Recherche avancée

Sur d’autres sites (4406)

• How to detect Audio or Video or Both exist in converted file

  28 juillet 2016, par Khaja Hussain

  I am trying to convert mp4 or 3gp video files into Flash (flv) format (using Perl script), using following (mencoder) command :

  mencoder test.mp4 -of lavf -ovc lavc -lavcopts vcodec=flv:vbitrate=1000:mbd=2 -fps 20.80 -ofps 20.80 -oac mp3lame -lameopts abr:br=32 -srate 22050 -o test.flv

  It works fine, but some files which comes as attachments from mobile phone has problem, the converted FLV file has only audio.

  I also used ffmpeg command as follows :

  ffmpeg -i test.mp4 -ar 22050 -acodec libmp3lame -ab 32K -r 25 -vcodec flv test.flv

  This ffmpeg command helps to convert to flv, which is failed by mencoder.

  I am thinking some solution like, need to check whether converted flv has audio and video then will take action depends on it. Could you help me to solve this issue ?

  Here is some more info (log) :

  [mov,mp4,m4a,3gp,3g2,mj2 @ 0xb6b9a3a0]multiple edit list entries, a/v desync might occur, patch welcome
  ** MUXER_LAVF *************************************
  REMEMBER : MEncoder’s libavformat muxing is presently broken and can generate
  INCORRECT files in the presence of B-frames. Moreover, due to bugs MPlayer
  will play these INCORRECT files as if nothing were wrong !

  ---

  Unsupported PixelFormat 61
  Unsupported PixelFormat 53
  Unsupported PixelFormat 81
  [flv @ 0xb6b9a3a0]Codec for stream 0 does not use global headers but container format requires global headers
  [flv @ 0xb6b9a3a0]Codec for stream 1 does not use global headers but container format requires global headers
  [flv @ 0xb6b9a3a0]pts < dts in stream 0
  Error while writing frame.

  [flv @ 0xb6b9a3a0]pts < dts in stream 0
  Error while writing frame.

  [flv @ 0xb6b9a3a0]pts < dts in stream 0
  Error while writing frame.

  [flv @ 0xb6b9a3a0]pts < dts in stream 0
  Error while writing frame.

  [flv @ 0xb6b9a3a0]pts < dts in stream 0
  Error while writing frame.

  Skipping frame !

  .........................

• ffmpeg split avi into frames with known frame rate

  31 mai 2016, par Myx

  I posted this as comments under this related thread. However, they seem to have gone unnoticed =(

  I’ve used

  ffmpeg -i myfile.avi -f image2 image-%05d.bmp

  to split myfile.avi into frames stored as .bmp files. It seemed to work except not quite. When recording my video, I recorded at a rate of 1000fps and the video turned out to be 2min29sec long. If my math is correct, that should amount to a total of 149,000 frames for the entire video. However, when I ran

  ffmpeg -i myfile.avi -f image2 image-%05d.bmp

  I only obtained 4472 files. How can I get the original 149k frames ?

  I also tried to convert the frame rate of my original AVI to 1000fps by doing

  ffmpeg -i myfile.avi -r 1000 otherfile.avi

  but this didn’t seem to fix my concern.

• Audio/Video encoding with ffmpeg

  16 mars 2017, par Vroz

  Audio/Video encoding with ffmpeg :

  I am trying to create an avi file with encoded video and audio, using ffmpeg.

  First, I create the file :

              //define BITRATE 10000000
  
              //define GOP 300
  
              //define FPS 60
  
              //define VIDEOTYPE "avi"
  
  
  
              if (!encoder_->createFile(QFileInfo(*(videoFile_.data())).absoluteFilePath(), targetRect.width(), targetRect.height(), BITRATE*(1000 / FPS), GOP, 1000))    

  The buffers are initialized as :

              audio_outbuf_size = 44100 * 0.005 * 16; //5ms of audio should be encoded, each time this function is called
  
              audio_outbuf = new uint8_t[audio_outbuf_size];
  
  
  
              outbuf_size = getWidth()*getHeight() * 3;        
  
              outbuf = new uint8_t[outbuf_size];

  Then add audio and video streams (audio : CODEC_ID_PCM_S16LE, 16000 kb/s and 44100 Hz, video : PIX_FMT_YUV420P)

              void MediaMuxer::addAudioStream(QString fileName, ffmpeg::CodecID codec_id)
  
              {
  
                  // Add the audio stream
  
                  ffmpeg::AVCodec *encoder = avcodec_find_encoder(codec_id);
  
                  pAudioStream_ = ffmpeg::av_new_stream(pOutputFormatCtx_, 0);
  
                  if (!pAudioStream_) {
  
                      printf("Could not allocate stream\n");
  
                      return;
  
                  }
  
  
  
                  pAudioCodecCtx_ = pAudioStream_->codec;
  
                  pAudioCodecCtx_->codec_id = codec_id;
  
                  pAudioCodecCtx_->codec_type = ffmpeg::AVMEDIA_TYPE_AUDIO;
  
                  pAudioCodecCtx_->sample_fmt = ffmpeg::AV_SAMPLE_FMT_S16;
  
                  pAudioCodecCtx_->sample_fmt = encoder->sample_fmts[0];
  
                  pAudioCodecCtx_->bit_rate = 16000;
  
                  //pAudioCodecCtx_->bit_rate = 64000;
  
                  pAudioCodecCtx_->sample_rate = N;
  
                  pAudioCodecCtx_->channels = 1;
  
  
  
                  pAudioCodecCtx_->time_base.den = FPS;
  
                  pAudioCodecCtx_->time_base.num = 1;
  
  
  
                  avcodec_thread_init(pAudioCodecCtx_, 10);
  
  
  
                  // some formats want stream headers to be separate
  
                  if (pOutputFormatCtx_->oformat->flags & AVFMT_GLOBALHEADER)
  
                      pAudioCodecCtx_->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
                  if (av_set_parameters(pOutputFormatCtx_, NULL) < 0)
  
                  {
  
                      printf("Invalid output format parameters\n");
  
                      return;
  
                  }
  
  
  
                  //ffmpeg::dump_format(pOutputFormatCtx_, 0, fileName.toStdString().c_str(), 1);
  
  
  
                  // open_video
  
                  // find the audio encoder
  
                  pAudioCodec_ = avcodec_find_encoder(pAudioCodecCtx_->codec_id);
  
                  if (!pAudioCodec_)
  
                  {
  
                      printf("codec not found\n");
  
                      return;
  
                  }
  
                  // open the codec
  
                  if (avcodec_open(pAudioCodecCtx_, pAudioCodec_) < 0)
  
                  {
  
                      printf("could not open codec\n");
  
                      return;
  
                  }
  
  
  
                  // Allocate memory for output
  
                  if (!initAudioOutputBuf())
  
                  {
  
                      printf("Can't allocate memory for audio output bitstream\n");
  
                      return;
  
                  }
  
  
  
                  // Allocate the audio frame
  
                  if (!initAudioFrame())
  
                  {
  
                      printf("Can't init audio frame\n");
  
                      return;
  
                  }
  
  
  
                  if (url_fopen(&pOutputFormatCtx_->pb, fileName.toStdString().c_str(), URL_WRONLY) < 0)
  
                  {
  
                      printf("Could not open '%s'\n", fileName.toStdString().c_str());
  
                      return;
  
                  }
  
                  av_write_header(pOutputFormatCtx_);
  
              }
  
  
  
              void MediaMuxer::addVideoStream(QString fileName)
  
              {
  
                  // Add the video stream
  
                  pVideoStream_ = ffmpeg::av_new_stream(pOutputFormatCtx_, 0);
  
                  if (!pVideoStream_)
  
                  {
  
                      printf("Could not allocate stream\n");
  
                      return;
  
                  }
  
  
  
                  pVideoCodecCtx_ = pVideoStream_->codec;
  
                  pVideoCodecCtx_->codec_id = pOutputFormat_->video_codec;
  
                  pVideoCodecCtx_->codec_type = ffmpeg::AVMEDIA_TYPE_VIDEO;
  
  
  
                  pVideoCodecCtx_->bit_rate = Bitrate;
  
                  pVideoCodecCtx_->width = getWidth();
  
                  pVideoCodecCtx_->height = getHeight();
  
                  pVideoCodecCtx_->time_base.den = FPS;
  
                  pVideoCodecCtx_->time_base.num = 1;
  
                  pVideoCodecCtx_->gop_size = Gop;
  
                  pVideoCodecCtx_->pix_fmt = ffmpeg::PIX_FMT_YUV420P;
  
  
  
                  avcodec_thread_init(pVideoCodecCtx_, 10);
  
  
  
                  // some formats want stream headers to be separate
  
                  if (pOutputFormatCtx_->oformat->flags & AVFMT_GLOBALHEADER)
  
                      pVideoCodecCtx_->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
  
  
                  if (av_set_parameters(pOutputFormatCtx_, NULL) < 0)
  
                  {
  
                      printf("Invalid output format parameters\n");
  
                      return;
  
                  }
  
  
  
                  //ffmpeg::dump_format(pOutputFormatCtx_, 0, fileName.toStdString().c_str(), 1);
  
  
  
                  // open_video
  
                  // find the video encoder
  
                  pVideoCodec_ = avcodec_find_encoder(pVideoCodecCtx_->codec_id);
  
                  if (!pVideoCodec_)
  
                  {
  
                      printf("codec not found\n");
  
                      return;
  
                  }
  
                  // open the codec
  
                  if (avcodec_open(pVideoCodecCtx_, pVideoCodec_) < 0)
  
                  {
  
                      printf("could not open codec\n");
  
                      return;
  
                  }
  
  
  
                  // Allocate memory for output
  
                  if (!initOutputBuf())
  
                  {
  
                      printf("Can't allocate memory for output bitstream\n");
  
                      return;
  
                  }
  
  
  
                  // Allocate the YUV frame
  
                  if (!initFrame())
  
                  {
  
                      printf("Can't init frame\n");
  
                      return;
  
                  }
  
  
  
                  if (url_fopen(&pOutputFormatCtx_->pb, fileName.toStdString().c_str(), URL_WRONLY) < 0)
  
                  {
  
                      printf("Could not open '%s'\n", fileName.toStdString().c_str());
  
                      return;
  
                  }
  
                  av_write_header(pOutputFormatCtx_);
  
              }

  Finally, I call alternatively encodeVideo/encodeAudio to encode video and PCM audio frames at specific recording times(pts) :

              int MediaMuxer::encodeVideo(const QImage &img, unsigned pts)
  
              {
  
                  convertImage_sws(img);     // SWS conversion
  
                  pVideoCodecCtx_->coded_frame->pts = pts;  // Set the time stamp
  
                  int out_size = ffmpeg::avcodec_encode_video(pVideoCodecCtx_, outbuf, outbuf_size, ppicture);        
  
                  pVideoCodecCtx_->coded_frame->pts = pts;  // Set the time stamp
  
  
  
                  if (out_size > 0)
  
                  {
  
                      ffmpeg::av_init_packet(&pkt);       
  
                      if (pVideoCodecCtx_->coded_frame->pts != (0x8000000000000000LL))
  
                          pkt.pts = av_rescale_q(pVideoCodecCtx_->coded_frame->pts, pVideoCodecCtx_->time_base, pVideoStream_->time_base);
  
                      if (pVideoCodecCtx_->coded_frame->key_frame)
  
                          pkt.flags |= AV_PKT_FLAG_KEY;
  
  
  
                      pkt.stream_index = pVideoStream_->index;
  
                      pkt.data = outbuf;
  
                      pkt.size = out_size;
  
                      int ret = ffmpeg::av_interleaved_write_frame(pOutputFormatCtx_, &pkt);      
  
                      if (ret<0)
  
                          return -1;
  
  
  
                  }
  
                  return out_size;
  
              }
  
  
  
              int MediaMuxer::encodeAudio(unsigned pts)
  
              {
  
                  pAudioCodecCtx_->coded_frame->pts = pts;  // Set the time stamp
  
  
  
                  // simple sound encoding    
  
                  int16_t samples[220] = { 0 }; // buffer
  
                  int n;                // buffer index
  
                  double Fs = 44100.0;  // sampling frequency
  
  
  
                  // Generate audio data
  
                  for (n = 0; n < 220; ++n)   //220 samples (44100*.005sec as the interval between 2 video frames is 10ms)
  
                      samples[n] = 16383.0 * sin(n*1000.0*2.0*M_PI / Fs); //sine wav
  
  
  
                  int  out_size = ffmpeg::avcodec_encode_audio(pAudioCodecCtx_, audio_outbuf, audio_outbuf_size, (const short*)samples);
  
  
  
                  pAudioCodecCtx_->coded_frame->pts = pts;  // Set the time stamp
  
  
  
                  if (out_size>0)
  
                  {
  
                      // Packet
  
                      ffmpeg::AVPacket pkt = { 0 };
  
                      av_init_packet(&pkt);
  
                      pkt.data = NULL; // packet data will be allocated by the encoder
  
                      pkt.size = 0;
  
                      if (pAudioCodecCtx_->coded_frame->pts != (0x8000000000000000LL))
  
                          pkt.pts = av_rescale_q(pAudioCodecCtx_->coded_frame->pts, pAudioCodecCtx_->time_base, pAudioStream_->time_base);
  
                      if (pAudioCodecCtx_->coded_frame->key_frame)
  
                          pkt.flags |= AV_PKT_FLAG_KEY;
  
  
  
                      pkt.stream_index = pAudioStream_->index;
  
                      pkt.data = audio_outbuf;
  
  
  
                      pkt.size = out_size;
  
                      int ret = av_interleaved_write_frame(pOutputFormatCtx_, &pkt);
  
                      if (ret<0)
  
                          return -1;
  
                      av_free_packet(&pkt);
  
                  }       
  
                  //end simple sound encoding
  
  
  
                  return pkt.size;
  
              }

  The result is a nice video with some audio behind (either a regular beeping sound at regular intervals but ending way earlier than the video or a continuous longer sound that also last shorter than the video).

  I want to generate a beeping sound each time the function encodeAudio() is called - at non-regular intervals. I have tried to modify the sampling rate, the buffer size, the pkt size and the number of samples but without any success. I also tried to set the pts at different times but it did not get me where I want to be. Could someone please help ?