Fix media code to work with new ffmpeg.

media/ffmpeg/ffmpeg_unittest.cc

 // Copyright (c) 2011 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.
 //
 // Known failures as of r54591:
@@ skipping 28 matching lines @@
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/file_protocol.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 int main(int argc, char** argv) {
   return base::PerfTestSuite(argc, argv).Run();
 }
 
 namespace media {
 
+// Mirror setting in ffmpeg_video_decoder.
+static const int kDecodeThreads = 2;
+
 class AVPacketQueue {
  public:
   AVPacketQueue() {
   }
 
   ~AVPacketQueue() {
     flush();
   }
 
   bool empty() {
@@ skipping 21 matching lines @@
       pop();
     }
   }
 
  private:
   std::queue<AVPacket*> packets_;
 
   DISALLOW_COPY_AND_ASSIGN(AVPacketQueue);
 };
 
+// TODO(dalecurtis): We should really just use PipelineIntegrationTests instead
+// of a one-off step decoder so we're exercising the real pipeline.
 class FFmpegTest : public testing::TestWithParam<const char*> {
  protected:
   FFmpegTest()
       : av_format_context_(NULL),
         audio_stream_index_(-1),
         video_stream_index_(-1),
         audio_buffer_(NULL),
         video_buffer_(NULL),
         decoded_audio_time_(AV_NOPTS_VALUE),
         decoded_audio_duration_(AV_NOPTS_VALUE),
@@ skipping 26 matching lines @@
         .AppendASCII(name.c_str());
     FilePath::StringType raw_path = path.value();
     EXPECT_TRUE(file_util::PathExists(path));
 
 #if defined(OS_WIN)
     std::string ascii_path = WideToASCII(path.value());
 #else
     std::string ascii_path = path.value();
 #endif
 
-    EXPECT_EQ(0, av_open_input_file(&av_format_context_,
-                                    ascii_path.c_str(),
-                                    NULL, 0, NULL))
+    EXPECT_EQ(0, avformat_open_input(&av_format_context_,
+                                     ascii_path.c_str(),
+                                     NULL, NULL))
         << "Could not open " << path.value();
-    EXPECT_LE(0, av_find_stream_info(av_format_context_))
+    EXPECT_LE(0, avformat_find_stream_info(av_format_context_, NULL))
         << "Could not find stream information for " << path.value();
 
     // Determine duration by picking max stream duration.
     for (unsigned int i = 0; i < av_format_context_->nb_streams; ++i) {
       AVStream* av_stream = av_format_context_->streams[i];
-      int64 duration = ConvertFromTimeBase(av_stream->time_base,
-                                        av_stream->duration).InMicroseconds();
+      int64 duration = ConvertFromTimeBase(
+          av_stream->time_base, av_stream->duration).InMicroseconds();
       duration_ = std::max(duration_, duration);
     }
 
     // Final check to see if the container itself specifies a duration.
     AVRational av_time_base = {1, AV_TIME_BASE};
     int64 duration =
         ConvertFromTimeBase(av_time_base,
-                         av_format_context_->duration).InMicroseconds();
+                            av_format_context_->duration).InMicroseconds();
     duration_ = std::max(duration_, duration);
   }
 
   void CloseFile() {
-    av_close_input_file(av_format_context_);
+    avformat_close_input(&av_format_context_);
   }
 
   void OpenCodecs() {
     for (unsigned int i = 0; i < av_format_context_->nb_streams; ++i) {
       AVStream* av_stream = av_format_context_->streams[i];
       AVCodecContext* av_codec_context = av_stream->codec;
       AVCodec* av_codec = avcodec_find_decoder(av_codec_context->codec_id);
 
       EXPECT_TRUE(av_codec)
           << "Could not find AVCodec with CodecID "
           << av_codec_context->codec_id;
-      EXPECT_EQ(0, avcodec_open(av_codec_context, av_codec))
+
+      av_codec_context->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
+      av_codec_context->err_recognition = AV_EF_CAREFUL;
+      av_codec_context->thread_count = (
+          av_codec_context->codec_id == CODEC_ID_THEORA ? 1 : kDecodeThreads);
+
+      EXPECT_EQ(0, avcodec_open2(av_codec_context, av_codec, NULL))
           << "Could not open AVCodecContext with CodecID "
           << av_codec_context->codec_id;
 
       if (av_codec->type == AVMEDIA_TYPE_AUDIO) {
         EXPECT_EQ(-1, audio_stream_index_) << "Found multiple audio streams.";
         audio_stream_index_ = static_cast<int>(i);
       } else if (av_codec->type == AVMEDIA_TYPE_VIDEO) {
         EXPECT_EQ(-1, video_stream_index_) << "Found multiple video streams.";
         video_stream_index_ = static_cast<int>(i);
       } else {
@@ skipping 81 matching lines @@
       }
 
       EXPECT_GE(result, 0) << "Audio decode error.";
       if (result < 0 || (size_out == 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_bits_per_sample_fmt(av_audio_context()->sample_fmt) / 8 *
+            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));
         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.";
@@ skipping 110 matching lines @@
     static bool initialized = false;
     if (initialized) {
       return;
     }
 
     FilePath path;
     PathService::Get(base::DIR_MODULE, &path);
     EXPECT_TRUE(InitializeMediaLibrary(path))
         << "Could not initialize media library.";
 
-    avcodec_init();
     av_log_set_level(AV_LOG_FATAL);
     av_register_all();
-    av_register_protocol2(&kFFmpegFileProtocol, sizeof(kFFmpegFileProtocol));
+    ffurl_register_protocol(&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_;
@@ skipping 227 matching lines @@
   SeekTo(0.4);
   ReadRemainingFile();
   EXPECT_TRUE(StepDecodeVideo());
   VLOG(1) << decoded_video_time();
 
   CloseCodecs();
   CloseFile();
 }
 
 }  // namespace media