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> avframe(avcodec_alloc_frame());

[scherkus (not reviewing), 2012/06/08 00:51:22]

nit: FFVD uses av_frame

[DaleCurtis, 2012/06/08 01:00:01]

Done.

 
   // Read until we hit EOF or we've read the requested number of frames.
   AVPacket avpkt;
   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);
+    avcodec_get_frame_defaults(avframe.get());
+    int frame_decoded = 0;
+    int result = avcodec_decode_audio4(
+        codec_context_, avframe.get(), &frame_decoded, &avpkt);
     av_free_packet(&avpkt);
 
     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 = avframe->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(avframe->data[0],
                                     audio_data[channel_index] + current_frame,
                                     channels,
                                     channel_index,
                                     bytes_per_sample,
                                     frames_read)) {
         DLOG(WARNING)
             << "AudioFileReader::Read() : Unsupported sample format : "
             << codec_context_->sample_fmt
             << " codec_->id : " << codec_->id;
         return false;
       }
     }
 
     current_frame += frames_read;
   }
 
   return true;
 }
 
 }  // namespace media