Recherche avancée

Sur d’autres sites (5822)

• FFMPEG avformat_write_header changing my stream time_base

  12 juillet 2019, par cesarpachon

  I am muxing video using ffmpeg 2.1.3 with libavcodec 55.39.101 (forced to that version because is the one available in google-chrome PNACL port project). all my frames seems to have bad the time. they try to be rendered all at once at the beggining of the video when playing it.

  I am setting the stream time base to 1/25, but just after calling avformat_write_header, it has the value of -18082736/1.
  in each frame, when I print the stream time_base it says 1/12800, while the time_base of codec is always ok (1/25).

  console log before and after av_format_write_header :

  before avformat_write_header stream time_base: 1/25
  
  after avformat_write_header ret 0 stream time_base: -18082736/1

  the code (abreviated to keep the post short, all calls in the original version had error checking) :

  AVCodecContext *codecContext;
  
  AVCodec * codec = avcodec_find_encoder(codec_id);  
  
  myOutputStream->stream = avformat_new_stream(outputFormatContext, *codec);
  
  myOutputStream->stream->id = outputFormatContext->nb_streams-1;
  
  codecContext = myOutputStream->stream->codec;
  
  codecContext->codec_id = codec_id;
  
  codecContext->bit_rate = 400000;
  
  codecContext->width    = width;
  
  codecContext->height   = height;
  
  myOutputStream->stream->time_base = (AVRational){ 1, 25 };
  
  codecContext->time_base       = myOutputStream->stream->time_base;
  
  codecContext->gop_size      = 12; 
  
  codecContext->pix_fmt       = AV_PIX_FMT_YUV420P;
  
  AVDictionary *opt = NULL;
  
  av_dict_copy(&opt, opt_arg, 0);
  
  ret = avcodec_open2(codecContext, codec, &opt);
  
  av_dict_free(&opt);
  
  myOutputStream->frame = alloc_picture(codecContext->pix_fmt, codecContext->width, codecContext->height);
  
    myOutputStream->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, codecContext->width, codecContext->height);
  
  
  
  //before: printing g_outputContext->stream time_base here
  
  ret = avformat_write_header(g_outputContext, &opt);
  
  //after: printing g_outputContext->stream time_base here

  If I run ffmpeg -i on the final video, I got this (why duration is zero ?) :

  Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'test4.mp4':
  
    Metadata:
  
      major_brand     : isom
  
      minor_version   : 512
  
      compatible_brands: isomiso2mp41
  
      encoder         : Lavf55.19.104
  
    Duration: 00:00:00.05, start: 0.000000, bitrate: 99549 kb/s
  
      Stream #0:0(und): Video: mpeg4 (Simple Profile) (mp4v / 0x7634706D), yuv420p, 800x600 [SAR 1:1 DAR 4:3], 463106 kb/s, 12800 fps, 12800 tbr, 12800 tbn, 25 tbc (default)
  
      Metadata:
  
        handler_name    : VideoHandler

• Why is the AV_PARSER_PARSE2 in ffmpeg returning empty AVPacket data for HEVC video ?

  3 août 2019, par HAlmawi

  I’m attempting to decode an HEVC encoded video (.mp4 format) and extract all the frames in C++. I installed ffmpeg and used one of their examples "video_decode.c", however the AVPacket data (pkt->data) is always NULL/empty and the size of the packet (pkt->size) is always 0.

  I have executed ffprobe on the video examples used to ensure that the videos were truly in HEVC format.

  I defined the width, height, pixel format, bit rate, and time base of the AVCodec.

  I initialized the AVPacket data to NULL and size to 0 manually.

  const char *filename, *outfilename;
  
  const AVCodec *codec;
  
  AVCodecParserContext *parser;
  
  AVCodecContext *c = NULL;
  
  FILE *f;
  
  AVFrame *frame;
  
  uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
  
  uint8_t *data;
  
  size_t   data_size;
  
  int ret;
  
  AVPacket *pkt;
  
  
  
  filename = "C:\\Users\\Me\\Downloads\\video_x265.mp4";
  
  outfilename = "E:\\output\\test%d.pgm";
  
  
  
  pkt = av_packet_alloc();
  
  if (!pkt)
  
      exit(1);
  
  //pkt->data = NULL;
  
  //pkt->size = 0;
  
  /* 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_HEVC);
  
  if (!codec) {
  
      fprintf(stderr, "Codec not found\n");
  
      exit(1);
  
  }
  
  
  
  parser = av_parser_init(codec->id);
  
  if (!parser) {
  
      fprintf(stderr, "parser not found\n");
  
      exit(1);
  
  }
  
  
  
  c = avcodec_alloc_context3(codec);
  
  if (!c) {
  
      fprintf(stderr, "Could not allocate video codec context\n");
  
      exit(1);
  
  }
  
  
  
  /* For some codecs, such as msmpeg4 and mpeg4, width and height
  
  MUST be initialized there because this information is not
  
  available in the bitstream. */
  
  c->width = WIDTH;
  
  c->height = HEIGHT;
  
  c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  c->bit_rate = 400000;
  
  c->time_base = (AVRational) { 1, 25 };
  
  
  
  /* open it */
  
  if (avcodec_open2(c, codec, NULL) < 0) {
  
      fprintf(stderr, "Could not open codec\n");
  
      exit(1);
  
  }
  
  
  
  f = fopen(filename, "rb");
  
  if (!f) {
  
      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->width = c->width;
  
  frame->height = c->height;
  
  
  
  while (!feof(f)) {
  
      /* read raw data from the input file */
  
      data_size = fread(inbuf, 1, INBUF_SIZE, f);
  
      if (!data_size)
  
          break;
  
  
  
      /* use the parser to split the data into frames */
  
      data = inbuf;
  
      while (data_size > 0) {
  
          ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,
  
                  data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
  
          printf("pkt size: %d\n",pkt->size);
  
          if (ret < 0) {
  
              fprintf(stderr, "Error while parsing\n");
  
              exit(1);
  
          }
  
          data += ret;
  
          data_size -= ret;
  
  
  
          if (pkt->size)
  
              decode(c, frame, pkt, outfilename);
  
      }
  
  }

• x264 encoded frames into a mp4 container with ffmpeg API

  10 septembre 2019, par PJD

  I’m struggling with understanding what is and what is not needed in getting my already encoded x264 frames into a video container file using ffmpeg’s libavformat API.

  My current program will get the x264 frames like this -

  while( x264_encoder_delayed_frames( h ) )
  
  {
  
      printf("Writing delayed frame %u\n", delayed_frame_counter++);
  
      i_frame_size = x264_encoder_encode( h, &nal, &i_nal, NULL, &pic_out );
  
      if( i_frame_size < 0 ) {
  
              printf("Failed to encode a delayed x264 frame.\n");
  
              return ERROR;
  
          }
  
      else if( i_frame_size )
  
      {
  
          if( !fwrite(nal->p_payload, i_frame_size, 1, video_file_ptr) ) {
  
              printf("Failed to write a delayed x264 frame.\n");
  
              return ERROR;
  
          }
  
      }
  
  }

  If I use the CLI to the ffmpeg binary, I can put these frames into a container using :

  ffmpeg -i "raw_frames.h264" -c:v copy -f mp4 "video.mp4"

  I would like to code this function into my program using the libavformat API though. I’m a little stuck in the concepts and the order on which each ffmpeg function is needed to be called.

  So far I have written :

          mAVOutputFormat = av_guess_format("gen_vid.mp4", NULL, NULL);
  
          printf("Guessed format\n");
  
  
  
          int ret = avformat_alloc_output_context2(&mAVFormatContext, NULL, NULL, "gen_vid.mp4");
  
          printf("Created context = %d\n", ret);
  
          printf("Format = %s\n", mAVFormatContext->oformat->name);
  
  
  
          mAVStream = avformat_new_stream(mAVFormatContext, 0);
  
          if (!mAVStream) {
  
              printf("Failed allocating output stream\n");
  
          } else {
  
              printf("Allocated stream.\n");
  
          }
  
  
  
          mAVCodecParameters = mAVStream->codecpar;
  
          if (mAVCodecParameters->codec_type != AVMEDIA_TYPE_AUDIO &&
  
              mAVCodecParameters->codec_type != AVMEDIA_TYPE_VIDEO &&
  
              mAVCodecParameters->codec_type != AVMEDIA_TYPE_SUBTITLE) {
  
              printf("Invalid codec?\n");
  
          }
  
  
  
          if (!(mAVFormatContext->oformat->flags & AVFMT_NOFILE)) {
  
              ret = avio_open(&mAVFormatContext->pb, "gen_vid.mp4", AVIO_FLAG_WRITE);
  
              if (ret < 0) {
  
                printf("Could not open output file '%s'", "gen_vid.mp4");
  
              }
  
            }
  
  
  
          ret = avformat_write_header(mAVFormatContext, NULL);
  
          if (ret < 0) {
  
            printf("Error occurred when opening output file\n");
  
          }

  This will print out :

  Guessed format
  
  Created context = 0
  
  Format = mp4
  
  Allocated stream.
  
  Invalid codec?
  
  [mp4 @ 0x55ffcea2a2c0] Could not find tag for codec none in stream #0, codec not currently supported in container
  
  Error occurred when opening output file

  How can I make sure the codec type is set correctly for my video ?
  Next I need to somehow point my mAVStream to use my x264 frames - advice would be great.

  Update 1 :
  So I’ve tried to set the H264 codec, so the codec’s meta-data is available. I seem to hit 2 newer issues now.
  1) It cannot find the device and therefore cannot configure the encoder.
  2) I get the "dimensions not set".

  mAVOutputFormat = av_guess_format("gen_vid.mp4", NULL, NULL);
  
  printf("Guessed format\n");
  
  
  
  // MUST allocate the media file format context. 
  
  int ret = avformat_alloc_output_context2(&mAVFormatContext, NULL, NULL, "gen_vid.mp4");
  
  printf("Created context = %d\n", ret);
  
  printf("Format = %s\n", mAVFormatContext->oformat->name);
  
  
  
  // Even though we already have encoded the H264 frames using x264,
  
  // we still need the codec's meta-data.
  
  const AVCodec *mAVCodec;
  
  mAVCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
  
  if (!mAVCodec) {
  
      fprintf(stderr, "Codec '%s' not found\n", "H264");
  
      exit(1);
  
  }
  
  mAVCodecContext = avcodec_alloc_context3(mAVCodec);
  
  if (!mAVCodecContext) {
  
      fprintf(stderr, "Could not allocate video codec context\n");
  
      exit(1);
  
  }
  
  printf("Codec context allocated with defaults.\n");
  
  /* put sample parameters */
  
  mAVCodecContext->bit_rate = 400000;
  
  mAVCodecContext->width = width;
  
  mAVCodecContext->height = height;
  
  mAVCodecContext->time_base = (AVRational){1, 30};
  
  mAVCodecContext->framerate = (AVRational){30, 1};
  
  mAVCodecContext->gop_size = 10;
  
  mAVCodecContext->level = 31;
  
  mAVCodecContext->max_b_frames = 1;
  
  mAVCodecContext->pix_fmt = AV_PIX_FMT_NV12;
  
  
  
  av_opt_set(mAVCodecContext->priv_data, "preset", "slow", 0);
  
  printf("Set codec parameters.\n");
  
  
  
  // Initialize the AVCodecContext to use the given AVCodec.
  
  avcodec_open2(mAVCodecContext, mAVCodec, NULL);            
  
  
  
  // Add a new stream to a media file. Must be called before
  
  // calling avformat_write_header().
  
  mAVStream = avformat_new_stream(mAVFormatContext, mAVCodec);
  
  if (!mAVStream) {
  
      printf("Failed allocating output stream\n");
  
  } else {
  
      printf("Allocated stream.\n");
  
  }
  
  
  
  // TODO How should codecpar be set?
  
  mAVCodecParameters = mAVStream->codecpar;
  
  if (mAVCodecParameters->codec_type != AVMEDIA_TYPE_AUDIO &&
  
      mAVCodecParameters->codec_type != AVMEDIA_TYPE_VIDEO &&
  
      mAVCodecParameters->codec_type != AVMEDIA_TYPE_SUBTITLE) {
  
      printf("Invalid codec?\n");
  
  }
  
  
  
  if (!(mAVFormatContext->oformat->flags & AVFMT_NOFILE)) {
  
      ret = avio_open(&mAVFormatContext->pb, "gen_vid.mp4", AVIO_FLAG_WRITE);
  
      if (ret < 0) {
  
        printf("Could not open output file '%s'", "gen_vid.mp4");
  
      }
  
    }
  
  printf("Called avio_open()\n");
  
  
  
  // MUST write a header.
  
  ret = avformat_write_header(mAVFormatContext, NULL);
  
  if (ret < 0) {
  
    printf("Error occurred when opening output file (writing header).\n");
  
  }

  Now I am getting this output -

  Guessed format
  
  Created context = 0
  
  Format = mp4
  
  Codec context allocated with defaults.
  
  Set codec parameters.
  
  [h264_v4l2m2m @ 0x556460344b40] Could not find a valid device
  
  [h264_v4l2m2m @ 0x556460344b40] can't configure encoder
  
  Allocated stream.
  
  Invalid codec?
  
  Called avio_open()
  
  [mp4 @ 0x5564603442c0] Using AVStream.codec to pass codec parameters to muxers is deprecated, use AVStream.codecpar instead.
  
  [mp4 @ 0x5564603442c0] dimensions not set
  
  Error occurred when opening output file (writing header).