Switch to using avcodec_decode_audio4, avcodec_alloc_context3.

media/test/ffmpeg_tests/ffmpeg_tests.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.
 
 // Software qualification test for FFmpeg.  This test is used to certify that
 // software decoding quality and performance of FFmpeg meets a mimimum
 // standard.
 
 #include <iomanip>
 #include <iostream>
@@ skipping 220 matching lines @@
 
   // Initialize our codec.
   if (avcodec_open2(codec_context, codec, NULL) < 0) {
     std::cerr << "Error: Could not open codec "
               << codec_context->codec->name << " for "
               << in_path.value() << std::endl;
     return 1;
   }
 
   // Buffer used for audio decoding.
-  scoped_ptr_malloc<int16, media::ScopedPtrAVFree> samples(
-      reinterpret_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE)));
-
-  // Buffer used for video decoding.
-  scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> frame(
+  scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> audio_frame(
       avcodec_alloc_frame());
-  if (!frame.get()) {
+  if (!audio_frame.get()) {
     std::cerr << "Error: avcodec_alloc_frame for "
               << in_path.value() << std::endl;
     return 1;
+  }
+
+  // Buffer used for video decoding.
+  scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> video_frame(
+      avcodec_alloc_frame());
+  if (!video_frame.get()) {
+    std::cerr << "Error: avcodec_alloc_frame for "
+              << in_path.value() << std::endl;
+    return 1;
   }
 
   // Stats collector.
   EnterTimingSection();
   std::vector<double> decode_times;
   decode_times.reserve(4096);
   // Parse through the entire stream until we hit EOF.
 #if SHOW_VERBOSE
   base::TimeTicks start = base::TimeTicks::HighResNow();
 #endif
@@ skipping 16 matching lines @@
         packet.size = 0;
       } else {
         break;
       }
     }
 
     // Only decode packets from our target stream.
     if (packet.stream_index == target_stream) {
       int result = -1;
       if (target_codec == AVMEDIA_TYPE_AUDIO) {
-        int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
+        int size_out = 0;
+        int got_audio = 0;
+
+        avcodec_get_frame_defaults(audio_frame.get());
 
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
-        result = avcodec_decode_audio3(codec_context, samples.get(), &size_out,
-                                       &packet);
+        result = avcodec_decode_audio4(codec_context, audio_frame.get(),
+                                       &got_audio, &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
-        if (size_out) {
+        if (got_audio) {
+          size_out = av_samples_get_buffer_size(
+              NULL, codec_context->channels, audio_frame->nb_samples,
+              codec_context->sample_fmt, 1);
+        }
+
+        if (got_audio && size_out) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
           read_result = 0;  // Force continuation.
 
           if (output) {
-            if (fwrite(samples.get(), 1, size_out, output) !=
+            if (fwrite(audio_frame->data[0], 1, size_out, output) !=
                 static_cast<size_t>(size_out)) {
               std::cerr << "Error: Could not write "
                         << size_out << " bytes for " << in_path.value()
                         << std::endl;
               return 1;
             }
           }
 
           const uint8* u8_samples =
-              reinterpret_cast<const uint8*>(samples.get());
+              reinterpret_cast<const uint8*>(audio_frame->data[0]);
           if (hash_djb2) {
             hash_value = DJB2Hash(u8_samples, size_out, hash_value);
           }
           if (hash_md5) {
             base::MD5Update(
                 &ctx,
-                base::StringPiece(
-                    reinterpret_cast<const char*>(u8_samples), size_out));
+                base::StringPiece(reinterpret_cast<const char*>(u8_samples),
+                                                                size_out));
           }
         }
       } else if (target_codec == AVMEDIA_TYPE_VIDEO) {
         int got_picture = 0;
 
+        avcodec_get_frame_defaults(video_frame.get());
+
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
-        result = avcodec_decode_video2(codec_context, frame.get(),
+        result = avcodec_decode_video2(codec_context, video_frame.get(),
                                        &got_picture, &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
         if (got_picture) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
           read_result = 0;  // Force continuation.
 
           for (int plane = 0; plane < 3; ++plane) {
-            const uint8* source = frame->data[plane];
-            const size_t source_stride = frame->linesize[plane];
+            const uint8* source = video_frame->data[plane];
+            const size_t source_stride = video_frame->linesize[plane];
             size_t bytes_per_line = codec_context->width;
             size_t copy_lines = codec_context->height;
             if (plane != 0) {
               switch (codec_context->pix_fmt) {
                 case PIX_FMT_YUV420P:
                 case PIX_FMT_YUVJ420P:
                   bytes_per_line /= 2;
                   copy_lines = (copy_lines + 1) / 2;
                   break;
                 case PIX_FMT_YUV422P:
@@ skipping 144 matching lines @@
 #if defined(ENABLE_WINDOWS_EXCEPTIONS)
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     *log_out << "  Exception:" << std::setw(11) << GetExceptionCode()
              << " " << in_path.value() << std::endl;
     return 1;
   }
 #endif
   CommandLine::Reset();
   return 0;
 }