Recherche avancée

Sur d’autres sites (12027)

• ffmpeg : capture rtsp stream continously without stoping

  21 décembre 2019, par Santhosh Yedidi

  I am trying to capture an rtsp stream

  ffmpeg -rtsp_transport tcp -i "rtsp://...." -acodec copy -vcodec copy file.ts

  But this will only record for few seconds and stop

  ffmpeg version n4.1.2 Copyright (c) 2000-2019 the FFmpeg developers
  
    built with gcc 8.2.1 (GCC) 20181127
  
    configuration: --prefix=/usr --disable-debug --disable-static --disable-stripping --enable-fontconfig --enable-gmp --enable-gnutls --enable-gpl --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libdrm --enable-libfreetype --enable-libfribidi --enable-libgsm --enable-libiec61883 --enable-libjack --enable-libmodplug --enable-libmp3lame --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libopenjpeg --enable-libopus --enable-libpulse --enable-libsoxr --enable-libspeex --enable-libssh --enable-libtheora --enable-libv4l2 --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxcb --enable-libxml2 --enable-libxvid --enable-nvdec --enable-nvenc --enable-omx --enable-shared --enable-version3
  
    libavutil      56. 22.100 / 56. 22.100
  
    libavcodec     58. 35.100 / 58. 35.100
  
    libavformat    58. 20.100 / 58. 20.100
  
    libavdevice    58.  5.100 / 58.  5.100
  
    libavfilter     7. 40.101 /  7. 40.101
  
    libswscale      5.  3.100 /  5.  3.100
  
    libswresample   3.  3.100 /  3.  3.100
  
    libpostproc    55.  3.100 / 55.  3.100
  
  [rtsp @ 0x564a002b4e80] max delay reached. need to consume packet
  
  [rtsp @ 0x564a002b4e80] RTP: missed 3 packets
  
  [h264 @ 0x564a002b8a80] out of range intra chroma pred mode
  
  [h264 @ 0x564a002b8a80] error while decoding MB 8 43
  
  [h264 @ 0x564a002b8a80] concealing 1401 DC, 1401 AC, 1401 MV errors in I frame
  
  Input #0, rtsp, from 'rtsp://...':
  
    Metadata:
  
      title           : RTSP Session/2.0
  
    Duration: N/A, start: 0.463333, bitrate: N/A
  
      Stream #0:0: Video: h264 (Main), yuvj420p(pc, progressive), 1280x960, 15 fps, 100 tbr, 90k tbn, 30 tbc
  
  Output #0, mpegts, to 'file.ts':
  
    Metadata:
  
      title           : RTSP Session/2.0
  
      encoder         : Lavf58.20.100
  
      Stream #0:0: Video: h264 (Main), yuvj420p(pc, progressive), 1280x960, q=2-31, 15 fps, 100 tbr, 90k tbn, 90k tbc
  
  Stream mapping:
  
    Stream #0:0 -> #0:0 (copy)
  
  Press [q] to stop, [?] for help
  
  frame=  380 fps= 16 q=-1.0 Lsize=    6962kB time=00:00:24.86 bitrate=2293.5kbits/s speed=1.06x    
  
  video:6416kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 8.512586%

  How to keep the recording continous

• IJG swings again, and misses

  1er février 2010, par Mans — Multimedia

  Earlier this month the IJG unleashed version 8 of its ubiquitous libjpeg library on the world. Eager to try out the “major breakthrough in image coding technology” promised in the README file accompanying v7, I downloaded the release. A glance at the README file suggests something major indeed is afoot :

  Version 8.0 is the first release of a new generation JPEG standard to overcome the limitations of the original JPEG specification.

  The text also hints at the existence of a document detailing these marvellous new features, and a Google search later a copy has found its way onto my monitor. As I read, however, my state of mind shifts from an initial excited curiosity, through bewilderment and disbelief, finally arriving at pure merriment.

  Already on the first page it becomes clear no new JPEG standard in fact exists. All we have is an unsolicited proposal sent to the ITU-T by members of the IJG. Realising that even the most brilliant of inventions must start off as mere proposals, I carry on reading. The summary informs me that I am about to witness the introduction of three extensions to the T.81 JPEG format :

  1. An alternative coefficient scan sequence for DCT coefficient serialization
  2. A SmartScale extension in the Start-Of-Scan (SOS) marker segment
  3. A Frame Offset definition in or in addition to the Start-Of-Frame (SOF) marker segment

  Together these three extensions will, it is promised, “bring DCT based JPEG back to the forefront of state-of-the-art image coding technologies.”

  Alternative scan

  The first of the proposed extensions introduces an alternative DCT coefficient scan sequence to be used in place of the zigzag scan employed in most block transform based codecs.

  

  Alternative scan sequence

  The advantage of this scan would be that combined with the existing progressive mode, it simplifies decoding of an initial low-resolution image which is enhanced through subsequent passes. The author of the document calls this scheme “image-pyramid/hierarchical multi-resolution coding.” It is not immediately obvious to me how this constitutes even a small advance in image coding technology.

  At this point I am beginning to suspect that our friend from the IJG has been trapped in a half-world between interlaced GIF images transmitted down noisy phone lines and today’s inferno of SVC, MVC, and other buzzwords.

  (Not so) SmartScale

  Disguised behind this camel-cased moniker we encounter a method which, we are told, will provide better image quality at high compression ratios. The author has combined two well-known (to us) properties in a (to him) clever way.

  The first property concerns the perceived impact of different types of distortion in an image. When encoding with JPEG, as the quantiser is increased, the decoded image becomes ever more blocky. At a certain point, a better subjective visual quality can be achieved by down-sampling the image before encoding it, thus allowing a lower quantiser to be used. If the decoded image is scaled back up to the original size, the unpleasant, blocky appearance is replaced with a smooth blur.

  The second property belongs to the DCT where, as we all know, the top-left (DC) coefficient is the average of the entire block, its neighbours represent the lowest frequency components etc. A top-left-aligned subset of the coefficient block thus represents a low-resolution version of the full block in the spatial domain.

  In his flash of genius, our hero came up with the idea of using the DCT for down-scaling the image. Unfortunately, he appears to possess precious little knowledge of sampling theory and human visual perception. Any block-based resampling will inevitably produce sharp artefacts along the block edges. The human visual system is particularly sensitive to sharp edges, so this is one of the most unwanted types of distortion in an encoded image.

  Despite the obvious flaws in this approach, I decided to give it a try. After all, the software is already written, allowing downscaling by factors of 8/8..16.

  Using a 1280×720 test image, I encoded it with each of the nine scaling options, from unity to half size, each time adjusting the quality parameter for a final encoded file size of no more than 200000 bytes. The following table presents the encoded file size, the libjpeg quality parameter used, and the SSIM metric for each of the images.

  Scale	Size	Quality	SSIM
  8/8	198462	59	0.940
  8/9	196337	70	0.936
  8/10	196133	79	0.934
  8/11	197179	84	0.927
  8/12	193872	89	0.915
  8/13	197153	92	0.914
  8/14	188334	94	0.899
  8/15	198911	96	0.886
  8/16	197190	97	0.869

  Although the smaller images allowed a higher quality setting to be used, the SSIM value drops significantly. Numbers may of course be misleading, but the images below speak for themselves. These are cut-outs from the full image, the original on the left, unscaled JPEG-compressed in the middle, and JPEG with 8/16 scaling to the right.

  

  

  Looking at these images, I do not need to hesitate before picking the JPEG variant I prefer.

  Frame offset

  The third and final extension proposed is quite simple and also quite pointless : a top-left cropping to be applied to the decoded image. The alleged utility of this feature would be to enable lossless cropping of a JPEG image. In a typical image workflow, however, JPEG is only used for the final published version, so the need for this feature appears quite far-fetched.

  The grand finale

  Throughout the text, the author makes references to “the fundamental DCT property for image representation.” In his own words :

  This property was found by the author during implementation of the new DCT scaling features and is after his belief one of the most important discoveries in digital image coding after releasing the JPEG standard in 1992.

  The secret is to be revealed in an annex to the main text. This annex quotes in full a post by the author to the comp.dsp Usenet group in a thread with the subject why DCT. Reading the entire thread proves quite amusing. A few excerpts follow.

  The actual reason is much simpler, and therefore apparently very difficult to recognize by complicated-thinking people.

  Here is the explanation :

  What are people doing when they have a bunch of images and want a quick preview ? They use thumbnails ! What are thumbnails ? Thumbnails are small downscaled versions of the original image ! If you want more details of the image, you can zoom in stepwise by enlarging (upscaling) the image.

  So with proper understanding of the fundamental DCT property, the MPEG folks could make their videos more scalable, but, as in the case of JPEG, they are unable to recognize this simple but basic property, unfortunately, and pursue rather inferior approaches in actual developments.

  These are just phrases, and they don’t explain anything. But this is typical for the current state in this field : The relevant people ignore and deny the true reasons, and thus they turn in a circle and no progress is being made.

  However, there are dark forces in action today which ignore and deny any fruitful advances in this field. That is the reason that we didn’t see any progress in JPEG for more than a decade, and as long as those forces dominate, we will see more confusion and less enlightenment. The truth is always simple, and the DCT *is* simple, but this fact is suppressed by established people who don’t want to lose their dubious position.

  I believe a trip to the Total Perspective Vortex may be in order. Perhaps his tin-foil hat will save him.

• How to reparse video with stable "overall bit rate" ? (FFmpeg)

  20 février 2018, par user3360601

  I have such code below :

  #include 
  
  #include 
  
  #include 
  
  
  
  extern "C"
  
  {
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libavfilter></libavfilter>buffersink.h>
  
  #include <libavfilter></libavfilter>buffersrc.h>
  
  #include <libavutil></libavutil>opt.h>
  
  #include <libavutil></libavutil>pixdesc.h>
  
  }
  
  
  
  static AVFormatContext *ifmt_ctx;
  
  static AVFormatContext *ofmt_ctx;
  
  
  
  typedef struct StreamContext {
  
      AVCodecContext *dec_ctx;
  
      AVCodecContext *enc_ctx;
  
  } StreamContext;
  
  static StreamContext *stream_ctx;
  
  
  
  static int open_input_file(const char *filename)
  
  {
  
      int ret;
  
      unsigned int i;
  
  
  
      ifmt_ctx = NULL;
  
      if ((ret = avformat_open_input(&amp;ifmt_ctx, filename, NULL, NULL)) &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
  
          return ret;
  
      }
  
  
  
      if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
  
          return ret;
  
      }
  
  
  
      stream_ctx = (StreamContext *) av_mallocz_array(ifmt_ctx->nb_streams, sizeof(*stream_ctx));
  
      if (!stream_ctx)
  
          return AVERROR(ENOMEM);
  
  
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          AVStream *stream = ifmt_ctx->streams[i];
  
          AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);
  
          AVCodecContext *codec_ctx;
  
          if (!dec) {
  
              av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);
  
              return AVERROR_DECODER_NOT_FOUND;
  
          }
  
          codec_ctx = avcodec_alloc_context3(dec);
  
          if (!codec_ctx) {
  
              av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);
  
              return AVERROR(ENOMEM);
  
          }
  
          ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "
  
                  "for stream #%u\n", i);
  
              return ret;
  
          }
  
          /* Reencode video &amp; audio and remux subtitles etc. */
  
          if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
  
              || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
  
              if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
  
                  codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
  
              /* Open decoder */
  
              ret = avcodec_open2(codec_ctx, dec, NULL);
  
              if (ret &lt; 0) {
  
                  av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
  
                  return ret;
  
              }
  
          }
  
          stream_ctx[i].dec_ctx = codec_ctx;
  
      }
  
  
  
      av_dump_format(ifmt_ctx, 0, filename, 0);
  
      return 0;
  
  }
  
  
  
  static int open_output_file(const char *filename)
  
  {
  
      AVStream *out_stream;
  
      AVStream *in_stream;
  
      AVCodecContext *dec_ctx, *enc_ctx;
  
      AVCodec *encoder;
  
      int ret;
  
      unsigned int i;
  
  
  
      ofmt_ctx = NULL;
  
      avformat_alloc_output_context2(&amp;ofmt_ctx, NULL, NULL, filename);
  
      if (!ofmt_ctx) {
  
          av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
  
          return AVERROR_UNKNOWN;
  
      }
  
  
  
  
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          out_stream = avformat_new_stream(ofmt_ctx, NULL);
  
          if (!out_stream) {
  
              av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
  
              return AVERROR_UNKNOWN;
  
          }
  
  
  
          in_stream = ifmt_ctx->streams[i];
  
          dec_ctx = stream_ctx[i].dec_ctx;
  
  
  
          //ofmt_ctx->bit_rate = ifmt_ctx->bit_rate;
  
          ofmt_ctx->duration = ifmt_ctx->duration;
  
  
  
          if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
  
              || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
  
              /* in this example, we choose transcoding to same codec */
  
              encoder = avcodec_find_encoder(dec_ctx->codec_id);
  
              if (!encoder) {
  
                  av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
  
                  return AVERROR_INVALIDDATA;
  
              }
  
              enc_ctx = avcodec_alloc_context3(encoder);
  
              if (!enc_ctx) {
  
                  av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
  
                  return AVERROR(ENOMEM);
  
              }
  
  
  
              /* In this example, we transcode to same properties (picture size,
  
              * sample rate etc.). These properties can be changed for output
  
              * streams easily using filters */
  
              if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  
                  enc_ctx->gop_size = dec_ctx->gop_size;
  
                  enc_ctx->bit_rate = dec_ctx->bit_rate;
  
                  enc_ctx->height = dec_ctx->height;
  
                  enc_ctx->width = dec_ctx->width;
  
                  enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
  
                  /* take first format from list of supported formats */
  
                  if (encoder->pix_fmts)
  
                      enc_ctx->pix_fmt = encoder->pix_fmts[0];
  
                  else
  
                      enc_ctx->pix_fmt = dec_ctx->pix_fmt;
  
                  /* video time_base can be set to whatever is handy and supported by encoder */
  
                  enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
  
                  enc_ctx->framerate = av_guess_frame_rate(ifmt_ctx, in_stream, NULL);
  
              }
  
              else {
  
                  enc_ctx->gop_size = dec_ctx->gop_size;
  
                  enc_ctx->bit_rate = dec_ctx->bit_rate;
  
                  enc_ctx->sample_rate = dec_ctx->sample_rate;
  
                  enc_ctx->channel_layout = dec_ctx->channel_layout;
  
                  enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
  
                  /* take first format from list of supported formats */
  
                  enc_ctx->sample_fmt = encoder->sample_fmts[0];
  
                  //enc_ctx->time_base = (AVRational){ 1, enc_ctx->sample_rate };
  
                  enc_ctx->time_base.num = 1;
  
                  enc_ctx->time_base.den = enc_ctx->sample_rate;
  
  
  
                  enc_ctx->framerate = av_guess_frame_rate(ifmt_ctx, in_stream, NULL);
  
              }
  
  
  
              /* Third parameter can be used to pass settings to encoder */
  
              ret = avcodec_open2(enc_ctx, encoder, NULL);
  
              if (ret &lt; 0) {
  
                  av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
  
                  return ret;
  
              }
  
              ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);
  
              if (ret &lt; 0) {
  
                  av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);
  
                  return ret;
  
              }
  
              if (ofmt_ctx->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
                  enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
  
  
              out_stream->time_base = enc_ctx->time_base;
  
              stream_ctx[i].enc_ctx = enc_ctx;
  
          }
  
          else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
  
              av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
  
              return AVERROR_INVALIDDATA;
  
          }
  
          else {
  
              /* if this stream must be remuxed */
  
              ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
  
              if (ret &lt; 0) {
  
                  av_log(NULL, AV_LOG_ERROR, "Copying parameters for stream #%u failed\n", i);
  
                  return ret;
  
              }
  
              out_stream->time_base = in_stream->time_base;
  
          }
  
  
  
      }
  
      av_dump_format(ofmt_ctx, 0, filename, 1);
  
  
  
      if (!(ofmt_ctx->oformat->flags &amp; AVFMT_NOFILE)) {
  
          ret = avio_open(&amp;ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
  
              return ret;
  
          }
  
      }
  
  
  
      /* init muxer, write output file header */
  
      ret = avformat_write_header(ofmt_ctx, NULL);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
  
          return ret;
  
      }
  
  
  
      return 0;
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      int ret;
  
      AVPacket packet = {0};
  
      packet.data = NULL;
  
      packet.size = 0 ;
  
      AVFrame *frame = NULL;
  
      enum AVMediaType type;
  
      unsigned int stream_index;
  
      unsigned int i;
  
      int got_frame;
  
      int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
  
  
  
      if (argc != 3) {
  
          av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file="file" /> <output file="file">\n", argv[0]);
  
          return 1;
  
      }
  
  
  
      av_register_all();
  
      avfilter_register_all();
  
  
  
      if ((ret = open_input_file(argv[1])) &lt; 0)
  
          goto end;
  
      if ((ret = open_output_file(argv[2])) &lt; 0)
  
          goto end;
  
  
  
      /* read all packets */
  
      while (1) {
  
          if ((ret = av_read_frame(ifmt_ctx, &amp;packet)) &lt; 0)
  
              break;
  
          stream_index = packet.stream_index;
  
          type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;
  
          av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n", stream_index);
  
  
  
          /* remux this frame without reencoding */
  
          av_packet_rescale_ts(&amp;packet,
  
              ifmt_ctx->streams[stream_index]->time_base,
  
              ofmt_ctx->streams[stream_index]->time_base);
  
  
  
          ret = av_interleaved_write_frame(ofmt_ctx, &amp;packet);
  
          if (ret &lt; 0)
  
              goto end;
  
  
  
          av_packet_unref(&amp;packet);
  
      }
  
  
  
      av_write_trailer(ofmt_ctx);
  
  end:
  
      av_packet_unref(&amp;packet);
  
      av_frame_free(&amp;frame);
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          avcodec_free_context(&amp;stream_ctx[i].dec_ctx);
  
          if (ofmt_ctx &amp;&amp; ofmt_ctx->nb_streams > i &amp;&amp; ofmt_ctx->streams[i] &amp;&amp; stream_ctx[i].enc_ctx)
  
              avcodec_free_context(&amp;stream_ctx[i].enc_ctx);
  
      }
  
      av_free(stream_ctx);
  
      avformat_close_input(&amp;ifmt_ctx);
  
      if (ofmt_ctx &amp;&amp; !(ofmt_ctx->oformat->flags &amp; AVFMT_NOFILE))
  
          avio_closep(&amp;ofmt_ctx->pb);
  
      avformat_free_context(ofmt_ctx);
  
  
  
      return ret ? 1 : 0;
  
  }
  
  </output>

  This is a little bit changed code from official example of using ffmpeg called transcoding.c

  I only read packets from one stream and write them to another stream. It works fine.

  Proof below.
  

  then I add to main a condition. If it is a packet with video frame, I will decode it, then encode and write to another stream. No other actions with frame.

  My addition code below :

  static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
  
      int ret;
  
      int got_frame_local;
  
      AVPacket enc_pkt;
  
      int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) = avcodec_encode_video2 ;
  
  
  
      if (!got_frame)
  
          got_frame = &got_frame_local;
  
  
  
      av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
  
      /* encode filtered frame */
  
      enc_pkt.data = NULL;
  
      enc_pkt.size = 0;
  
      av_init_packet(&enc_pkt);
  
      ret = enc_func(stream_ctx[stream_index].enc_ctx, &enc_pkt,
  
          filt_frame, got_frame);
  
      if (ret < 0)
  
          return ret;
  
      if (!(*got_frame))
  
          return 0;
  
  
  
      /* prepare packet for muxing */
  
      enc_pkt.stream_index = stream_index;
  
      av_packet_rescale_ts(&enc_pkt,
  
          stream_ctx[stream_index].enc_ctx->time_base,
  
          ofmt_ctx->streams[stream_index]->time_base);
  
  
  
      av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
  
      /* mux encoded frame */
  
      ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
  
      return ret;
  
  }
  
  
  
  static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
  
  {
  
      int ret;
  
      av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
  
  
  
      while (1) {
  
          av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
  
  
  
          ret = encode_write_frame(frame, stream_index, NULL);
  
          if (ret < 0)
  
              break;
  
          break;
  
      }
  
  
  
      return ret;
  
  }
  
  
  
  
  
  int main(int argc, char **argv)
  
  {
  
      int ret;
  
      AVPacket packet = {0};
  
      packet.data = NULL;
  
      packet.size = 0 ;
  
      AVFrame *frame = NULL;
  
      enum AVMediaType type;
  
      unsigned int stream_index;
  
      unsigned int i;
  
      int got_frame;
  
      int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
  
  
  
      if (argc != 3) {
  
          av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file="file" /> <output file="file">\n", argv[0]);
  
          return 1;
  
      }
  
  
  
      av_register_all();
  
      avfilter_register_all();
  
  
  
      if ((ret = open_input_file(argv[1])) &lt; 0)
  
          goto end;
  
      if ((ret = open_output_file(argv[2])) &lt; 0)
  
          goto end;
  
  
  
      /* read all packets */
  
      while (1) {
  
          if ((ret = av_read_frame(ifmt_ctx, &amp;packet)) &lt; 0)
  
              break;
  
          stream_index = packet.stream_index;
  
          type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;
  
          av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
  
              stream_index);
  
  
  
           if (type == AVMEDIA_TYPE_VIDEO)
  
           {
  
               av_log(NULL, AV_LOG_DEBUG, "Going to reencode&amp;filter the frame\n");
  
               frame = av_frame_alloc();
  
               if (!frame) {
  
                   ret = AVERROR(ENOMEM);
  
                   break;
  
               }
  
               av_packet_rescale_ts(&amp;packet,
  
                   ifmt_ctx->streams[stream_index]->time_base,
  
                   stream_ctx[stream_index].dec_ctx->time_base);
  
               dec_func = avcodec_decode_video2;
  
               ret = dec_func(stream_ctx[stream_index].dec_ctx, frame,
  
                   &amp;got_frame, &amp;packet);
  
               if (ret &lt; 0) {
  
                   av_frame_free(&amp;frame);
  
                   av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
  
                   break;
  
               }
  
  
  
               if (got_frame) {
  
                   frame->pts = frame->best_effort_timestamp;
  
                   ret = filter_encode_write_frame(frame, stream_index);
  
                   av_frame_free(&amp;frame);
  
                   if (ret &lt; 0)
  
                       goto end;
  
               }
  
               else {
  
                   av_frame_free(&amp;frame);
  
               }
  
           }
  
           else 
  
          {
  
              /* remux this frame without reencoding */
  
              av_packet_rescale_ts(&amp;packet,
  
                  ifmt_ctx->streams[stream_index]->time_base,
  
                  ofmt_ctx->streams[stream_index]->time_base);
  
  
  
              ret = av_interleaved_write_frame(ofmt_ctx, &amp;packet);
  
              if (ret &lt; 0)
  
                  goto end;
  
          }
  
          av_packet_unref(&amp;packet);
  
      }
  
  
  
      av_write_trailer(ofmt_ctx);
  
  end:
  
      av_packet_unref(&amp;packet);
  
      av_frame_free(&amp;frame);
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          avcodec_free_context(&amp;stream_ctx[i].dec_ctx);
  
          if (ofmt_ctx &amp;&amp; ofmt_ctx->nb_streams > i &amp;&amp; ofmt_ctx->streams[i] &amp;&amp; stream_ctx[i].enc_ctx)
  
              avcodec_free_context(&amp;stream_ctx[i].enc_ctx);
  
      }
  
      av_free(stream_ctx);
  
      avformat_close_input(&amp;ifmt_ctx);
  
      if (ofmt_ctx &amp;&amp; !(ofmt_ctx->oformat->flags &amp; AVFMT_NOFILE))
  
          avio_closep(&amp;ofmt_ctx->pb);
  
      avformat_free_context(ofmt_ctx);
  
  
  
      return ret ? 1 : 0;
  
  }
  
  </output>

  And the result is different.

  For a test I took a SampleVideo_1280x720_1mb.flv.
  It has

  File size : 1.00 MiB
  Overall bit rate : 1 630 kb/s

  After my decode/encode actions the result became :

  File size : 1.23 MiB
  Overall bit rate : 2 005 kb/s

  Other parameters (video bit rate, audio bit rate, etc) are the same.
  

  What am I doing wrong ? How to control overall bit rate ? I suppose, something wrong with encoder/decoder, but what ?

  UPD :
  I get that when in function open_input_file I write

  if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
  
  {
  
       codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
  
  }

  I get what I get (bigger size and bit rate).

  And when in this function I write

  if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
  
  {
  
      codec_ctx = ifmt_ctx->streams[i]->codec;
  
  }

  I get smaller size and bit rate.

  File size : 900 KiB
  Overall bit rate : 1 429 kb/s

  But how to get the exactly size and frame rate as in the original file ?