Newest 'ffmpeg' Questions - Stack Overflow

Les articles publiés sur le site

• How can I use ffmpeg with PHP's exec( ) command ?

  22 janvier 2012, par John Anderson

  I'm running Max OS 10.7, MAMP (PHP 5.3.6), with FFMPEG installed. I want to convert videos from one format to another. The following entered into Terminal works fine:

   ffmpeg -i /path/video.wmv /path/video.flv
  

  The file video.wmv is converted to video.flv. Great! Now, this PHP line DOESN'T work:

   exec('ffmpeg -i /path/video.wmv /path/video.flv');
  

  Why? I've spent many hours reading up on this and I still can't figure out what is wrong. I have read the other discussions on this topic and there is no clear answer. Any help would be greatly appreciated! (PHP safe_mode is off).

• OpenCV video writing to named pipe

  21 janvier 2012, par user28667

  I'm trying to send videos created with OpenCV in real-time to user though Apache (user downloads video from a website). I don't need streaming video. I'm just trying to transfer whole video file. My OpenCV program writes video to a named pipe (created with mkfifo) and PHP scrpt reads from it and outputs to user.

  The problem is that pipe-transfered videos doesn't open in Windows. They're shorter exactly at 7072 bytes (checked with different videos). They are not just truncated. The first difference between videos appeared in 5-th byte. And there is no mistake in PHP script. I've checked it using:

  cat fifo.avi > output.avi
  

  The result was the same. How to make OpenCV write videos to pipes just as to normal files? Why this happens? Or is there another way to send videos in real-time to user?

  P. S. Thanks and sorry for bad English
  P. P. S. I'm creating CvVideoWriter with this code if it matters:

  cvCreateVideoWriter("fifo.avi",CV_FOURCC('M','J','P','G'),25,cvSize(blah blah blah),1)
  

• libav* incorrect decode

  21 janvier 2012, par jjSunny

  Use libav to save frames from a video.

  The problem is that if you call the function decode a few times, then 2nd and then not correctly handled.

  1st time such a conclusion (all works fine):

  [swscaler @ 0x8b48510]No accelerated colorspace conversion found from yuv420p to bgra.
  good
  

  2nd (can not find stream, but these are the same):

  [mp3 @ 0x8ae5800]Header missing
  Last message repeated 223 times
  [mp3 @ 0x8af31c0]Could not find codec parameters (Audio: mp1, 0 channels, s16)
  [mp3 @ 0x8af31c0]Estimating duration from bitrate, this may be inaccurate
  av_find_stream_info
  

  Can you please tell where the error occurred.

  main.cpp

  avcodec_init();
  avcodec_register_all();
  av_register_all();
  char *data;
  int size;
  //fill data and size
  ...
  decode(data, size);
  decode(data, size);
  

  video.cpp

  int f_offset = 0;
  int f_length = 0;
  char *f_data = 0;
  
  int64_t seekp(void *opaque, int64_t offset, int whence)
  {
      switch (whence)
      {
      case SEEK_SET:
          if (offset > f_length || offset < 0)
              return -1;
          f_offset = offset;
          return f_offset;
      case SEEK_CUR:
          if (f_offset + offset > f_length || f_offset + offset < 0)
              return -1;
          f_offset += offset;
          return f_offset;
      case SEEK_END:
          if (offset > 0 || f_length + offset < 0)
              return -1;
          f_offset = f_length + offset;
          return f_offset;
      case AVSEEK_SIZE:
          return f_length;
      }
  
      return -1;
  }
  int readp(void *opaque, uint8_t *buf, int buf_size)
  {
      if (f_offset == f_length)
          return 0;
  
      int length = buf_size <= (f_length - f_offset) ? buf_size : (f_length - f_offset);
  
      memcpy(buf, f_data + f_offset, length);
      f_offset += length;
  
      return length;
  }
  
  bool decode(char *data, int length)
  {
      f_offset = 0;
      f_length = length;
      f_data = data;
  
      int buffer_read_size = FF_MIN_BUFFER_SIZE;
      uchar *buffer_read = (uchar *) av_mallocz(buffer_read_size + FF_INPUT_BUFFER_PADDING_SIZE);
  
      AVProbeData pd;
      pd.filename = "";
      pd.buf_size = 4096 < f_length ? 4096 : f_length;
      pd.buf = (uchar *) av_mallocz(pd.buf_size + AVPROBE_PADDING_SIZE);
      memcpy(pd.buf, f_data, pd.buf_size);
  
      AVInputFormat *pAVInputFormat = av_probe_input_format(&pd, 1);
      if (pAVInputFormat == NULL)
      {
          std::cerr << "AVIF";
          return false;
      }
      pAVInputFormat->flags |= AVFMT_NOFILE;
  
      ByteIOContext ByteIOCtx;
      if (init_put_byte(&ByteIOCtx, buffer_read, buffer_read_size, 0, NULL, readp, NULL, seekp) < 0)
      {
          std::cerr << "init_put_byte";
          return false;
      }
  
      AVFormatContext *pFormatCtx;
      if (av_open_input_stream(&pFormatCtx, &ByteIOCtx, "", pAVInputFormat, NULL) < 0)
      {
          std::cerr << "av_open_stream";
          return false;
      }
  
      if (av_find_stream_info(pFormatCtx) < 0)
      {
          std::cerr << "av_find_stream_info";
          return false;
      }
  
      int video_stream;
      video_stream = -1;
      for (uint i = 0; i < pFormatCtx->nb_streams; ++i)
          if (pFormatCtx->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO)
          {
              video_stream = i;
              break;
          }
      if (video_stream == -1)
      {
          std::cerr << "video_stream == -1";
          return false;
      }
  
      AVCodecContext *pCodecCtx;
      pCodecCtx = pFormatCtx->streams[video_stream]->codec;
  
      AVCodec *pCodec;
      pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
      if (pCodec == NULL)
      {
          std::cerr << "pCodec == NULL";
          return false;
      }
  
      if (avcodec_open(pCodecCtx, pCodec) < 0)
      {
          std::cerr << "avcodec_open";
          return false;
      }
  
      AVFrame *pFrame;
      pFrame = avcodec_alloc_frame();
      if (pFrame == NULL)
      {
          std::cerr << "pFrame == NULL";
          return false;
      }
      AVFrame *pFrameRGB;
      pFrameRGB = avcodec_alloc_frame();
      if (pFrameRGB == NULL)
      {
          std::cerr << "pFrameRGB == NULL";
          return false;
      }
  
      int numBytes;
      numBytes = avpicture_get_size(PIX_FMT_RGB32, pCodecCtx->width, pCodecCtx->height);
      uint8_t *buffer;
      buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
      if (buffer == NULL)
      {
          std::cerr << "buffer == NULL";
          return false;
      }
  
      // Assign appropriate parts of buffer to image planes in pFrameRGB
      // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
      // of AVPicture
      avpicture_fill((AVPicture *) pFrameRGB, buffer, PIX_FMT_RGB32, pCodecCtx->width, pCodecCtx->height);
  
      SwsContext *swsctx;
      swsctx = sws_getContext(
                  pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
                  pCodecCtx->width, pCodecCtx->height, PIX_FMT_RGB32,
                  SWS_BILINEAR, NULL, NULL, NULL);
      if (swsctx == NULL)
      {
          std::cerr << "swsctx == NULL";
          return false;
      }
  
      AVPacket packet;
      while (av_read_frame(pFormatCtx, &packet) >= 0)
      {
          if (packet.stream_index == video_stream)
          {
              int frame_finished;
              avcodec_decode_video2(pCodecCtx, pFrame, &frame_finished, &packet);
  
              if (frame_finished)
              {
                  sws_scale(swsctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
  
                  std::cerr << "good";
                  av_close_input_stream(pFormatCtx);
  
                  return true;
              }
              else
                  std::cerr << "frame_finished == 0";
          }
      }
  
      std::cerr << "av_read_frame < 0";
      return false;
  }
  

  ffmpeg -version

  FFmpeg 0.6.2-4:0.6.2-1ubuntu1
  libavutil     50.15. 1 / 50.15. 1
  libavcodec    52.72. 2 / 52.72. 2
  libavformat   52.64. 2 / 52.64. 2
  libavdevice   52. 2. 0 / 52. 2. 0
  libavfilter    1.19. 0 /  1.19. 0
  libswscale     0.11. 0 /  0.11. 0
  libpostproc   51. 2. 0 / 51. 2. 0
  

• avcodec_find_decoder(CODEC_ID_MPEG2TS) always NULL

  21 janvier 2012, par mmoment

  I want to decode an incoming MPEG2-Transport Stream and then encode it to h264. Everything works fine with the h264 Codec, but the problem is that libavcodec doesn't seem to recognize the MPEG2-Transportstream. I am basically doing it analogue to the official example:

  http://ffmpeg.org/doxygen/trunk/decoding__encoding_8c-source.html

  ptrCodec = avcodec_find_decoder(CODEC_ID_MPEG2TS);
  

  ptrCodec is always NULL. Could anybody help me with this?

• Wma decoding with ffmpeg

  21 janvier 2012, par Izak

  I am new to ffmpeg and I tried using api-example.c to decode wma files. However when I run the program, it gave me an error saying

  "frame_len overflow". Does anyone know how to fix this error?

  Here is my code:

  extern "C" {
  #include 
  #include "../libavcodec/avcodec.h"
  #include 
  }
  
  #include 
  #include 
  #include 
  #include 
  #define INBUF_SIZE 4096
  #define AUDIO_INBUF_SIZE 20480
  #define AUDIO_REFILL_THRESH 4096
  
  int main(int argc, char *argv[]) {
      avcodec_init();
      avcodec_register_all();
      //avdevice_register_all();
      av_register_all();
  
      AVCodec *codec;
      AVCodecContext *c= NULL;
  
      AVCodec *ocodec;
      AVCodecContext *oc= NULL;
  
      int out_size, len,out_size2;
      FILE *f, *outfile;
      uint8_t *outbuf;
      uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
  
      AVPacket avpkt;
      char* outfilename="test.wma";
      char* filename="Beethoven's.wma";
      AVFormatContext *pFormatCtx;
  
      WAVEFORMATEX* wfx=new WAVEFORMATEX;
  
      int ret;
      ret=av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL);
  
      if(ret!=0)
      {
          std::cout<<"cannot open file!"</ Find the first video stream
      audioStream=-1;
      for(int i=0; inb_streams; i++)
          if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO)
          {
              audioStream=i;
              break;
          }
      if(audioStream==-1)
      {
          std::cout<<"cannot find audio!"</ Get a pointer to the codec context for the audio stream
      pCodecCtx=pFormatCtx->streams[audioStream]->codec;
      av_init_packet(&avpkt);
  
      printf("Audio decoding\n");
  
      /* find the suitable audio decoder */
      codec = avcodec_find_decoder(pCodecCtx->codec_id);
  
      if (!codec) {
          fprintf(stderr, "codec not found\n");
          exit(1);
      }
  
      if(codec->capabilities & CODEC_CAP_TRUNCATED)
          pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
  
      //open the codec (for decoding)
      int test = avcodec_open(pCodecCtx, codec);
      if (test < 0) {
          fprintf(stderr, "could not open codec\n");
          exit(1);
      }
  
      //find mp3 encoder
      ocodec = avcodec_find_encoder(CODEC_ID_MP3);
      if (!ocodec) {
          fprintf(stderr, "codec not found\n");
          exit(1);
      }
  
      //allocate context
      oc= avcodec_alloc_context();
      /* put sample parameters */
      oc->bit_rate = 64000;
      oc->sample_rate = 44100;
      oc->channels = 1;
      /* open it */
      if (avcodec_open(oc, ocodec) < 0) {
          fprintf(stderr, "could not open encoding codec\n");
          exit(1);
      }
  
      //buffer
      outbuf = (uint8_t*)malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
  
      //open inputfile
      f = fopen(filename, "rb");
      if (!f) {
          fprintf(stderr, "could not open %s\n", filename);
          exit(1);
      }
  
      //open outputfile
      outfile = fopen(outfilename, "wb");
  
      if (!outfile) {
          av_free(c);
          exit(1);
      }
  
      /* decode until eof */
      avpkt.data = inbuf;
      avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
  
      //while there is still data
      while (avpkt.size > 0) {
          std::cout<<"decoding..."</decode
          len = avcodec_decode_audio3(pCodecCtx, (short *)outbuf, &out_size, &avpkt);
  
          if (len < 0) {
              fprintf(stderr, "Error while decoding\n");
              exit(1);
          }
  
          if (out_size > 0) {
              /* if a frame has been decoded, output it */
              std::cout<<"1 frame decoded!"</subtract data from whatever decode function returns
  
          avpkt.size -= len;
  
          avpkt.data += len;
  
          if (avpkt.size < AUDIO_REFILL_THRESH) {
  
              /* Refill the input buffer, to avoid trying to decode
  
              * incomplete frames. Instead of this, one could also use
  
              * a parser, or use a proper container format through
  
              * libavformat. */
  
              memmove(inbuf, avpkt.data, avpkt.size);
  
              avpkt.data = inbuf;
  
              len = fread(avpkt.data + avpkt.size, 1,
  
                          AUDIO_INBUF_SIZE - avpkt.size, f);
  
              if (len > 0)
  
                  avpkt.size += len;
  
          }
  
  
  
      }
  
      fclose(outfile);
  
      fclose(f);
  
      free(outbuf);
  
      avcodec_close(c);
  
      av_free(c);
  
  
  
  }
  

  I have been stuck on this for quite a long time. Please help me. anyone know whats wrong with my code?

  Thanks,

  Izak