Recherche avancée

Sur d’autres sites (3492)

• C++ ffmpeg API created video does not open in some players

  18 novembre 2017, par ar2015

  After my previous question, I found codes from here to create videos in C++ using avcodec of ffmpeg libraries.

  I have modified this code to comply with C++. Everything is fine and it creates mp4 videos. Except for the output video opens with some video managers and does not open with some others.

  E.g. I can open it on Linux by totem (the slider does not allow back and forth anyway). But VLC (on the same Linux machine) does not open this file. Probably, there will be similar problem in windows.

  Is there any missing process for this code causing this problem ?

  #include 
  
  #include 
  
  #include 
  
  #include <string>
  
  #include <iostream>
  
  
  
  extern "C" {
  
      #include <libavcodec></libavcodec>avcodec.h>
  
      #include <libavutil></libavutil>opt.h>
  
      #include <libavutil></libavutil>imgutils.h>
  
  }
  
  
  
  static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,
  
                     FILE *outfile)
  
  {
  
      int ret;
  
  
  
      /* send the frame to the encoder */
  
      if (frame)
  
          std::cout&lt;&lt;"Send frame "&lt;&lt;(frame->pts)&lt;= 0) {
  
          ret = avcodec_receive_packet(enc_ctx, pkt);
  
          if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
              return;
  
          else if (ret &lt; 0) {
  
              fprintf(stderr, "Error during encoding\n");
  
              exit(1);
  
          }
  
  
  
          std::cout&lt;&lt;"Write packet "&lt;&lt;(pkt->pts)&lt;&lt;" (size="&lt;&lt;(pkt->size)&lt;&lt;")"&lt;/ printf("Write packet %3" PRId64" (size=%5d)\n", pkt->pts, pkt->size);
  
          fwrite(pkt->data, 1, pkt->size, outfile);
  
          av_packet_unref(pkt);
  
      }
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      const char *filename;
  
      const AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      int i, ret, x, y;
  
      FILE *f;
  
      AVFrame *frame;
  
      AVPacket *pkt;
  
      uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  
  
      if (argc &lt; 2) {
  
          fprintf(stderr, "Usage: %s <output file="file">\n", argv[0]);
  
          exit(0);
  
      }
  
      filename = argv[1];
  
      std::string codec_name = "mpeg4";
  
  
  
      avcodec_register_all();
  
  
  
      /* find the mpeg1video encoder */
  
      codec = avcodec_find_encoder_by_name(codec_name.c_str());
  
      if (!codec) {
  
          fprintf(stderr, "Codec '%s' not found\n", codec_name.c_str());
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
      if (!c) {
  
          fprintf(stderr, "Could not allocate video codec context\n");
  
          exit(1);
  
      }
  
  
  
      pkt = av_packet_alloc();
  
      if (!pkt)
  
          exit(1);
  
  
  
      /* put sample parameters */
  
      // c->bit_rate = 400000;
  
      c->bit_rate = 4000000;
  
      /* resolution must be a multiple of two */
  
      // c->width = 352;
  
      // c->height = 288;
  
      c->width = 640;
  
      c->height = 480;
  
      /* frames per second */
  
      c->time_base = (AVRational){1, 25};
  
      c->framerate = (AVRational){25, 1};
  
  
  
      /* emit one intra frame every ten frames
  
       * check frame pict_type before passing frame
  
       * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
  
       * then gop_size is ignored and the output of encoder
  
       * will always be I frame irrespective to gop_size
  
       */
  
      c->gop_size = 10;
  
      c->max_b_frames = 1;
  
      c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
      if (codec->id == AV_CODEC_ID_H264)
  
          av_opt_set(c->priv_data, "preset", "slow", 0);
  
  
  
      /* open it */
  
      ret = avcodec_open2(c, codec, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not open codec\n");
  
          // fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      f = fopen(filename, "wb");
  
      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->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);
  
      }
  
  
  
      /* encode 10 second of video */
  
      for (i = 0; i &lt; 250; i++) {
  
          fflush(stdout);
  
  
  
          /* make sure the frame data is writable */
  
          ret = av_frame_make_writable(frame);
  
          if (ret &lt; 0)
  
              exit(1);
  
  
  
          /* prepare a dummy image */
  
          /* Y */
  
          for (y = 0; y &lt; c->height; y++) {
  
              for (x = 0; x &lt; c->width; x++) {
  
                  frame->data[0][y * frame->linesize[0] + x] = uint8_t(x + y + i * 3);
  
              }
  
          }
  
  
  
          /* Cb and Cr */
  
          for (y = 0; y &lt; c->height/2; y++) {
  
              for (x = 0; x &lt; c->width/2; x++) {
  
                  frame->data[1][y * frame->linesize[1] + x] = uint8_t(128 + y + i * 2);
  
                  frame->data[2][y * frame->linesize[2] + x] = uint8_t(64 + x + i * 5);
  
              }
  
          }
  
  
  
          frame->pts = i;
  
  
  
          /* encode the image */
  
          encode(c, frame, pkt, f);
  
      }
  
  
  
      /* flush the encoder */
  
      encode(c, NULL, pkt, f);
  
  
  
      /* add sequence end code to have a real MPEG file */
  
      fwrite(endcode, 1, sizeof(endcode), f);
  
      fclose(f);
  
  
  
      avcodec_free_context(&amp;c);
  
      av_frame_free(&amp;frame);
  
      av_packet_free(&amp;pkt);
  
  
  
      return 0;
  
  }
  
  </output></iostream></string>

  build :

  g++ -I ./FFmpeg/ video.cpp -L ./fflibs -lavdevice -lavfilter -lavformat -lavcodec -lrt -ldl -lXfixes -lXext -lX11 -lasound -lSDL -lz -lrt -lswresample -lswscale -lavutil -lm -llzma -lbz2 -lswresample -lpthread

  run

  ./a.out myvideo.mp4

  This video will be fine if converted in bash via

  ffmpeg -i myvideo.mp4 out1.mp4

  But I look for a method to fix it from the code.

  Generated video played on totem (Ubuntu) :

  

  Video after conversion :

  

• Encoding H.264 CBR videos with FFmpeg

  3 février 2018, par Cornstalks

  I’m trying to encode a video with ffmpeg into H.264 (via the libx264 library) with a constant bit rate. I know, I know, VBR is often preferred, but for this specific job I’m required to use CBR (just as long as it’s so many kilobytes per second ; it doesn’t have to be an exact kilobytes per frame, afaik). My sample video I’m using to test is from here : http://a1408.g.akamai.net/5/1408/1388/2005110403/1a1a1ad948be278cff2d96046ad90768d848b41947aa1986/sample_iTunes.mov.zip (it comes from http://support.apple.com/kb/HT1425)

  I can get a constant bit rate when encoding the video with MPEG-4 Video (using the commands ffmpeg -i sample_iTunes.mov -b 819968 -minrate 819968 -maxrate 819968 out.mov), and the bit rate is as expected. Reading the video’s specs via the QuickTime Inspector, it’s got a data rate of 844.94 kbit/s. Cool.

  However, when I change the codec to libx264, it seems to completely ignore my bitrate requests ! The command I’m trying is "ffmpeg -i sample_iTunes.mov -vcodec libx264 -vpre medium -b 819968 -vb 819968 -minrate 819968 -maxrate 819968 -bufsize 400000 test.mov". But when I check the video’s specs via the QuickTime Inspector, it’s got a data rate of 254.74 kbit/s. WTF ? That’s not even close !

  I’ve tried changing so many parameters and adding tons of different things, and I’ve spent 2 days googling this, but I can’t seem to get it to work. If I encode the video with the MainConcept H.264 encoder, I can get a constant bitrate, but I need this to work with ffmpeg.

  If someone can help me figure out how to do CBR H.264 encoding with FFmpeg, I will love you forever !

• Assigning of dts values to encoded packets

  24 mars, par Alex

  I have a dump of H264-encoded data, which I need to put in mp4 container. I verified the validity of the encoded data by using mp4box utility against it. The mp4 file created by mp4box contained a proper 17 seconds long video. It is interesting that if I try ffmpeg to achieve the same, the resulting video is 34 seconds long and rather crappy (probably ffmpeg tries to decode video and then encode it, which results in the loss of video quality ?) Anyway, for my project I can't use command line approach and need to come up wit a programmatic way to embed the data in the mp4 container.

  



  Below is the code I use (I removed error checking for brevity. During execution all the calls succeed) :

  



  AVFormatContext* pInputFormatContext = avformat_alloc_context();
avformat_open_input(&pInputFormatContext, "Data.264", NULL, NULL);
avformat_find_stream_info(pInputFormatContext, NULL);
AVRational* pTime_base = &pInputFormatContext->streams[0]->time_base;

int nFrameRate = pInputFormatContext->streams[0]->r_frame_rate.num / pFormatCtx->streams[0]->r_frame_rate.den;
int nWidth = pInputFormatContext->streams[0]->codecpar->width;
int nHeight = pInputFormatContext->streams[0]->codecpar->height;
// nWidth = 1920, nHeight = 1080, nFrameRate = 25

// Create output objects
AVFormatContext* pOutputFormatContext = NULL;
avformat_alloc_output_context2(&pOutputFormatContext, NULL, NULL, "Destination.mp4");

AVCodec* pVideoCodec = avcodec_find_encoder(pOutputFormatContext->oformat->video_codec/*AV_CODEC_ID_264*/);
AVStream* pOutputStream = avformat_new_stream(pOutputFormatContext, NULL);
pOutputStream->id = pOutputFormatContext->nb_streams - 1;
AVCodecContext* pCodecContext = avcodec_alloc_context3(pVideoCodec);

switch (pVideoCodec->type) {
case AVMEDIA_TYPE_VIDEO:
  pCodecContext->codec_id = codec_id;
  pCodecContext->bit_rate = 400000;
  /* Resolution must be a multiple of two. */
  pCodecContext->width = nFrameWidth;
  pCodecContext->height = nFrameHeight;
  /* timebase: This is the fundamental unit of time (in seconds) in terms
  * of which frame timestamps are represented. For fixed-fps content,
  * timebase should be 1/framerate and timestamp increments should be
  * identical to 1. */
  pOutputStream->time_base.num = 1;
  pOutputStream->time_base.den = nFrameRate;
  pCodecContext->time_base = pOutputStream->time_base;
  pCodecContext->gop_size = 12; /* emit one intra frame every twelve frames at most */
  pCodecContext->pix_fmt = STREAM_PIX_FMT;
  break;
default:
  break;
}

/* copy the stream parameters to the muxer */
avcodec_parameters_from_context(pOutputStream->codecpar, pCodecContext);

avio_open(&pOutputFormatContext->pb, "Destination.mp4", AVIO_FLAG_WRITE);

// Start writing
AVDictionary* pDict = NULL;
avformat_write_header(pOutputFormatContext, &pDict);

// Process packets
AVPacket packet;
int64_t nCurrentDts = 0;
int64_t nDuration = 0;
int nReadResult = 0;

while (nReadResult == 0)
{
  nReadResult = av_read_frame(m_pInputFormatContext, &packet);
// At this point, packet.dts == AV_NOPTS_VALUE. 
// The duration field of the packet contains valid data

  packet.flags |= AV_PKT_FLAG_KEY;
  nDuration = packet.duration;
  packet.dts = nCurrentDts;
  packet.dts = av_rescale_q(nCurrentDts, pOutputFormatContext->streams[0]->codec->time_base, pOutputFormatContext->streams[0]->time_base);
  av_interleaved_write_frame(pOutputFormatContext, &packet);
  nCurrentDts += nDuration;
  nDuration += packet.duration;
  av_free_packet(&packet);
}

av_write_trailer(pOutputFormatContext);


  



  The properties for the Destination.mp4 file I receive indicate it is about 1 hour long with frame rate 0. I am sure the culprit is in the way I calculate dts values for each packet and use av_rescale_q(), but I do not have sufficient understanding of the avformat library to figure out the proper way to do it. Any help will be appreciated !