Switch to using avcodec_decode_audio4, avcodec_alloc_context3.

media/ffmpeg/ffmpeg_unittest.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.
 
 // ffmpeg_unittests verify that the parts of the FFmpeg API that Chromium uses
 // function as advertised for each media format that Chromium supports.  This
 // mostly includes stuff like reporting proper timestamps, seeking to
 // keyframes, and supporting certain features like reordered_opaque.
 //
 
@@ skipping 72 matching lines @@
         video_stream_index_(-1),
         audio_buffer_(NULL),
         video_buffer_(NULL),
         decoded_audio_time_(AV_NOPTS_VALUE),
         decoded_audio_duration_(AV_NOPTS_VALUE),
         decoded_video_time_(AV_NOPTS_VALUE),
         decoded_video_duration_(AV_NOPTS_VALUE),
         duration_(AV_NOPTS_VALUE) {
     InitializeFFmpeg();
 
-    audio_buffer_.reset(
-        reinterpret_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE)));
+    audio_buffer_.reset(avcodec_alloc_frame());
     video_buffer_.reset(avcodec_alloc_frame());
   }
 
   virtual ~FFmpegTest() {
   }
 
   void OpenAndReadFile(const std::string& name) {
     OpenFile(name);
     OpenCodecs();
     ReadRemainingFile();
@@ skipping 127 matching lines @@
 
   bool StepDecodeAudio() {
     EXPECT_TRUE(has_audio());
     if (!has_audio() || audio_packets_.empty()) {
       return false;
     }
 
     // Decode until output is produced, end of stream, or error.
     while (true) {
       int result = 0;
-      int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
+      int got_audio = 0;
       bool end_of_stream = false;
 
       AVPacket packet;
       if (audio_packets_.empty()) {
         av_init_packet(&packet);
         end_of_stream = true;
       } else {
         memcpy(&packet, audio_packets_.peek(), sizeof(packet));
       }
 
-      result = avcodec_decode_audio3(av_audio_context(), audio_buffer_.get(),
-                                     &size_out, audio_packets_.peek());
+      avcodec_get_frame_defaults(audio_buffer_.get());
+      result = avcodec_decode_audio4(av_audio_context(), audio_buffer_.get(),
+                                     &got_audio, &packet);
       if (!audio_packets_.empty()) {
         audio_packets_.pop();
       }
 
       EXPECT_GE(result, 0) << "Audio decode error.";
-      if (result < 0 || (size_out == 0 && end_of_stream)) {
+      if (result < 0 || (got_audio == 0 && end_of_stream)) {
         return false;
       }
 
       if (result > 0) {
-        // TODO(scherkus): move this to ffmpeg_common.h and dedup.
-        int64 denominator = av_audio_context()->channels *
-            av_get_bytes_per_sample(av_audio_context()->sample_fmt) *
-            av_audio_context()->sample_rate;
-        double microseconds = size_out /
-            (denominator /
-             static_cast<double>(base::Time::kMicrosecondsPerSecond));
+        double microseconds = 1.0L * audio_buffer_->nb_samples /
+            av_audio_context()->sample_rate *
+            base::Time::kMicrosecondsPerSecond;
         decoded_audio_duration_ = static_cast<int64>(microseconds);
 
         if (packet.pts == static_cast<int64>(AV_NOPTS_VALUE)) {
           EXPECT_NE(decoded_audio_time_, static_cast<int64>(AV_NOPTS_VALUE))
               << "We never received an initial timestamped audio packet! "
               << "Looks like there's a seeking/parsing bug in FFmpeg.";
           decoded_audio_time_ += decoded_audio_duration_;
         } else {
           decoded_audio_time_ =
               ConvertFromTimeBase(av_audio_stream()->time_base, packet.pts)
@@ skipping 18 matching lines @@
       bool end_of_stream = false;
 
       AVPacket packet;
       if (video_packets_.empty()) {
         av_init_packet(&packet);
         end_of_stream = true;
       } else {
         memcpy(&packet, video_packets_.peek(), sizeof(packet));
       }
 
+      avcodec_get_frame_defaults(video_buffer_.get());
       av_video_context()->reordered_opaque = packet.pts;
       result = avcodec_decode_video2(av_video_context(), video_buffer_.get(),
                                      &got_picture, &packet);
       if (!video_packets_.empty()) {
         video_packets_.pop();
       }
 
       EXPECT_GE(result, 0) << "Video decode error.";
       if (result < 0 || (got_picture == 0 && end_of_stream)) {
         return false;
@@ skipping 80 matching lines @@
     av_register_protocol2(&kFFmpegFileProtocol, sizeof(kFFmpegFileProtocol));
     initialized = true;
   }
 
   AVFormatContext* av_format_context_;
   int audio_stream_index_;
   int video_stream_index_;
   AVPacketQueue audio_packets_;
   AVPacketQueue video_packets_;
 
-  scoped_ptr_malloc<int16, media::ScopedPtrAVFree> audio_buffer_;
+  scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> audio_buffer_;
   scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> video_buffer_;
 
   int64 decoded_audio_time_;
   int64 decoded_audio_duration_;
   int64 decoded_video_time_;
   int64 decoded_video_duration_;
   int64 duration_;
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegTest);
 };
@@ skipping 212 matching lines @@
   SeekTo(0.4);
   ReadRemainingFile();
   EXPECT_TRUE(StepDecodeVideo());
   VLOG(1) << decoded_video_time();
 
   CloseCodecs();
   CloseFile();
 }
 
 }  // namespace media