Newest 'ffmpeg' Questions - Stack Overflow

Les articles publiés sur le site

• Decode feed file from ffserver

  30 mars 2017, par Xavier BuC

  I made a stream video from two computer thanks to ffserver. ffserver create a 1Go video file called feed1.ffm on my computer.

  How can I convert this file to avi file?

• How to convert flv video to mp3 using ffmpeg programmatically ?

  30 mars 2017, par user958353

  I need to create application on C++ for video conversion, and I can't use ffmpeg.exe.
  I need to do it programmatically, but I don't know how can I do it, and I didn't find any examples on Internet.
  May be somebody know something about my task? Thank you.

• FFMPEG : AV out of sync when writing a part of a video to a new file

  30 mars 2017, par IT_Layman

  I'm developing a data preprocessing program for a computer vision project using FFMPEG and Face detection API. In this program, I need to extract the shots that contain human faces from a given input video file and output them into a new file. But when I played the output video file generated by that program, the video and audio track was out of sync. I think a possible reason is that the timestamp of video frame or audio frame is set incorrectly, but I can't fix it by myself as I'm not very familiar with FFMPEG library, Please help me solving this out-of-sync issue.

  To simplify the code shown below, I have removed all face detection code and use an empty function called faceDetect to represent it instead.

  // ffmpegAPI.cpp : Defines the entry point for the console application.
  //
      #include "stdafx.h"
      #include 
  
      extern "C" {
      #include opt.h>
      #include avcodec.h>
      #include avformat.h>
      #include avutil.h>
      #include channel_layout.h>
      #include common.h>
      #include imgutils.h>
      #include mathematics.h>
      #include samplefmt.h>
      #include pixdesc.h>
      #include swscale.h>
  
  }
  bool faceDetect(AVFrame *frame)
  {
      /*...*/
      return true;
  }
  int main(int argc, char **argv)
  {
      int64_t videoPts = 0, audioPts = 0;
      int samples_count = 0;
      AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
      AVOutputFormat *ofmt = NULL;
      AVPacket pkt;
      AVFrame *frame = NULL;
      int videoindex = -1; int audioindex = -1;
      double videoTime = DBL_MAX;
      const char *in_filename, *out_filename;
      int ret, i;
      in_filename = "C:\\input.flv";//Input file name
      out_filename = "C:\\output.avi";//Output file name
      av_register_all();
      //Open input file
      if ((ret = avformat_open_input(&ifmt_ctx, in_filename, 0, 0)) < 0) {
          fprintf(stderr, "Could not open input file '%s'", in_filename);
          goto end;
      }
      //Find input streams
      if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0) {
          fprintf(stderr, "Failed to retrieve input stream information");
          goto end;
      }
      //Retrive AV stream information
      for (i = 0; i < ifmt_ctx->nb_streams; i++)
      {
          AVStream *stream;
          AVCodecContext *codec_ctx;
          stream = ifmt_ctx->streams[i];//Get current stream
          codec_ctx = stream->codec;//Get current stream codec
          if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
          {
              videoindex = i;//video stream index
          }
          else if (codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO)
          {
              audioindex = i;//audio stream index
          }
          if (videoindex == -1)//no video stream is found
          {
              printf("can't find video stream\n");
              goto end;
  
          }
      }
      av_dump_format(ifmt_ctx, 0, in_filename, 0);
      //Configure output
      avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
      if (!ofmt_ctx) {
          fprintf(stderr, "Could not create output context\n");
          ret = AVERROR_UNKNOWN;
          goto end;
      }
      ofmt = ofmt_ctx->oformat;
      //Configure output streams
      for (i = 0; i < ifmt_ctx->nb_streams; i++) {//Traversal input streams
          AVStream *in_stream = ifmt_ctx->streams[i];//Get current stream
          AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);//Create a corresponding output stream
          if (!out_stream) {
              fprintf(stderr, "Failed allocating output stream\n");
              ret = AVERROR_UNKNOWN;
              goto end;
          }
          //Copy codec from current input stream to corresponding output stream
          ret = avcodec_copy_context(out_stream->codec, in_stream->codec);
          if (ret < 0) {
              fprintf(stderr, "Failed to copy context from input to output stream codec context\n");
              goto end;
          }
          if (i == videoindex)//Video stream
          {
              if (out_stream->codec->codec_id == AV_CODEC_ID_H264)
              {
                  out_stream->codec->me_range = 16;
                  out_stream->codec->max_qdiff = 4;
                  out_stream->codec->qmin = 10;
                  out_stream->codec->qmax = 51;
                  out_stream->codec->qcompress = 1;
  
              }
          }
          AVCodecContext *codec_ctx = out_stream->codec;
          if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
              || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
              //Find codec encoder
              AVCodec *encoder = avcodec_find_encoder(codec_ctx->codec_id);
              if (!encoder) {
                  av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
                  ret = AVERROR_INVALIDDATA;
                  goto end;
              }
              //Open encoder
              ret = avcodec_open2(codec_ctx, encoder, NULL);
              if (ret < 0) {
                  av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
                  goto end;
              }
              out_stream->codec->codec_tag = 0;
              if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
                  out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
          }
          //Open the decoder for input stream
          codec_ctx = in_stream->codec;
          if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
              || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
              ret = avcodec_open2(codec_ctx,
                  avcodec_find_decoder(codec_ctx->codec_id), NULL);
              if (ret < 0) {
                  av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
              }
          }
      }
      av_dump_format(ofmt_ctx, 0, out_filename, 1);
      //Open output file for writing
      if (!(ofmt->flags & AVFMT_NOFILE)) {
          ret = avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
          if (ret < 0) {
              fprintf(stderr, "Could not open output file '%s'", out_filename);
              goto end;
          }
      }
  
      //Write video header
      ret = avformat_write_header(ofmt_ctx, NULL);
      if (ret < 0) {
          fprintf(stderr, "Error occurred when opening output file\n");
          goto end;
      }
      //Write frames in a loop
      while (1) {
          AVStream *in_stream, *out_stream;
          //Read one frame from the input file
          ret = av_read_frame(ifmt_ctx, &pkt);
          if (ret < 0)
              break;
          in_stream = ifmt_ctx->streams[pkt.stream_index];//Get current input stream
          out_stream = ofmt_ctx->streams[pkt.stream_index];//Get current output stream
          if (pkt.stream_index == videoindex)//video frame
          {
              int got_frame;
              frame = av_frame_alloc();
              if (!frame) {
                  ret = AVERROR(ENOMEM);
                  break;
              }
              //Readjust packet timestamp for decoding
              av_packet_rescale_ts(&pkt,
                  in_stream->time_base,
                  in_stream->codec->time_base);
              //Decode video frame
              int len = avcodec_decode_video2(in_stream->codec, frame, &got_frame, &pkt);
              if (len < 0)
              {
                  av_frame_free(&frame);
                  av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
                  break;
              }
              if (got_frame)//Got a decoded video frame
              {
                  int64_t pts = av_frame_get_best_effort_timestamp(frame);
                  //determine if the frame image contains human face
                  bool result = faceDetect(frame);
                  if (result) //face contained
                  {
                      videoTime = pts* av_q2d(out_stream->time_base);
                      frame->pts = videoPts++;//Set pts of video frame
                      AVPacket enc_pkt;
                      av_log(NULL, AV_LOG_INFO, "Encoding video frame\n");
                      //Create packet for encoding
                      enc_pkt.data = NULL;
                      enc_pkt.size = 0;
                      av_init_packet(&enc_pkt);
                      //Encoding frame
                      ret = avcodec_encode_video2(out_stream->codec, &enc_pkt,
                          frame, &got_frame);
                      av_frame_free(&frame);
                      if (!(got_frame))
                          ret = 0;
                      /* Configure encoding properties */
                      enc_pkt.stream_index = videoindex;
                      av_packet_rescale_ts(&enc_pkt,
                          out_stream->codec->time_base,
                          out_stream->time_base);
                      av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
                      /* Write encoded frame */
                      ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
                      if (ret < 0)
                          break;
                  }
                  else //no face contained
                  {
                      //Set the videoTime as maximum double value, 
                      //making the corresponding audio frame not been processed
                      if (videoTime < DBL_MAX)
                          videoTime = DBL_MAX;
                  }
  
              }
              else
              {
                  av_frame_free(&frame);
              }
          }
          else//Audio frame
          {
              //Get current frame time
              double audioTime = pkt.pts * av_q2d(in_stream->time_base);
              if (audioTime >= videoTime)
              {//The current frame should be written into output file
                  int got_frame;
                  frame = av_frame_alloc();
                  if (!frame) {
                      ret = AVERROR(ENOMEM);
                      break;
                  }
                  //Readjust packet timestamp for decoding
                  av_packet_rescale_ts(&pkt,
                      in_stream->time_base,
                      in_stream->codec->time_base);
                  //Decode audio frame
                  int len = avcodec_decode_audio4(in_stream->codec, frame, &got_frame, &pkt);
                  if (len < 0)
                  {
                      av_frame_free(&frame);
                      av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
                      break;
                  }
                  if (got_frame)//Got a decoded audio frame
                  {
                      //Set pts of audio frame
                      frame->pts = audioPts;
                      audioPts += frame->nb_samples;
                      AVPacket enc_pkt;
                      av_log(NULL, AV_LOG_INFO, "Encoding audio frame");
                      //Create packet for encoding
                      enc_pkt.data = NULL;
                      enc_pkt.size = 0;
                      av_init_packet(&enc_pkt);
                      //Encode audio frame
                      ret = avcodec_encode_audio2(out_stream->codec, &enc_pkt,
                          frame, &got_frame);
                      av_frame_free(&frame);
                      if (!(got_frame))
                          ret = 0;
                      /* Configure encoding properties */
                      enc_pkt.stream_index = audioindex;
                      av_packet_rescale_ts(&enc_pkt,
                          out_stream->codec->time_base,
                          out_stream->time_base);
                      av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
                      /* Write encoded frame */
                      ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
                      if (ret < 0)
                          break;
                  }
                  else //Shouldn't be written
                  {
                      av_frame_free(&frame);
                  }
              }
          }
          av_packet_unref(&pkt);
      }
      //Write video trailer
      av_write_trailer(ofmt_ctx);
  end://Clean up
      av_log(NULL, AV_LOG_INFO, "Clean up\n");
      av_frame_free(&frame);
      for (i = 0; i < ifmt_ctx->nb_streams; i++) {
          avcodec_close(ifmt_ctx->streams[i]->codec);
          if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)
              avcodec_close(ofmt_ctx->streams[i]->codec);
      }
      avformat_close_input(&ifmt_ctx);
      /* Close output file */
      if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
          avio_closep(&ofmt_ctx->pb);
      avformat_free_context(ofmt_ctx);
      if (ret < 0 && ret != AVERROR_EOF) {
          char buf[256];
          av_strerror(ret, buf, sizeof(buf));
          av_log(NULL, AV_LOG_ERROR, "Error occurred:%s\n", buf);
          system("Pause");
          return 1;
      }
      //Program end
      printf("The End.\n");
      system("Pause");
      return 0;
  }
  

• Downscaling Video With FFMPEG - Setting Max Width and Height

  30 mars 2017, par Vahid Jamali

  I'm currently trying to use FFMPEG to scale down my video sources from various resolution down to a max width of 854 and a max height of 480. I want to scale the aspect ratio properly with a modulus/divder min of 2.

  Currently this is what I got: scale=-2:'min(ih\,480)'

  This is for the height part only, but still need to figure out how to do the width part and to keep the -2 divider enabled for both. Any ideas? Thanks

• ffmpeg video stream output multiply when I modify viedo in OpenCV

  30 mars 2017, par trojek

  I try to implement a proof of concept program which: (1)get video from webcam, (2)do some operations on it, (3)stream modified video on a web page.

  I do it as follows:

  1) In open CV: open webcam stream and output frames as a rawvideo, capture.py looks:

    import cv2
    import sys
  
    cap = cv2.VideoCapture(0)
    while(cap.isOpened()):
      ret, frame = cap.read()
      if(ret):
        sys.stdout.write(frame.tostring())
      else:
        break
  

  2) Run ffmpeg server by execute: python2 capture.py | ffmpeg -framerate 30 -f rawvideo -pixel_format bgr24 -video_size 640x480 -i - -f mpegts -codec:v mpeg1video -s 640x480 -b:v 2500k -bf 0 http://localhost:8081/supersecret

  3) Run Websocket relay and http-server according to the instruction on page: https://github.com/phoboslab/jsmpeg, in order to stream video in a browser.

  I get the stream in browser, but when I apply any change(e.g. frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)) on the frame inside capture.py file I get 9 small stream instead of one.

  The same situation occurs when I change video resolution while starting ffmpeg server. When I stream directly from /dev/video0 insted of pipe I get the proper stream.

  How can I do some operations on the video and get the single image stream?