ffmpeg chromium glue

media/filters/ffmpeg_demuxer_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.
 
 #include <deque>
 
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_ffmpeg.h"
@@ skipping 64 matching lines @@
     EXPECT_CALL(*data_source_, Stop(NotNull()))
         .WillRepeatedly(Invoke(&RunStopFilterCallback));
 
     // Initialize FFmpeg fixtures.
     memset(&format_context_, 0, sizeof(format_context_));
     memset(&input_format_, 0, sizeof(input_format_));
     memset(&streams_, 0, sizeof(streams_));
     memset(&codecs_, 0, sizeof(codecs_));
 
     // Initialize AVCodecContext structures.
-    codecs_[AV_STREAM_DATA].codec_type = CODEC_TYPE_DATA;
+    codecs_[AV_STREAM_DATA].codec_type = AVMEDIA_TYPE_DATA;
     codecs_[AV_STREAM_DATA].codec_id = CODEC_ID_NONE;
 
-    codecs_[AV_STREAM_VIDEO].codec_type = CODEC_TYPE_VIDEO;
+    codecs_[AV_STREAM_VIDEO].codec_type = AVMEDIA_TYPE_VIDEO;
     codecs_[AV_STREAM_VIDEO].codec_id = CODEC_ID_THEORA;
     codecs_[AV_STREAM_VIDEO].width = kWidth;
     codecs_[AV_STREAM_VIDEO].height = kHeight;
 
-    codecs_[AV_STREAM_AUDIO].codec_type = CODEC_TYPE_AUDIO;
+    codecs_[AV_STREAM_AUDIO].codec_type = AVMEDIA_TYPE_AUDIO;
     codecs_[AV_STREAM_AUDIO].codec_id = CODEC_ID_VORBIS;
     codecs_[AV_STREAM_AUDIO].channels = kChannels;
     codecs_[AV_STREAM_AUDIO].sample_rate = kSampleRate;
 
     input_format_.name = "foo";
     format_context_.iformat = &input_format_;
 
     // Initialize AVStream and AVFormatContext structures.  We set the time base
     // of the streams such that duration is reported in microseconds.
     format_context_.nb_streams = AV_STREAM_MAX;
+    format_context_.streams = new AVStream*[AV_STREAM_MAX];
     for (size_t i = 0; i < AV_STREAM_MAX; ++i) {
       format_context_.streams[i] = &streams_[i];
       streams_[i].codec = &codecs_[i];
       streams_[i].duration = kDurations[i];
       streams_[i].time_base.den = 1 * base::Time::kMicrosecondsPerSecond;
       streams_[i].time_base.num = 1;
     }
   }
 
   virtual ~FFmpegDemuxerTest() {
     // Call Stop() to shut down internal threads.
     demuxer_->Stop(NewExpectedCallback());
 
     // Finish up any remaining tasks.
     message_loop_.RunAllPending();
-
     // Release the reference to the demuxer.
     demuxer_ = NULL;
+
+    if (format_context_.streams) {
+      delete[] format_context_.streams;
+      format_context_.streams = NULL;
+      format_context_.nb_streams = 0;
+    }
   }
 
   // Sets up MockFFmpeg to allow FFmpegDemuxer to successfully initialize.
   void InitializeDemuxerMocks() {
     EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
         .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
     EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
         .WillOnce(Return(0));
     EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
   }
@@ skipping 51 matching lines @@
   demuxer_->Initialize(data_source_.get(),
                        NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_OPEN));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
   // Simulate av_find_stream_info() failing.
   EXPECT_CALL(mock_ffmpeg_, AVOpenInputFile(_, _, NULL, 0, NULL))
       .WillOnce(DoAll(SetArgumentPointee<0>(&format_context_), Return(0)));
   EXPECT_CALL(mock_ffmpeg_, AVFindStreamInfo(&format_context_))
-      .WillOnce(Return(AVERROR_IO));
+      .WillOnce(Return(AVERROR(EIO)));
   EXPECT_CALL(mock_ffmpeg_, AVCloseInputFile(&format_context_));
 
   demuxer_->Initialize(
       data_source_.get(),
       NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_PARSE));
   message_loop_.RunAllPending();
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Simulate media with no parseable streams.
@@ skipping 55 matching lines @@
 
   // Ignore all AVFreePacket() calls.  We check this elsewhere.
   EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
 
   // The demuxer will read a data packet which will get immediately freed,
   // followed by a read error to end the reading.
   InSequence s;
   EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_DATA, kNullData, 0));
   EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
-      .WillOnce(Return(AVERROR_IO));
+      .WillOnce(Return(AVERROR(EIO)));
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
@@ skipping 187 matching lines @@
   // indeed inserted.
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
 
   // Ignore all AVFreePacket() calls.  We check this via valgrind.
   EXPECT_CALL(mock_ffmpeg_, AVFreePacket(_)).Times(AnyNumber());
 
   EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
-      .WillOnce(Return(AVERROR_IO));
+      .WillOnce(Return(AVERROR(EIO)));
 
   // We should now expect an end of stream buffer.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(audio);
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ASSERT_TRUE(reader->buffer());
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
@@ skipping 222 matching lines @@
 
   // Expect all calls in sequence.
   InSequence s;
 
   // The demuxer will read an audio packet which will get immediately freed.
   EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
       .WillOnce(CreatePacketNoCount(AV_STREAM_AUDIO, kNullData, 0));
 
   // Then an end-of-stream packet is read.
   EXPECT_CALL(mock_ffmpeg_, AVReadFrame(&format_context_, _))
-      .WillOnce(Return(AVERROR_IO));
+      .WillOnce(Return(AVERROR(EIO)));
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(video);
 
   // Attempt a read from the video stream and run the message loop until done.
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(video);
   message_loop_.RunAllPending();
@@ skipping 118 matching lines @@
   {
     SCOPED_TRACE("");
     InitializeDemuxer();
   }
   EXPECT_CALL(*data_source_, IsStreaming())
       .WillOnce(Return(false));
   EXPECT_FALSE(demuxer_->IsStreaming());
 }
 
 }  // namespace media