Recherche avancée

Sur d’autres sites (5851)

• FFmpeg library : webm (vorbis) audio to aac conversion

  3 janvier 2014, par taansari

  I have written a small program to convert webm (vorbis) audio to aac format, using FFmpeg libraries - C++ (on Windows using 32 bit Zeranoe FFmpeg builds). After writing this program, I find it is sometimes converting files as per expectation, and at other times, results in larger duration files, and audio playback is broken/awkward as well.

  This code appears to be working fine for mp3, which also uses FLTP format (same as vorbis), so technically both look similar.

  Please see below sample code I am using :

  ////////////////////////////////////////////////
  
  #include "stdafx.h"
  
  
  
  #include <iostream>
  
  #include <fstream>
  
  
  
  #include <string>
  
  #include <vector>
  
  #include <map>
  
  
  
  #include <deque>
  
  #include <queue>
  
  
  
  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  extern "C"
  
  {
  
  #include "libavcodec/avcodec.h"
  
  #include "libavformat/avformat.h"
  
  #include "libavdevice/avdevice.h"
  
  #include "libswscale/swscale.h"
  
  #include "libavutil/dict.h"
  
  #include "libavutil/error.h"
  
  #include "libavutil/opt.h"
  
  #include <libavutil></libavutil>fifo.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  #include <libavutil></libavutil>samplefmt.h>
  
  #include <libswresample></libswresample>swresample.h>
  
  }
  
  
  
  AVFormatContext*    fmt_ctx= NULL;
  
  int                    audio_stream_index = -1;
  
  AVCodecContext *    codec_ctx_audio = NULL;
  
  AVCodec*            codec_audio = NULL;
  
  AVFrame*            decoded_frame = NULL;
  
  uint8_t**            audio_dst_data = NULL;
  
  int                    got_frame = 0;
  
  int                    audiobufsize = 0;
  
  AVPacket            input_packet;
  
  int                    audio_dst_linesize = 0;
  
  int                    audio_dst_bufsize = 0;
  
  SwrContext *        swr = NULL;
  
  
  
  AVOutputFormat *    output_format = NULL ;
  
  AVFormatContext *    output_fmt_ctx= NULL;
  
  AVStream *            audio_st = NULL;
  
  AVCodec *            audio_codec = NULL;
  
  double                audio_pts = 0.0;
  
  AVFrame *            out_frame = avcodec_alloc_frame();
  
  
  
  int                    audio_input_frame_size = 0;
  
  
  
  uint8_t *            audio_data_buf = NULL;
  
  uint8_t *            audio_out = NULL;
  
  int                    audio_bit_rate;
  
  int                    audio_sample_rate;
  
  int                    audio_channels;
  
  
  
  int decode_packet();
  
  int open_audio_input(char* src_filename);
  
  int decode_frame();
  
  
  
  int open_encoder(char* output_filename);
  
  AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec,
  
      enum AVCodecID codec_id);
  
  int open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st);
  
  void close_audio(AVFormatContext *oc, AVStream *st);
  
  void write_audio_frame(uint8_t ** audio_src_data, int audio_src_bufsize);
  
  
  
  int open_audio_input(char* src_filename)
  
  {
  
      int i =0;
  
      /* open input file, and allocate format context */
  
      if (avformat_open_input(&amp;fmt_ctx, src_filename, NULL, NULL) &lt; 0)
  
      {
  
          fprintf(stderr, "Could not open source file %s\n", src_filename);
  
          exit(1);
  
      }
  
  
  
      // Retrieve stream information
  
      if(avformat_find_stream_info(fmt_ctx, NULL)&lt;0)
  
          return -1; // Couldn&#39;t find stream information
  
  
  
      // Dump information about file onto standard error
  
      av_dump_format(fmt_ctx, 0, src_filename, 0);
  
  
  
      // Find the first video stream
  
      for(i=0; inb_streams; i++)
  
      {
  
          if(fmt_ctx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO)
  
          {
  
              audio_stream_index=i;
  
              break;
  
          }
  
      }
  
      if ( audio_stream_index != -1 )
  
      {
  
          // Get a pointer to the codec context for the audio stream
  
          codec_ctx_audio=fmt_ctx->streams[audio_stream_index]->codec;
  
  
  
          // Find the decoder for the video stream
  
          codec_audio=avcodec_find_decoder(codec_ctx_audio->codec_id);
  
          if(codec_audio==NULL) {
  
              fprintf(stderr, "Unsupported audio codec!\n");
  
              return -1; // Codec not found
  
          }
  
  
  
          // Open codec
  
          AVDictionary *codecDictOptions = NULL;
  
          if(avcodec_open2(codec_ctx_audio, codec_audio, &amp;codecDictOptions)&lt;0)
  
              return -1; // Could not open codec
  
  
  
          // Set up SWR context once you&#39;ve got codec information
  
          swr = swr_alloc();
  
          av_opt_set_int(swr, "in_channel_layout",  codec_ctx_audio->channel_layout, 0);
  
          av_opt_set_int(swr, "out_channel_layout", codec_ctx_audio->channel_layout,  0);
  
          av_opt_set_int(swr, "in_sample_rate",     codec_ctx_audio->sample_rate, 0);
  
          av_opt_set_int(swr, "out_sample_rate",    codec_ctx_audio->sample_rate, 0);
  
          av_opt_set_sample_fmt(swr, "in_sample_fmt",  codec_ctx_audio->sample_fmt, 0);
  
          av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16,  0);
  
          swr_init(swr);
  
  
  
          // Allocate audio frame
  
          if ( decoded_frame == NULL ) decoded_frame = avcodec_alloc_frame();
  
          int nb_planes = 0;
  
          AVStream* audio_stream = fmt_ctx->streams[audio_stream_index];
  
          nb_planes = av_sample_fmt_is_planar(codec_ctx_audio->sample_fmt) ? codec_ctx_audio->channels : 1;
  
          int tempSize =  sizeof(uint8_t *) * nb_planes;
  
          audio_dst_data = (uint8_t**)av_mallocz(tempSize);
  
          if (!audio_dst_data)
  
          {
  
              fprintf(stderr, "Could not allocate audio data buffers\n");
  
          }
  
          else
  
          {
  
              for ( int i = 0 ; i &lt; nb_planes ; i ++ )
  
              {
  
                  audio_dst_data[i] = NULL;
  
              }
  
          }
  
      }
  
  }
  
  
  
  
  
  int decode_frame()
  
  {
  
      int rv = 0;
  
      got_frame = 0;
  
      if ( fmt_ctx == NULL  )
  
      {
  
          return rv;
  
      }
  
      int ret = 0;
  
      audiobufsize = 0;
  
      rv = av_read_frame(fmt_ctx, &amp;input_packet);
  
      if ( rv &lt; 0 )
  
      {
  
          return rv;
  
      }
  
      rv = decode_packet();
  
      // Free the input_packet that was allocated by av_read_frame
  
      av_free_packet(&amp;input_packet);
  
      return rv;
  
  }
  
  
  
  int decode_packet()
  
  {
  
      int rv = 0;
  
      int ret = 0;
  
  
  
      //audio stream?
  
      if(input_packet.stream_index == audio_stream_index)
  
      {
  
          /* decode audio frame */
  
          rv = avcodec_decode_audio4(codec_ctx_audio, decoded_frame, &amp;got_frame, &amp;input_packet);
  
          if (rv &lt; 0)
  
          {
  
              fprintf(stderr, "Error decoding audio frame\n");
  
              //return ret;
  
          }
  
          else
  
          {
  
              if (got_frame)
  
              {
  
                  if ( audio_dst_data[0] == NULL )
  
                  {
  
                       ret = av_samples_alloc(audio_dst_data, &amp;audio_dst_linesize, decoded_frame->channels,
  
                          decoded_frame->nb_samples, (AVSampleFormat)decoded_frame->format, 1);
  
                      if (ret &lt; 0)
  
                      {
  
                          fprintf(stderr, "Could not allocate audio buffer\n");
  
                          return AVERROR(ENOMEM);
  
                      }
  
                      /* TODO: extend return code of the av_samples_* functions so that this call is not needed */
  
                      audio_dst_bufsize = av_samples_get_buffer_size(NULL, audio_st->codec->channels,
  
                          decoded_frame->nb_samples, (AVSampleFormat)decoded_frame->format, 1);
  
  
  
                      //int16_t* outputBuffer = ...;
  
                      swr_convert(swr, audio_dst_data, out_frame->nb_samples,
  
                                  (const uint8_t **)(decoded_frame->data), decoded_frame->nb_samples);
  
                      //swr_convert( swr, audio_dst_data, out_frame->nb_samples, (const uint8_t**) decoded_frame->extended_data, decoded_frame->nb_samples );
  
                  }
  
                  /* copy audio data to destination buffer:
  
                  * this is required since rawaudio expects non aligned data */
  
                  //av_samples_copy(audio_dst_data, decoded_frame->data, 0, 0,
  
                  //    decoded_frame->nb_samples, decoded_frame->channels, (AVSampleFormat)decoded_frame->format);
  
              }
  
          }
  
      }
  
      return rv;
  
  }
  
  
  
  
  
  int open_encoder(char* output_filename )
  
  {
  
      int rv = 0;
  
  
  
      /* allocate the output media context */
  
      AVOutputFormat *opfmt = NULL;
  
  
  
      avformat_alloc_output_context2(&amp;output_fmt_ctx, opfmt, NULL, output_filename);
  
      if (!output_fmt_ctx) {
  
          printf("Could not deduce output format from file extension: using MPEG.\n");
  
          avformat_alloc_output_context2(&amp;output_fmt_ctx, NULL, "mpeg", output_filename);
  
      }
  
      if (!output_fmt_ctx) {
  
          rv = -1;
  
      }
  
      else
  
      {
  
          output_format = output_fmt_ctx->oformat;
  
      }
  
  
  
      /* Add the audio stream using the default format codecs
  
      * and initialize the codecs. */
  
      audio_st = NULL;
  
  
  
      if ( output_fmt_ctx )
  
      {
  
          if (output_format->audio_codec != AV_CODEC_ID_NONE)
  
          {
  
              audio_st = add_audio_stream(output_fmt_ctx, &amp;audio_codec, output_format->audio_codec);
  
          }
  
  
  
          /* Now that all the parameters are set, we can open the audio and
  
          * video codecs and allocate the necessary encode buffers. */
  
          if (audio_st)
  
          {
  
              rv = open_audio(output_fmt_ctx, audio_codec, audio_st);
  
              if ( rv &lt; 0 ) return rv;
  
          }
  
  
  
          av_dump_format(output_fmt_ctx, 0, output_filename, 1);
  
          /* open the output file, if needed */
  
          if (!(output_format->flags &amp; AVFMT_NOFILE))
  
          {
  
              if (avio_open(&amp;output_fmt_ctx->pb, output_filename, AVIO_FLAG_WRITE) &lt; 0) {
  
                  fprintf(stderr, "Could not open &#39;%s&#39;\n", output_filename);
  
                  rv = -1;
  
              }
  
              else
  
              {
  
                  /* Write the stream header, if any. */
  
                  if (avformat_write_header(output_fmt_ctx, NULL) &lt; 0)
  
                  {
  
                      fprintf(stderr, "Error occurred when opening output file\n");
  
                      rv = -1;
  
                  }
  
              }
  
          }
  
      }
  
  
  
      return rv;
  
  }
  
  
  
  AVStream *add_audio_stream(AVFormatContext *oc, AVCodec **codec,
  
      enum AVCodecID codec_id)
  
  {
  
      AVCodecContext *c;
  
      AVStream *st;
  
  
  
      /* find the audio encoder */
  
      *codec = avcodec_find_encoder(codec_id);
  
      if (!(*codec)) {
  
          fprintf(stderr, "Could not find codec\n");
  
          exit(1);
  
      }
  
  
  
      st = avformat_new_stream(oc, *codec);
  
      if (!st) {
  
          fprintf(stderr, "Could not allocate stream\n");
  
          exit(1);
  
      }
  
      st->id = 1;
  
  
  
      c = st->codec;
  
  
  
      /* put sample parameters */
  
      c->sample_fmt  = AV_SAMPLE_FMT_S16;
  
      c->bit_rate    = audio_bit_rate;
  
      c->sample_rate = audio_sample_rate;
  
      c->channels    = audio_channels;
  
  
  
      // some formats want stream headers to be separate
  
      if (oc->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
          c->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
      return st;
  
  }
  
  
  
  int open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
  
  {
  
      int ret=0;
  
      AVCodecContext *c;
  
  
  
      st->duration = fmt_ctx->duration;
  
      c = st->codec;
  
  
  
      /* open it */
  
      ret = avcodec_open2(c, codec, NULL) ;
  
      if ( ret &lt; 0)
  
      {
  
          fprintf(stderr, "could not open codec\n");
  
          return -1;
  
          //exit(1);
  
      }
  
  
  
      if (c->codec->capabilities &amp; CODEC_CAP_VARIABLE_FRAME_SIZE)
  
          audio_input_frame_size = 10000;
  
      else
  
          audio_input_frame_size = c->frame_size;
  
      int tempSize = audio_input_frame_size *
  
          av_get_bytes_per_sample(c->sample_fmt) *
  
          c->channels;
  
      return ret;
  
  }
  
  
  
  void close_audio(AVFormatContext *oc, AVStream *st)
  
  {
  
      avcodec_close(st->codec);
  
  }
  
  
  
  void write_audio_frame(uint8_t ** audio_src_data, int audio_src_bufsize)
  
  {
  
      AVFormatContext *oc = output_fmt_ctx;
  
      AVStream *st = audio_st;
  
      if ( oc == NULL || st == NULL ) return;
  
      AVCodecContext *c;
  
      AVPacket pkt = { 0 }; // data and size must be 0;
  
      int got_packet;
  
  
  
      av_init_packet(&amp;pkt);
  
      c = st->codec;
  
  
  
      out_frame->nb_samples = audio_input_frame_size;
  
      int buf_size =         audio_src_bufsize *
  
          av_get_bytes_per_sample(c->sample_fmt) *
  
          c->channels;
  
      avcodec_fill_audio_frame(out_frame, c->channels, c->sample_fmt,
  
          (uint8_t *) *audio_src_data,
  
          buf_size, 1);
  
      avcodec_encode_audio2(c, &amp;pkt, out_frame, &amp;got_packet);
  
      if (!got_packet)
  
      {
  
      }
  
      else
  
      {
  
          if (pkt.pts != AV_NOPTS_VALUE)
  
              pkt.pts =  av_rescale_q(pkt.pts, st->codec->time_base, st->time_base);
  
          if (pkt.dts != AV_NOPTS_VALUE)
  
              pkt.dts = av_rescale_q(pkt.dts, st->codec->time_base, st->time_base);
  
          if ( c &amp;&amp; c->coded_frame &amp;&amp; c->coded_frame->key_frame)
  
              pkt.flags |= AV_PKT_FLAG_KEY;
  
  
  
           pkt.stream_index = st->index;
  
          pkt.flags |= AV_PKT_FLAG_KEY;
  
          /* Write the compressed frame to the media file. */
  
          if (av_interleaved_write_frame(oc, &amp;pkt) != 0)
  
          {
  
              fprintf(stderr, "Error while writing audio frame\n");
  
              exit(1);
  
          }
  
      }
  
      av_free_packet(&amp;pkt);
  
  }
  
  
  
  
  
  void write_delayed_frames(AVFormatContext *oc, AVStream *st)
  
  {
  
      AVCodecContext *c = st->codec;
  
      int got_output = 0;
  
      int ret = 0;
  
      AVPacket pkt;
  
      pkt.data = NULL;
  
      pkt.size = 0;
  
      av_init_packet(&amp;pkt);
  
      int i = 0;
  
      for (got_output = 1; got_output; i++)
  
      {
  
          ret = avcodec_encode_audio2(c, &amp;pkt, NULL, &amp;got_output);
  
          if (ret &lt; 0)
  
          {
  
              fprintf(stderr, "error encoding frame\n");
  
              exit(1);
  
          }
  
          static int64_t tempPts = 0;
  
          static int64_t tempDts = 0;
  
          /* If size is zero, it means the image was buffered. */
  
          if (got_output)
  
          {
  
              if (pkt.pts != AV_NOPTS_VALUE)
  
                  pkt.pts =  av_rescale_q(pkt.pts, st->codec->time_base, st->time_base);
  
              if (pkt.dts != AV_NOPTS_VALUE)
  
                  pkt.dts = av_rescale_q(pkt.dts, st->codec->time_base, st->time_base);
  
              if ( c &amp;&amp; c->coded_frame &amp;&amp; c->coded_frame->key_frame)
  
                  pkt.flags |= AV_PKT_FLAG_KEY;
  
  
  
              pkt.stream_index = st->index;
  
              /* Write the compressed frame to the media file. */
  
              ret = av_interleaved_write_frame(oc, &amp;pkt);
  
          }
  
          else
  
          {
  
              ret = 0;
  
          }
  
          av_free_packet(&amp;pkt);
  
      }
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      /* register all formats and codecs */
  
      av_register_all();
  
      avcodec_register_all();
  
      avformat_network_init();
  
      avdevice_register_all();
  
      int i =0;
  
      int ret=0;
  
      char src_filename[90] = "test_a.webm";
  
      char dst_filename[90] = "output.aac";
  
      open_audio_input(src_filename);
  
      if ( codec_ctx_audio->bit_rate == 0 ) codec_ctx_audio->bit_rate = 112000;
  
      audio_bit_rate        = codec_ctx_audio->bit_rate;
  
      audio_sample_rate    = codec_ctx_audio->sample_rate;
  
      audio_channels        = codec_ctx_audio->channels;
  
      open_encoder( dst_filename );
  
      while(1)
  
      {
  
          int rv = decode_frame();
  
          if ( rv &lt; 0 )
  
          {
  
              break;
  
          }
  
  
  
          if (audio_st)
  
          {
  
              audio_pts = (double)audio_st->pts.val * audio_st->time_base.num /
  
                  audio_st->time_base.den;
  
          }
  
          else
  
          {
  
              audio_pts = 0.0;
  
          }
  
          if ( codec_ctx_audio )
  
          {
  
              if ( got_frame)
  
              {
  
                  write_audio_frame( audio_dst_data, audio_dst_bufsize );
  
              }
  
          }
  
          if ( audio_dst_data[0] )
  
          {
  
              av_freep(&amp;audio_dst_data[0]);
  
              audio_dst_data[0] = NULL;
  
          }
  
          printf("\naudio_pts: %.3f", audio_pts);
  
      }
  
      while(1)
  
      {
  
          if ( audio_dst_data &amp;&amp; audio_dst_data[0] )
  
          {
  
              av_freep(&amp;audio_dst_data[0]);
  
              audio_dst_data[0] = NULL;
  
          }
  
          ret = av_samples_alloc(audio_dst_data, NULL, codec_ctx_audio->channels,
  
              decoded_frame->nb_samples, AV_SAMPLE_FMT_S16, 0);
  
          ret = swr_convert(swr, audio_dst_data, out_frame->nb_samples,NULL, 0);
  
          if ( ret &lt;= 0 ) break;
  
          write_audio_frame( audio_dst_data, audio_dst_bufsize );
  
      }
  
      write_delayed_frames( output_fmt_ctx, audio_st );
  
      av_write_trailer(output_fmt_ctx);
  
      close_audio( output_fmt_ctx, audio_st);
  
      swr_free(&amp;swr);
  
      avcodec_free_frame(&amp;out_frame);
  
      getch();
  
      return 0;
  
  }
  
  </queue></deque></map></vector></string></fstream></iostream>

  "test_a.webm" input file results in longer duration (40 second output), and if I change it to "jet.webm", it is converted fine.

  Both input files are approximately 18 second duration.

  For reference, these files can be downloaded from links below :

  http://www.filedropper.com/testa ,
  http://www.filedropper.com/jet

  Alternatively, they are zipped and uploaded elsewhere as well :

  http://www.files.com/shared/52c3eefe990ea/test_audio_files.zip

  Could someone kindly guide on what I am doing wrong here ?

  Thanks in advance...

  p.s. These files are taken/extracted from different online sources/demos.

  Edit 2-1-14 : After debugging, I can see audio_pts variable is being populated incorrectly. It relies on audio_st->pts.val, which is automatically calculated upon calling av_interleaved_write_frame() function. I cannot step inside av_interleaved_write_frame() function since I am on Windows, using libav dlls/libs.

  So,

  For jet.webm file (whose conversion is fine), audio_st->pts.val goes till maximum : 1665567, and audio_pts becomes :

  1665567*1/90000 = 18.5063

  For test_a.webm file (whose conversion is bad), audio_st->pts.val goes till maximum : 3606988, and audio_pts becomes :

  3606988*1/90000 = 40.0776

  • reference line : audio_pts = (double)audio_st->pts.val * audio_st->time_base.num /
    audio_st->time_base.den ;

  Since PTS is very off, it shouldn't be playing fine logically as well. But I cannot say av_interleaved_write_frame() function is doing it wrong ; surely something cleaner can be managed on my end.

  Edit 3-1-14 : Discovered one more thing : while reading jet.webm file, decoded frame's nb_sample are always 1024 (except for 1st frame : 576), but in case of test_a.webm file, nb_samples are either 1024, or 128, with exceptions of 576 (less frequent). If I ignore writing of frame when nb_sample is 128, I get approximately same file length in the end, but you can hear bits and pieces are missing here and there.

  How can I deal with this ?

• Revision f167433d9c : fix the mv_ref_idx issue The following issue was reported : https://code.google

  20 août 2013, par Jim Bankoski

  Changed Paths :
   Modify /vp9/common/vp9_mvref_common.c

  
  
  fix the mv_ref_idx issue

  The following issue was reported :
  https://code.google.com/p/webm/issues/detail?id=601&q=jimbankoski&sort=-id&colsp
  ec=ID%20Pri%20mstone%20ReleaseBlock%20Type%20Component%20Status%20Owner%20Summar
  y

  This code makes the choice and code cleaner and removes any question
  about whether the border needs to be checked.

  Change-Id : Ia7aecfb3168e340618805bd318499176c2989597

• Pushing Projects to Github

  17 février 2012, par Multimedia Mike — Game Hacking, Python

  I finally got around to importing some old projects into my Github account. I guess it’s good to have a backup out there in the cloud.

  GhettoRSS
  https://github.com/multimediamike/GhettoRSS
  I describe this as a true offline RSS reader. Technically, it’s arguably not a true offline RSS reader. Rather, it does what most people actually want an offline RSS reader to do.

  I wrote this about 2 years ago when I had a long daily train ride with a disconnected netbook. I quickly learned that I couldn’t count on offline RSS readers simply because most RSS feeds to not contain much meat. Thus, I created a program that follows URLs in RSS feeds, downloads web pages and supporting images and CSS files, and caches them in an offline database which can be read via a local web browser.

  I wrote more information about this little project 2 years ago (here is part 1 and here is part 2). I fixed a few bugs in preparation for posting it but I probably won’t work on this anymore since I don’t have any use for it (the commute is long gone, but I didn’t even use it when I was commuting because I decided I just didn’t care enough to read the feeds on the train).

  xbfuse
  https://github.com/multimediamike/xbfuse
  This is a FUSE module for mounting Xbox/360 optical disc filesystems. Here is when I first discussed it. The tool has had its own little homepage for a long time. This tool has seen some development, as I learned from Googling for “xbfuse”. Regrettably, no one who has modified the tool has ever contacted me about it (at least, not that I can recall). This is unfortunate because the patches I have seen floating around which fix my xbfuse for various installations usually boil down replacing many occurrences of an include path in the autotool-generated build system. There is probably a simpler, cleaner fix.

  gcfuse
  https://github.com/multimediamike/gcfuse
  Written prior to xbfuse, this is a FUSE module for mounting GameCube optical disc filesystems. I first discussed this here and here. This tool has not seen too much direct development although someone eventually used it as the basis for WiiFuse which, as you can predict, mounts optical disc filesystems from Nintendo Wii games.