Recherche avancée

Sur d’autres sites (3027)

• libavutil : Adds gray floating-point pixel formats.

  3 août 2018, par Sergey Lavrushkin

  libavutil : Adds gray floating-point pixel formats.
  Signed-off-by : Michael Niedermayer <michael@niedermayer.cc>
  

  • [DH] libavutil/pixdesc.c
  • [DH] libavutil/pixfmt.h
  • [DH] libavutil/version.h
  • [DH] tests/ref/fate/sws-pixdesc-query

• Adding transparency to a video from black and white (and gray) alpha information video images

  3 juillet 2018, par Jan F.

  I’d like to create a video with transparency (and semi transparency) in android. The images of the source video are split into two images, the top one with color information (looks like the normal video image), the bottom one with alpha information (the same shapes but only in black and white and gray, black means transparent).

  This is the solution for iOS :
  https://medium.com/@quentinfasquel/ios-transparent-video-with-coreimage-52cfb2544d54

  What would be the best way to to this in android ?

  Can this be solved with javacv, FFmpegFrameGrabber, FFmpegFrameFilter etc.?

  Or better with OpenGL ES and shaders ?

  Are there any samples ?

  Thanks !

• Decoding of 16bit gray image encoded with FFV1

  15 juin 2018, par Domin W

  I have a problem with decoding of gray images encoded with FFV1 codec.
  I successfully encode 16 bit gray image (with avcodec_receive_packet(...) function) and save AvPacket data to file. Then I read this data from file and try to decode (with avcodec_decode_video2 or avcodec_send_packet/avcodec_receive_frame) with no success :

  • when I try to decode packet with avcodec_decode_video2 function I get an error "Access violation occurred, unable to write location 0x0000000000000000".
  • when I try to decode packet with avcodec_send_packet/avcodec_receive_frame functions I get an error "chroma shift parameters 7 0 are invalid".

  I compared packets after encoding and before decoding and all fields and values seems to be the same. I even try to decode packet just after avcodec_receive_packet (encoding function), however with the same error.

  I use the 4.0 version of ffmpeg and the program is based on decode_video.c and encode_video.c examples.
  When I use containers (eg. avi) to support read/write encoded images from file (based on demuxing_decoding.c and muxing.c examples) I successfully encode and decode frames with FFV1. However I cannot use containers, because I want to encode frames with different resolutions and mix few video sources together. Additionally the compression level is significantly lower (falls from 2.9 to 2.2) for few hundred of images, what is also very surprising.

  So my question is how to correctly save/read (from binary file not container) and prepare AVPacker for decoding with FFV1.

  Any help is greatly appreciated.

  The decoding code :

  extern "C" {
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavutil></libavutil>opt.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  }
  
  #pragma warning(disable: 4996)
  
  #define INBUF_SIZE 4096
  
  #define FF_INPUT_BUFFER_PADDING_SIZE 64
  
  
  
  uint8_t endcode[4];
  
  AVCodecContext *c, c2;
  
  AVCodec *codec;
  
  int i, ret, x, y;
  
  AVFrame *frame;
  
  AVPacket *pkt, *pkt_temp;
  
  
  
  FILE *encodedVideoFile;
  
  AVDictionary *opts = NULL;
  
  uint8_t *video_dst_data[4] = { NULL };
  
  int      video_dst_linesize[4];
  
  int imageSize;
  
  uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
  
  /* flush the encoder */
  
      frame = NULL;
  
      encode();
  
      /* add sequence end code to have a real MPEG file */
  
      //fwrite(endcode, 1, sizeof(endcode), encodedVideoFile);
  
      fclose(encodedVideoFile);
  
      avcodec_free_context(&amp;c);
  
      av_frame_free(&amp;frame);
  
      av_packet_free(&amp;pkt);
  
  }
  
  
  
  void initDecoding(const char *filename)
  
  {
  
      /* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
  
      memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  
      /* find the MPEG-1 video decoder */
  
      codec = avcodec_find_decoder(AV_CODEC_ID_FFV1);
  
      if (!codec) {
  
          fprintf(stderr, "Codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
      if (!c) {
  
          fprintf(stderr, "Could not allocate video codec context\n");
  
          exit(1);
  
      }
  
  
  
      /* resolution must be a multiple of two */
  
      c->width = 1280;
  
      c->height = 484;
  
      /* frames per second */
  
      c->time_base.den = 1;
  
      c->time_base.num = 10;
  
      c->bits_per_raw_sample = 16;
  
  
  
      c->framerate.den = 10;
  
      c->framerate.num = 1;
  
  
  
      c->pix_fmt = AV_PIX_FMT_GRAY16;
  
  
  
      //Version of FFV1 codec
  
      c->level = 3;
  
  
  
      /* Init the decoders, with or without reference counting */
  
      av_dict_set(&amp;opts, "refcounted_frames", 0 ? "1" : "0", 0);
  
      if ((ret = avcodec_open2(c, codec, &amp;opts)) &lt; 0) {
  
          return;
  
      }
  
  
  
      if (avcodec_open2(c, codec, NULL) &lt; 0) {
  
          fprintf(stderr, "Could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      ret = av_image_alloc(video_dst_data, video_dst_linesize,
  
          c->width, c->height, c->pix_fmt, 4);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not allocate raw video buffer\n");
  
      }
  
  
  
      encodedVideoFile = fopen(filename, "rb");
  
      if (!encodedVideoFile) {
  
          fprintf(stderr, "Could not open %s\n", filename);
  
          exit(1);
  
      }
  
  
  
      frame = av_frame_alloc();
  
      if (!frame) {
  
          fprintf(stderr, "Could not allocate video frame\n");
  
          exit(1);
  
      }
  
  
  
      frame->format = c->pix_fmt;
  
      frame->width = c->width;
  
      frame->height = c->height;
  
  
  
      ret = av_frame_get_buffer(frame, 32);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not allocate the video frame data\n");
  
          exit(1);
  
      }
  
  
  
      /* make sure the frame data is writable */
  
      ret = av_frame_make_writable(frame);
  
      if (ret &lt; 0)
  
          exit(1);
  
  }
  
  
  
  void closeDecoding()
  
  {
  
      fclose(encodedVideoFile);
  
      av_parser_close(parser);
  
      avcodec_free_context(&amp;c);
  
      av_frame_free(&amp;frame);
  
      av_packet_free(&amp;pkt);
  
  }
  
  
  
  void decodePacket()
  
  {
  
      size_t data_size;
  
      int *got_frame = 0;
  
  
  
      read_packt_from_file(pkt, encodedVideoFile);        
  
  
  
      ret = av_frame_is_writable(frame);
  
  
  
      //First decoding function
  
      /*ret = avcodec_decode_video2(c, frame, got_frame, pkt);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error decoding video frame (%s)\n");
  
  
  
      }*/
  
  
  
      ret = avcodec_send_packet(c, pkt);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error sending a packet for decoding\n");
  
          exit(1);
  
      }
  
      while (ret >= 0) {
  
          ret = avcodec_receive_frame(c, frame);
  
          if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
              return;
  
          else if (ret &lt; 0) {
  
              fprintf(stderr, "Error during decoding\n");
  
              exit(1);
  
          }
  
          printf("saving frame %3d\n", c->frame_number);
  
  
  
          fflush(stdout);
  
  
  
      }
  
  
  
  }
  
  
  
  size_t read_packt_from_file(AVPacket *packet, FILE *file)
  
  {
  
      size_t ret = 0;
  
      int size;
  
      uint8_t * data;
  
      //av_packet_from_data
  
      ret = fread(packet, sizeof(AVPacket), 1, file);
  
      size = packet->size;
  
      data = new uint8_t[size];
  
      ret = fread(data, size, 1, file);
  
      av_new_packet(packet, size);
  
      av_packet_from_data(packet, data, size);
  
  
  
      return ret;
  
  }
  
  //To write encoded AVPacket
  
  size_t write_packt_to_file(AVPacket *packet, FILE *file)
  
  {
  
      size_t ret = 0;
  
      ret = fwrite(packet, sizeof(AVPacket), 1, file);
  
      ret = fwrite(packet->data, packet->size, 1, file);
  
      if (packet->buf) {
  
          fwrite(packet->buf->data, packet->buf->size, 1, file);
  
      }
  
      fflush(file);
  
      return ret;
  
  }