Switch to using avcodec_decode_audio4, avcodec_alloc_context3.

media/filters/audio_file_reader.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/audio_file_reader.h"
 
 #include <string>
 #include "base/basictypes.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 106 matching lines @@
   DCHECK_EQ(audio_data.size(), channels);
   if (audio_data.size() != channels)
     return false;
 
   DCHECK(format_context_ && codec_context_ && codec_);
   if (!format_context_ || !codec_context_ || !codec_) {
     DLOG(WARNING) << "AudioFileReader::Read() : reader is not opened!";
     return false;
   }
 
-  scoped_ptr_malloc<int16, ScopedPtrAVFree> output_buffer(
-      static_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE)));
+  // Holds decoded audio.
+  scoped_ptr_malloc<AVFrame, ScopedPtrAVFree> av_frame(avcodec_alloc_frame());
 
   // Read until we hit EOF or we've read the requested number of frames.
-  AVPacket avpkt;
+  AVPacket packet;
   int result = 0;
   size_t current_frame = 0;
 
   while (current_frame < number_of_frames &&
-         (result = av_read_frame(format_context_, &avpkt)) >= 0) {
-    int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
-    result = avcodec_decode_audio3(codec_context_,
-                                   output_buffer.get(),
-                                   &out_size,
-                                   &avpkt);
-    av_free_packet(&avpkt);
+         (result = av_read_frame(format_context_, &packet)) >= 0) {
+    avcodec_get_frame_defaults(av_frame.get());
+    int frame_decoded = 0;
+    int result = avcodec_decode_audio4(
+        codec_context_, av_frame.get(), &frame_decoded, &packet);
+    av_free_packet(&packet);
 
     if (result < 0) {
       DLOG(WARNING)
           << "AudioFileReader::Read() : error in avcodec_decode_audio3() -"
           << result;
 
       // Fail if nothing has been decoded, otherwise return partial data.
       return current_frame > 0;
     }
 
+    if (!frame_decoded)
+      continue;
+
     // Determine the number of sample-frames we just decoded.
     size_t bytes_per_sample =
         av_get_bytes_per_sample(codec_context_->sample_fmt);
-    size_t frames_read = out_size / (channels * bytes_per_sample);
+    size_t frames_read = av_frame->nb_samples;
 
     // Truncate, if necessary, if the destination isn't big enough.
     if (current_frame + frames_read > number_of_frames)
       frames_read = number_of_frames - current_frame;
 
     // Deinterleave each channel and convert to 32bit floating-point
     // with nominal range -1.0 -> +1.0.
     for (size_t channel_index = 0; channel_index < channels;
          ++channel_index) {
-      if (!DeinterleaveAudioChannel(output_buffer.get(),
+      if (!DeinterleaveAudioChannel(av_frame->data[0],
                                     audio_data[channel_index] + current_frame,
                                     channels,
                                     channel_index,
                                     bytes_per_sample,
                                     frames_read)) {
         DLOG(WARNING)

[rbultje1, 2012/06/08 14:29:01]

You know when I see this, I cry, because FFmpeg (or Libav) does the exact
inverse of this just before outputting the audio back to Chrome (i.e internally
in pretty much every audio codec on the planet, samples are handled and stored
per-channel).

What a waste of cycles... Fortunately someone is working on fixing that
(upstream), please encourage him. ;-).

             << "AudioFileReader::Read() : Unsupported sample format : "
             << codec_context_->sample_fmt
             << " codec_->id : " << codec_->id;
         return false;
       }
     }
 
     current_frame += frames_read;
   }
 
   return true;
 }
 
 }  // namespace media