Recherche avancée

Sur d’autres sites (12494)

• Scale filter crashes with error when used from transcoding example

  27 juin 2017, par Vali

  I’ve modified a bit (just to compile in c++) this code example :
  https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/transcoding.c.

  What works : as is (null filter), a number of other filters like framerate, drawtext, ...

  What doesn’t work : scale filter when scaling down.

  I use the following syntax for scale ( I’ve tried many others also, same effect) :
  "scale=w=iw/2 :-1"

  The error is : "Input picture width (240) is greater than stride (128)" where the values for width and stride depend on the input.

  Misc environment info : windows, VS 2017, input example : rtsp ://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mov

  Any clue as to what I’m doing wrong ?

  Thanks !

  ---

  EDITED to add working code sample

  ---

  #pragma comment(lib, "avcodec.lib")
  
  #pragma comment(lib, "avutil.lib")
  
  #pragma comment(lib, "avformat.lib")
  
  #pragma comment(lib, "avfilter.lib")
  
  
  
  /*
  
  * Copyright (c) 2010 Nicolas George
  
  * Copyright (c) 2011 Stefano Sabatini
  
  * Copyright (c) 2014 Andrey Utkin
  
  *
  
  **** EDITED 2017 for testing (see original here: https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/transcoding.c)
  
  *
  
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  
  * of this software and associated documentation files (the "Software"), to deal
  
  * in the Software without restriction, including without limitation the rights
  
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  
  * copies of the Software, and to permit persons to whom the Software is
  
  * furnished to do so, subject to the following conditions:
  
  *
  
  * The above copyright notice and this permission notice shall be included in
  
  * all copies or substantial portions of the Software.
  
  *
  
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  
  * THE SOFTWARE.
  
  */
  
  
  
  /**
  
  * @file
  
  * API example for demuxing, decoding, filtering, encoding and muxing
  
  * @example transcoding.c
  
  */
  
  
  
  extern "C"
  
  {
  
      #include <libavcodec></libavcodec>avcodec.h>
  
      #include <libavformat></libavformat>avformat.h>
  
      #include <libavfilter></libavfilter>avfiltergraph.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 FilteringContext {
  
      AVFilterContext *buffersink_ctx;
  
      AVFilterContext *buffersrc_ctx;
  
      AVFilterGraph *filter_graph;
  
  } FilteringContext;
  
  static FilteringContext *filter_ctx;
  
  
  
  typedef struct StreamContext {
  
      AVCodecContext *dec_ctx;
  
      AVCodecContext *enc_ctx;
  
  } StreamContext;
  
  static StreamContext *stream_ctx;
  
  
  
  static int open_input_file(const char *filename, int&amp; videoStreamIndex)
  
  {
  
      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;
  
      }
  
  
  
      // Just need video
  
      videoStreamIndex = -1;
  
      for (unsigned int i = 0; i &lt; ifmt_ctx->nb_streams; i++)
  
      {
  
          if (ifmt_ctx->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
  
              continue;
  
          videoStreamIndex = i;
  
          break;
  
      }
  
      if (videoStreamIndex &lt; 0)
  
      {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot find video stream\n");
  
          return videoStreamIndex;
  
      }
  
  
  
  
  
      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++) {
  
  
  
          // Just need video
  
          if (i != videoStreamIndex)
  
              continue;
  
  
  
  
  
          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, const int videoStreamIndex)
  
  {
  
      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++) {
  
          // Just need video
  
          if (i != videoStreamIndex)
  
              continue;
  
  
  
          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;
  
  
  
          if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  
              /* 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 */
  
              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->time_base = dec_ctx->time_base;
  
  
  
  
  
              /* 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;
  
  }
  
  
  
  static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
  
      AVCodecContext *enc_ctx, const char *filter_spec)
  
  {
  
      char args[512];
  
      int ret = 0;
  
      AVFilter *buffersrc = NULL;
  
      AVFilter *buffersink = NULL;
  
      AVFilterContext *buffersrc_ctx = NULL;
  
      AVFilterContext *buffersink_ctx = NULL;
  
      AVFilterInOut *outputs = avfilter_inout_alloc();
  
      AVFilterInOut *inputs = avfilter_inout_alloc();
  
      AVFilterGraph *filter_graph = avfilter_graph_alloc();
  
  
  
      if (!outputs || !inputs || !filter_graph) {
  
          ret = AVERROR(ENOMEM);
  
          goto end;
  
      }
  
  
  
      if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  
          buffersrc = avfilter_get_by_name("buffer");
  
          buffersink = avfilter_get_by_name("buffersink");
  
          if (!buffersrc || !buffersink) {
  
              av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
  
              ret = AVERROR_UNKNOWN;
  
              goto end;
  
          }
  
  
  
          snprintf(args, sizeof(args),
  
              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
  
              dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
  
              dec_ctx->time_base.num, dec_ctx->time_base.den,
  
              dec_ctx->sample_aspect_ratio.num,
  
              dec_ctx->sample_aspect_ratio.den);
  
  
  
          ret = avfilter_graph_create_filter(&amp;buffersrc_ctx, buffersrc, "in",
  
              args, NULL, filter_graph);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
  
              goto end;
  
          }
  
  
  
          ret = avfilter_graph_create_filter(&amp;buffersink_ctx, buffersink, "out",
  
              NULL, NULL, filter_graph);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
  
              goto end;
  
          }
  
  
  
          ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
  
              (uint8_t*)&amp;enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
  
              AV_OPT_SEARCH_CHILDREN);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
  
              goto end;
  
          }
  
      }
  
      else {
  
          ret = AVERROR_UNKNOWN;
  
          goto end;
  
      }
  
  
  
      /* Endpoints for the filter graph. */
  
      outputs->name = av_strdup("in");
  
      outputs->filter_ctx = buffersrc_ctx;
  
      outputs->pad_idx = 0;
  
      outputs->next = NULL;
  
  
  
      inputs->name = av_strdup("out");
  
      inputs->filter_ctx = buffersink_ctx;
  
      inputs->pad_idx = 0;
  
      inputs->next = NULL;
  
  
  
      if (!outputs->name || !inputs->name) {
  
          ret = AVERROR(ENOMEM);
  
          goto end;
  
      }
  
  
  
      if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
  
          &amp;inputs, &amp;outputs, NULL)) &lt; 0)
  
          goto end;
  
  
  
      if ((ret = avfilter_graph_config(filter_graph, NULL)) &lt; 0)
  
          goto end;
  
  
  
      /* Fill FilteringContext */
  
      fctx->buffersrc_ctx = buffersrc_ctx;
  
      fctx->buffersink_ctx = buffersink_ctx;
  
      fctx->filter_graph = filter_graph;
  
  
  
  end:
  
      avfilter_inout_free(&amp;inputs);
  
      avfilter_inout_free(&amp;outputs);
  
  
  
      return ret;
  
  }
  
  
  
  static int init_filters(const int videoStreamIndex)
  
  {
  
      const char *filter_spec;
  
      unsigned int i;
  
      int ret;
  
      filter_ctx = (FilteringContext*)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
  
      if (!filter_ctx)
  
          return AVERROR(ENOMEM);
  
  
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
  
  
          // Just video
  
          if (i != videoStreamIndex)
  
              continue;
  
  
  
          filter_ctx[i].buffersrc_ctx = NULL;
  
          filter_ctx[i].buffersink_ctx = NULL;
  
          filter_ctx[i].filter_graph = NULL;
  
          if (!(ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO
  
              || ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO))
  
              continue;
  
  
  
          filter_spec = "null"; /* passthrough (dummy) filter for video */
  
          //filter_spec = "scale=w=iw/2:-1";
  
          // filter_spec = "drawtext=fontfile=FreeSerif.ttf: text='%{localtime}': x=w-text_w: y=0: fontsize=24: fontcolor=yellow@1.0: box=1: boxcolor=red@1.0";
  
          // filter_spec = "drawtext=fontfile=FreeSerif.ttf :text='test': x=w-text_w: y=text_h: fontsize=24: fontcolor=yellow@1.0: box=1: boxcolor=red@1.0";
  
  
  
          ret = init_filter(&amp;filter_ctx[i], stream_ctx[i].dec_ctx,
  
              stream_ctx[i].enc_ctx, filter_spec);
  
          if (ret)
  
              return ret;
  
      }
  
      return 0;
  
  }
  
  
  
  static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame, const int videoStreamIndex) {
  
  
  
      // Just video
  
      if (stream_index != videoStreamIndex)
  
          return 0;
  
  
  
      int ret;
  
      int got_frame_local;
  
      AVPacket enc_pkt;
  
      int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
  
          (ifmt_ctx->streams[stream_index]->codecpar->codec_type ==
  
              AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
  
  
  
      if (!got_frame)
  
          got_frame = &amp;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(&amp;enc_pkt);
  
  
  
      ret = enc_func(stream_ctx[stream_index].enc_ctx, &amp;enc_pkt,
  
          filt_frame, got_frame);
  
  
  
      av_frame_free(&amp;filt_frame);
  
      if (ret &lt; 0)
  
          return ret;
  
      if (!(*got_frame))
  
          return 0;
  
  
  
      /* prepare packet for muxing */
  
      /*enc_pkt.stream_index = stream_index;
  
      av_packet_rescale_ts(&amp;enc_pkt, stream_ctx[stream_index].enc_ctx->time_base, ofmt_ctx->streams[stream_index]->time_base);*/
  
      enc_pkt.stream_index = 0;
  
      av_packet_rescale_ts(&amp;enc_pkt, stream_ctx[stream_index].enc_ctx->time_base, ofmt_ctx->streams[0]->time_base);
  
  
  
      av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
  
      /* mux encoded frame */
  
      ret = av_interleaved_write_frame(ofmt_ctx, &amp;enc_pkt);
  
      return ret;
  
  }
  
  
  
  static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index, const int videoStreamIndex)
  
  {
  
      // Just video, all else crashes
  
      if (stream_index != videoStreamIndex)
  
          return 0;
  
  
  
      int ret;
  
      AVFrame *filt_frame;
  
  
  
      // av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
  
      /* push the decoded frame into the filtergraph */
  
      ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
  
          frame, 0);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
  
          return ret;
  
      }
  
  
  
      /* pull filtered frames from the filtergraph */
  
      while (1) {
  
          filt_frame = av_frame_alloc();
  
          if (!filt_frame) {
  
              ret = AVERROR(ENOMEM);
  
              break;
  
          }
  
          // av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
  
          ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
  
              filt_frame);
  
          if (ret &lt; 0) {
  
              /* if no more frames for output - returns AVERROR(EAGAIN)
  
              * if flushed and no more frames for output - returns AVERROR_EOF
  
              * rewrite retcode to 0 to show it as normal procedure completion
  
              */
  
              if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
                  ret = 0;
  
              av_frame_free(&amp;filt_frame);
  
              break;
  
          }
  
  
  
          filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
  
          ret = encode_write_frame(filt_frame, stream_index, NULL, videoStreamIndex);
  
          if (ret &lt; 0)
  
              break;
  
      }
  
  
  
      return ret;
  
  }
  
  
  
  static int flush_encoder(unsigned int stream_index, const int videoStreamIndex)
  
  {
  
      int ret;
  
      int got_frame;
  
  
  
      // Just video
  
      if (stream_index != videoStreamIndex)
  
          return 0;
  
  
  
      if (!(stream_ctx[stream_index].enc_ctx->codec->capabilities &amp;
  
          AV_CODEC_CAP_DELAY))
  
          return 0;
  
  
  
      while (1) {
  
          av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
  
          ret = encode_write_frame(NULL, stream_index, &amp;got_frame, videoStreamIndex);
  
          if (ret &lt; 0)
  
              break;
  
          if (!got_frame)
  
              return 0;
  
      }
  
      return ret;
  
  }
  
  
  
  
  
  #include <vector>
  
  
  
  int main(int argc, char **argv)
  
  {
  
      int ret;
  
  
  
      AVPacket packet;
  
      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 *);
  
  
  
  
  
  #ifdef _DEBUG
  
      // Hardcoded arguments
  
      std::vector varguments;
  
      {
  
          varguments.push_back(argv[0]);
  
  
  
          // Source
  
          varguments.push_back("./big_buck_bunny_short.mp4 ");
  
  
  
          // Destination
  
          varguments.push_back("./big_buck_bunny_short-processed.mp4");
  
      }
  
  
  
      char** arguments = new char*[varguments.size()];
  
      for (unsigned int i = 0; i &lt; varguments.size(); i++)
  
      {
  
          arguments[i] = varguments[i];
  
      }
  
      argc = varguments.size();
  
      argv = arguments;
  
  #endif // _DEBUG
  
  
  
  
  
      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();
  
  
  
      int videoStreamIndex = -1;
  
      if ((ret = open_input_file(argv[1], videoStreamIndex)) &lt; 0)
  
          goto end;
  
      if ((ret = open_output_file(argv[2], videoStreamIndex)) &lt; 0)
  
          goto end;
  
      if ((ret = init_filters(videoStreamIndex)) &lt; 0)
  
          goto end;
  
  
  
      // Stop after a couple of frames
  
      int framesToGet = 100;
  
  
  
      /* read all packets */
  
      //while (framesToGet--)
  
      while(1)
  
      {
  
          if ((ret = av_read_frame(ifmt_ctx, &amp;packet)) &lt; 0)
  
              break;
  
          stream_index = packet.stream_index;
  
  
  
          // I just need video
  
          if (stream_index != videoStreamIndex) {
  
              av_packet_unref(&amp;packet);
  
              continue;
  
          }
  
  
  
          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 (filter_ctx[stream_index].filter_graph) {
  
              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 = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
  
                  avcodec_decode_audio4;
  
              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, videoStreamIndex);
  
                  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);
  
      }
  
  
  
      /* flush filters and encoders */
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          /* flush filter */
  
          if (!filter_ctx[i].filter_graph)
  
              continue;
  
          ret = filter_encode_write_frame(NULL, i, videoStreamIndex);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
  
              goto end;
  
          }
  
  
  
          /* flush encoder */
  
          ret = flush_encoder(i, videoStreamIndex);
  
          if (ret &lt; 0) {
  
              av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
  
              goto end;
  
          }
  
      }
  
  
  
      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++) {
  
          // Just video
  
          if (i != videoStreamIndex)
  
              continue;
  
          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);
  
          if (filter_ctx &amp;&amp; filter_ctx[i].filter_graph)
  
              avfilter_graph_free(&amp;filter_ctx[i].filter_graph);
  
      }
  
      av_free(filter_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);
  
  
  
      /*if (ret &lt; 0)
  
          av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));*/
  
  
  
      return ret ? 1 : 0;
  
  }
  
  </output></vector>

• Merge remote-tracking branch ’rbultje/vp9-profile1-wip’

  1er mai 2015, par Michael Niedermayer

  Merge remote-tracking branch ’rbultje/vp9-profile1-wip’
  * rbultje/vp9-profile1-wip :
  
    vp9 : add fate test for 422.
  
    vp9 : copy bug in libvpx for 4:2:2 chroma bs=8x4/4x4 prediction.
  
    vp9 : add yuv440 fate test.
  
    vp9 : fix mask_edges and filter_plane_rows/cols() for 440.
  
    vp9 : more specifically specify mask destination to mask_edges().
  
    vp9 : add fate test for profile 1 444.
  
    vp9 : don’t create special u/v filter masks for 444.
  
    vp9 : merge uv loopfilter code into generic filter_plane_rows/cols().
  
    vp9 : split out loopfilter luma rows/cols functions from loopfilter_sb().
  
    vp9 : invert order of two conditions.
  
    vp9 : use correct chroma subsampling for profile 1 inter block recon.
  
    vp9 : use correct chroma subsampling for profile 1 intra block recon.
  
    vp9 : take chroma subsampling into account when walking the block tree.
  
    vp9 : support non-420 chroma subsampling for profile 1 token decoding.
  
    vp9 : increase buffer sizes for non-420 chroma subsamplings.
  
    vp9 : profile 1 header decoding.
  Merged-by : Michael Niedermayer <michaelni@gmx.at>
  

  • [DH] libavcodec/vp9.c
  • [DH] libavcodec/vp9_mc_template.c
  • [DH] tests/fate/vpx.mak
  • [DH] tests/ref/fate/vp9p1-04-yuv422
  • [DH] tests/ref/fate/vp9p1-04-yuv440
  • [DH] tests/ref/fate/vp9p1-04-yuv444

• Real-time streaming of rawdata images to Android with FFMPEG

  29 juillet 2015, par Philies

  CONDITIONS

  I have an C++ server (Linux) and want to transmit rawdata images (RGB, 32bit) to an Android device in real-time.
  The server generates the rawdata images (with or without bitmap header) continuously every x miliseconds. Now, I want to put the rawdata images into a stream and transmit them without much delay to the Android client.

  I’ve chosen FFMPEG for this kind of job.

  The input for FFMPEG should be the rawdata images, which are generated just in time. The output should be an rtsp stream (h264 or is another format better ?).
  On client side I will play the stream with the Android MediaPlayer. That works for a RTSP url like rtsp ://184.72.239.149/vod/mp4:BigBuckBunny_115k.mov

  ---

  PREVIOUS APPROCH :

  I’ve installed FFMPEG on my server.

  Depending on this question : https://ffmpeg.org/pipermail/ffmpeg-user/2013-April/014617.html ... here is my FFMEG command :

  ffmpeg -an -f rawvideo -vcodec rawvideo -pix_fmt rgb32 -r 10 -i -vcodec libx264 -r 30 -tune zerolatency -preset ultrafast -bsf:v h264_mp4toannexb -f mpegts udp://192.168.1.20:1234

  Explanation of the parameters :

  • -an = ignore audio
  • -report = log file in current directory

  INPUT :

  • -f = rawvideo (video format)
  • -vcodec = rawvideo (video codec)
  • -pix_fmt = rgb32
  • -r = 10 (frame rate)

  OUTPUT :

  • -vcodec = libx264
  • -r = 30 (frame rate)
  • -bsf:v = h264_mp4toannexb
  • -f = mpegts udp ://192.168.1.20:1234

  ---

  C++ Server Code Snippet :

  /* -------  Get image rawdata from source ------- */
  
  ...
  
  /* -------  Create image header which fits to the image rawdata ------- */
  
  ...
  
  
  
  /* ------- Store the picture local (not necessary?) ------- */
  
  FILE *f;
  
  f = fopen("/home/philies/test.bmp","wb");
  
  
  
  //Write Bitmap Headers
  
  fwrite(&imageFileHeader,1,sizeof(imageFileHeader),f);
  
  fwrite(imageInfoHeader,1, imageInfoHeader,f);
  
  
  
  //Write Bitmap Rawdata
  
  fwrite(lastImage.GetBitmapRawData(),1,imageSize,f);
  
  
  
  
  
  —> ffmpeg ???

  ---

  PROBLEMS/QUESTIONS :

  1. How can I specify the rawvideo of the ffmpeg command respectively how can I specify my bitmap rawdata (with or without header ?) as the input of the FFMPEG ?

  2. Is the FFMPEG command correct ?

  If I fire the FFMPEG command in the terminal I get this error :

  vcodec : no such file or directory

  EDIT :
  In the first step, I will open the udp stream with the VLC player on my Android device. After that I will set up a FFserver to create a RTSP stream