media/filters/ffmpeg_demuxer_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <deque>
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/logging.h"
  12 #include "base/path_service.h"
  13 #include "base/threading/thread.h"
  14 #include "media/base/decrypt_config.h"
  15 #include "media/base/media_log.h"
  16 #include "media/base/mock_demuxer_host.h"
  17 #include "media/base/test_helpers.h"
  18 #include "media/base/timestamp_constants.h"
  19 #include "media/ffmpeg/ffmpeg_common.h"
  20 #include "media/filters/ffmpeg_demuxer.h"
  21 #include "media/filters/file_data_source.h"
  22 #include "media/formats/mp4/avc.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using ::testing::AnyNumber;
  26 using ::testing::DoAll;
  27 using ::testing::Exactly;
  28 using ::testing::InSequence;
  29 using ::testing::Invoke;
  30 using ::testing::NotNull;
  31 using ::testing::Return;
  32 using ::testing::SaveArg;
  33 using ::testing::SetArgPointee;
  34 using ::testing::StrictMock;
  35 using ::testing::WithArgs;
  36 using ::testing::_;
  37
  38 namespace media {
  39
  40 MATCHER(IsEndOfStreamBuffer,
  41         std::string(negation ? "isn't" : "is") + " end of stream") {
  42   return arg->end_of_stream();
  43 }
  44
  45 const uint8 kEncryptedMediaInitData[] = {
  46   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  47   0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
  48 };
  49
  50 static void EosOnReadDone(bool* got_eos_buffer,
  51                           DemuxerStream::Status status,
  52                           const scoped_refptr<DecoderBuffer>& buffer) {
  53   base::MessageLoop::current()->PostTask(
  54       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
  55
  56   EXPECT_EQ(status, DemuxerStream::kOk);
  57   if (buffer->end_of_stream()) {
  58     *got_eos_buffer = true;
  59     return;
  60   }
  61
  62   EXPECT_TRUE(buffer->data());
  63   EXPECT_GT(buffer->data_size(), 0);
  64   *got_eos_buffer = false;
  65 };
  66
  67
  68 // Fixture class to facilitate writing tests.  Takes care of setting up the
  69 // FFmpeg, pipeline and filter host mocks.
  70 class FFmpegDemuxerTest : public testing::Test {
  71  protected:
  72   FFmpegDemuxerTest() {}
  73
  74   virtual ~FFmpegDemuxerTest() {
  75     if (demuxer_)
  76       demuxer_->Stop();
  77   }
  78
  79   void CreateDemuxer(const std::string& name) {
  80     CHECK(!demuxer_);
  81
  82     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
  83
  84     CreateDataSource(name);
  85
  86     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
  87         &FFmpegDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
  88
  89     demuxer_.reset(new FFmpegDemuxer(
  90         message_loop_.task_runner(), data_source_.get(),
  91         encrypted_media_init_data_cb, new MediaLog()));
  92   }
  93
  94   MOCK_METHOD1(CheckPoint, void(int v));
  95
  96   void InitializeDemuxerWithTimelineOffset(bool enable_text,
  97                                            base::Time timeline_offset) {
  98     EXPECT_CALL(host_, SetDuration(_));
  99     WaitableMessageLoopEvent event;
 100     demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
 101     demuxer_->timeline_offset_ = timeline_offset;
 102     event.RunAndWaitForStatus(PIPELINE_OK);
 103   }
 104
 105   void InitializeDemuxerText(bool enable_text) {
 106     InitializeDemuxerWithTimelineOffset(enable_text, base::Time());
 107   }
 108
 109   void InitializeDemuxer() {
 110     InitializeDemuxerText(false);
 111   }
 112
 113   MOCK_METHOD2(OnReadDoneCalled, void(int, int64));
 114
 115   struct ReadExpectation {
 116     ReadExpectation(int size,
 117                     int64 timestamp_us,
 118                     const base::TimeDelta& discard_front_padding,
 119                     bool is_key_frame)
 120         : size(size),
 121           timestamp_us(timestamp_us),
 122           discard_front_padding(discard_front_padding),
 123           is_key_frame(is_key_frame) {
 124     }
 125
 126     int size;
 127     int64 timestamp_us;
 128     base::TimeDelta discard_front_padding;
 129     bool is_key_frame;
 130   };
 131
 132   // Verifies that |buffer| has a specific |size| and |timestamp|.
 133   // |location| simply indicates where the call to this function was made.
 134   // This makes it easier to track down where test failures occur.
 135   void OnReadDone(const tracked_objects::Location& location,
 136                   const ReadExpectation& read_expectation,
 137                   DemuxerStream::Status status,
 138                   const scoped_refptr<DecoderBuffer>& buffer) {
 139     std::string location_str;
 140     location.Write(true, false, &location_str);
 141     location_str += "\n";
 142     SCOPED_TRACE(location_str);
 143     EXPECT_EQ(status, DemuxerStream::kOk);
 144     EXPECT_TRUE(buffer.get() != NULL);
 145     EXPECT_EQ(read_expectation.size, buffer->data_size());
 146     EXPECT_EQ(read_expectation.timestamp_us,
 147               buffer->timestamp().InMicroseconds());
 148     EXPECT_EQ(read_expectation.discard_front_padding,
 149               buffer->discard_padding().first);
 150     EXPECT_EQ(read_expectation.is_key_frame, buffer->is_key_frame());
 151     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
 152     OnReadDoneCalled(read_expectation.size, read_expectation.timestamp_us);
 153     message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 154   }
 155
 156   DemuxerStream::ReadCB NewReadCB(const tracked_objects::Location& location,
 157                                   int size,
 158                                   int64 timestamp_us,
 159                                   bool is_key_frame) {
 160     return NewReadCBWithCheckedDiscard(location,
 161                                        size,
 162                                        timestamp_us,
 163                                        base::TimeDelta(),
 164                                        is_key_frame);
 165   }
 166
 167   DemuxerStream::ReadCB NewReadCBWithCheckedDiscard(
 168       const tracked_objects::Location& location,
 169       int size,
 170       int64 timestamp_us,
 171       base::TimeDelta discard_front_padding,
 172       bool is_key_frame) {
 173     EXPECT_CALL(*this, OnReadDoneCalled(size, timestamp_us));
 174
 175     struct ReadExpectation read_expectation(size,
 176                                             timestamp_us,
 177                                             discard_front_padding,
 178                                             is_key_frame);
 179
 180     return base::Bind(&FFmpegDemuxerTest::OnReadDone,
 181                       base::Unretained(this),
 182                       location,
 183                       read_expectation);
 184   }
 185
 186   MOCK_METHOD2(OnEncryptedMediaInitData,
 187                void(EmeInitDataType init_data_type,
 188                     const std::vector<uint8>& init_data));
 189
 190   // Accessor to demuxer internals.
 191   void set_duration_known(bool duration_known) {
 192     demuxer_->duration_known_ = duration_known;
 193   }
 194
 195   bool IsStreamStopped(DemuxerStream::Type type) {
 196     DemuxerStream* stream = demuxer_->GetStream(type);
 197     CHECK(stream);
 198     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
 199   }
 200
 201   // Fixture members.
 202   scoped_ptr<FileDataSource> data_source_;
 203   scoped_ptr<FFmpegDemuxer> demuxer_;
 204   StrictMock<MockDemuxerHost> host_;
 205   base::MessageLoop message_loop_;
 206
 207   AVFormatContext* format_context() {
 208     return demuxer_->glue_->format_context();
 209   }
 210
 211   int preferred_seeking_stream_index() const {
 212     return demuxer_->preferred_stream_for_seeking_.first;
 213   }
 214
 215   void ReadUntilEndOfStream(DemuxerStream* stream) {
 216     bool got_eos_buffer = false;
 217     const int kMaxBuffers = 170;
 218     for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
 219       stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
 220       message_loop_.Run();
 221     }
 222
 223     EXPECT_TRUE(got_eos_buffer);
 224   }
 225
 226  private:
 227   void CreateDataSource(const std::string& name) {
 228     CHECK(!data_source_);
 229
 230     base::FilePath file_path;
 231     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
 232
 233     file_path = file_path.Append(FILE_PATH_LITERAL("media"))
 234         .Append(FILE_PATH_LITERAL("test"))
 235         .Append(FILE_PATH_LITERAL("data"))
 236         .AppendASCII(name);
 237
 238     data_source_.reset(new FileDataSource());
 239     EXPECT_TRUE(data_source_->Initialize(file_path));
 240   }
 241
 242   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 243 };
 244
 245 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
 246   // Simulate avformat_open_input() failing.
 247   CreateDemuxer("ten_byte_file");
 248   WaitableMessageLoopEvent event;
 249   demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
 250   event.RunAndWaitForStatus(DEMUXER_ERROR_COULD_NOT_OPEN);
 251 }
 252
 253 // TODO(acolwell): Uncomment this test when we discover a file that passes
 254 // avformat_open_input(), but has avformat_find_stream_info() fail.
 255 //
 256 //TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
 257 //  ("find_stream_info_fail.webm");
 258 //  demuxer_->Initialize(
 259 //      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
 260 //  message_loop_.RunUntilIdle();
 261 //}
 262
 263 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
 264   // Open a file with no streams whatsoever.
 265   CreateDemuxer("no_streams.webm");
 266   WaitableMessageLoopEvent event;
 267   demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
 268   event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 269 }
 270
 271 TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
 272   // Open a file containing streams but none of which are audio/video streams.
 273   CreateDemuxer("no_audio_video.webm");
 274   WaitableMessageLoopEvent event;
 275   demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
 276   event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 277 }
 278
 279 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
 280   CreateDemuxer("bear-320x240.webm");
 281   InitializeDemuxer();
 282
 283   // Video stream should be present.
 284   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 285   ASSERT_TRUE(stream);
 286   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 287
 288   const VideoDecoderConfig& video_config = stream->video_decoder_config();
 289   EXPECT_EQ(kCodecVP8, video_config.codec());
 290   EXPECT_EQ(PIXEL_FORMAT_YV12, video_config.format());
 291   EXPECT_EQ(320, video_config.coded_size().width());
 292   EXPECT_EQ(240, video_config.coded_size().height());
 293   EXPECT_EQ(0, video_config.visible_rect().x());
 294   EXPECT_EQ(0, video_config.visible_rect().y());
 295   EXPECT_EQ(320, video_config.visible_rect().width());
 296   EXPECT_EQ(240, video_config.visible_rect().height());
 297   EXPECT_EQ(320, video_config.natural_size().width());
 298   EXPECT_EQ(240, video_config.natural_size().height());
 299   EXPECT_FALSE(video_config.extra_data());
 300   EXPECT_EQ(0u, video_config.extra_data_size());
 301
 302   // Audio stream should be present.
 303   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 304   ASSERT_TRUE(stream);
 305   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 306
 307   const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
 308   EXPECT_EQ(kCodecVorbis, audio_config.codec());
 309   EXPECT_EQ(32, audio_config.bits_per_channel());
 310   EXPECT_EQ(CHANNEL_LAYOUT_STEREO, audio_config.channel_layout());
 311   EXPECT_EQ(44100, audio_config.samples_per_second());
 312   EXPECT_EQ(kSampleFormatPlanarF32, audio_config.sample_format());
 313   EXPECT_TRUE(audio_config.extra_data());
 314   EXPECT_GT(audio_config.extra_data_size(), 0u);
 315
 316   // Unknown stream should never be present.
 317   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 318 }
 319
 320 TEST_F(FFmpegDemuxerTest, Initialize_Multitrack) {
 321   // Open a file containing the following streams:
 322   //   Stream #0: Video (VP8)
 323   //   Stream #1: Audio (Vorbis)
 324   //   Stream #2: Subtitles (SRT)
 325   //   Stream #3: Video (Theora)
 326   //   Stream #4: Audio (16-bit signed little endian PCM)
 327   //
 328   // We should only pick the first audio/video streams we come across.
 329   CreateDemuxer("bear-320x240-multitrack.webm");
 330   InitializeDemuxer();
 331
 332   // Video stream should be VP8.
 333   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 334   ASSERT_TRUE(stream);
 335   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 336   EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
 337
 338   // Audio stream should be Vorbis.
 339   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 340   ASSERT_TRUE(stream);
 341   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 342   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 343
 344   // Unknown stream should never be present.
 345   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 346 }
 347
 348 TEST_F(FFmpegDemuxerTest, Initialize_MultitrackText) {
 349   // Open a file containing the following streams:
 350   //   Stream #0: Video (VP8)
 351   //   Stream #1: Audio (Vorbis)
 352   //   Stream #2: Text (WebVTT)
 353
 354   CreateDemuxer("bear-vp8-webvtt.webm");
 355   DemuxerStream* text_stream = NULL;
 356   EXPECT_CALL(host_, AddTextStream(_, _))
 357       .WillOnce(SaveArg<0>(&text_stream));
 358   InitializeDemuxerText(true);
 359   ASSERT_TRUE(text_stream);
 360   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 361
 362   // Video stream should be VP8.
 363   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 364   ASSERT_TRUE(stream);
 365   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 366   EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
 367
 368   // Audio stream should be Vorbis.
 369   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 370   ASSERT_TRUE(stream);
 371   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 372   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 373
 374   // Unknown stream should never be present.
 375   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 376 }
 377
 378 TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
 379   EXPECT_CALL(*this,
 380               OnEncryptedMediaInitData(
 381                   EmeInitDataType::WEBM,
 382                   std::vector<uint8>(kEncryptedMediaInitData,
 383                                      kEncryptedMediaInitData +
 384                                          arraysize(kEncryptedMediaInitData))))
 385       .Times(Exactly(2));
 386
 387   CreateDemuxer("bear-320x240-av_enc-av.webm");
 388   InitializeDemuxer();
 389 }
 390
 391 TEST_F(FFmpegDemuxerTest, Read_Audio) {
 392   // We test that on a successful audio packet read.
 393   CreateDemuxer("bear-320x240.webm");
 394   InitializeDemuxer();
 395
 396   // Attempt a read from the audio stream and run the message loop until done.
 397   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 398
 399   audio->Read(NewReadCB(FROM_HERE, 29, 0, true));
 400   message_loop_.Run();
 401
 402   audio->Read(NewReadCB(FROM_HERE, 27, 3000, true));
 403   message_loop_.Run();
 404 }
 405
 406 TEST_F(FFmpegDemuxerTest, Read_Video) {
 407   // We test that on a successful video packet read.
 408   CreateDemuxer("bear-320x240.webm");
 409   InitializeDemuxer();
 410
 411   // Attempt a read from the video stream and run the message loop until done.
 412   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 413
 414   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
 415   message_loop_.Run();
 416
 417   video->Read(NewReadCB(FROM_HERE, 1057, 33000, false));
 418   message_loop_.Run();
 419 }
 420
 421 TEST_F(FFmpegDemuxerTest, Read_Text) {
 422   // We test that on a successful text packet read.
 423   CreateDemuxer("bear-vp8-webvtt.webm");
 424   DemuxerStream* text_stream = NULL;
 425   EXPECT_CALL(host_, AddTextStream(_, _))
 426       .WillOnce(SaveArg<0>(&text_stream));
 427   InitializeDemuxerText(true);
 428   ASSERT_TRUE(text_stream);
 429   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 430
 431   text_stream->Read(NewReadCB(FROM_HERE, 31, 0, true));
 432   message_loop_.Run();
 433
 434   text_stream->Read(NewReadCB(FROM_HERE, 19, 500000, true));
 435   message_loop_.Run();
 436 }
 437
 438 TEST_F(FFmpegDemuxerTest, SeekInitialized_NoVideoStartTime) {
 439   CreateDemuxer("audio-start-time-only.webm");
 440   InitializeDemuxer();
 441   EXPECT_EQ(0, preferred_seeking_stream_index());
 442 }
 443
 444 TEST_F(FFmpegDemuxerTest, Read_VideoPositiveStartTime) {
 445   const int64 kTimelineOffsetMs = 1352550896000LL;
 446
 447   // Test the start time is the first timestamp of the video and audio stream.
 448   CreateDemuxer("nonzero-start-time.webm");
 449   InitializeDemuxerWithTimelineOffset(
 450       false, base::Time::FromJsTime(kTimelineOffsetMs));
 451
 452   // Attempt a read from the video stream and run the message loop until done.
 453   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 454   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 455
 456   const base::TimeDelta video_start_time =
 457       base::TimeDelta::FromMicroseconds(400000);
 458   const base::TimeDelta audio_start_time =
 459       base::TimeDelta::FromMicroseconds(396000);
 460
 461   // Run the test twice with a seek in between.
 462   for (int i = 0; i < 2; ++i) {
 463     video->Read(NewReadCB(FROM_HERE, 5636, video_start_time.InMicroseconds(),
 464                           true));
 465     message_loop_.Run();
 466     audio->Read(NewReadCB(FROM_HERE, 165, audio_start_time.InMicroseconds(),
 467                           true));
 468     message_loop_.Run();
 469
 470     // Verify that the start time is equal to the lowest timestamp (ie the
 471     // audio).
 472     EXPECT_EQ(audio_start_time, demuxer_->start_time());
 473
 474     // Verify that the timeline offset has not been adjusted by the start time.
 475     EXPECT_EQ(kTimelineOffsetMs, demuxer_->GetTimelineOffset().ToJavaTime());
 476
 477     // Seek back to the beginning and repeat the test.
 478     WaitableMessageLoopEvent event;
 479     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 480     event.RunAndWaitForStatus(PIPELINE_OK);
 481   }
 482 }
 483
 484 TEST_F(FFmpegDemuxerTest, Read_AudioNoStartTime) {
 485   // FFmpeg does not set timestamps when demuxing wave files.  Ensure that the
 486   // demuxer sets a start time of zero in this case.
 487   CreateDemuxer("sfx_s24le.wav");
 488   InitializeDemuxer();
 489
 490   // Run the test twice with a seek in between.
 491   for (int i = 0; i < 2; ++i) {
 492     demuxer_->GetStream(DemuxerStream::AUDIO)
 493         ->Read(NewReadCB(FROM_HERE, 4095, 0, true));
 494     message_loop_.Run();
 495     EXPECT_EQ(base::TimeDelta(), demuxer_->start_time());
 496
 497     // Seek back to the beginning and repeat the test.
 498     WaitableMessageLoopEvent event;
 499     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 500     event.RunAndWaitForStatus(PIPELINE_OK);
 501   }
 502 }
 503
 504 // TODO(dalecurtis): Test is disabled since FFmpeg does not currently guarantee
 505 // the order of demuxed packets in OGG containers.  Re-enable and fix key frame
 506 // expectations once we decide to either workaround it or attempt a fix
 507 // upstream.  See http://crbug.com/387996.
 508 TEST_F(FFmpegDemuxerTest,
 509        DISABLED_Read_AudioNegativeStartTimeAndOggDiscard_Bear) {
 510   // Many ogg files have negative starting timestamps, so ensure demuxing and
 511   // seeking work correctly with a negative start time.
 512   CreateDemuxer("bear.ogv");
 513   InitializeDemuxer();
 514
 515   // Attempt a read from the video stream and run the message loop until done.
 516   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 517   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 518
 519   // Run the test twice with a seek in between.
 520   for (int i = 0; i < 2; ++i) {
 521     audio->Read(
 522         NewReadCBWithCheckedDiscard(FROM_HERE, 40, 0, kInfiniteDuration(),
 523                                     true));
 524     message_loop_.Run();
 525     audio->Read(
 526         NewReadCBWithCheckedDiscard(FROM_HERE, 41, 2903, kInfiniteDuration(),
 527                                     true));
 528     message_loop_.Run();
 529     audio->Read(NewReadCBWithCheckedDiscard(
 530         FROM_HERE, 173, 5805, base::TimeDelta::FromMicroseconds(10159), true));
 531     message_loop_.Run();
 532
 533     audio->Read(NewReadCB(FROM_HERE, 148, 18866, true));
 534     message_loop_.Run();
 535     EXPECT_EQ(base::TimeDelta::FromMicroseconds(-15964),
 536               demuxer_->start_time());
 537
 538     video->Read(NewReadCB(FROM_HERE, 5751, 0, true));
 539     message_loop_.Run();
 540
 541     video->Read(NewReadCB(FROM_HERE, 846, 33367, true));
 542     message_loop_.Run();
 543
 544     video->Read(NewReadCB(FROM_HERE, 1255, 66733, true));
 545     message_loop_.Run();
 546
 547     // Seek back to the beginning and repeat the test.
 548     WaitableMessageLoopEvent event;
 549     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 550     event.RunAndWaitForStatus(PIPELINE_OK);
 551   }
 552 }
 553
 554 // Same test above, but using sync2.ogv which has video stream muxed before the
 555 // audio stream, so seeking based only on start time will fail since ffmpeg is
 556 // essentially just seeking based on file position.
 557 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOggDiscard_Sync) {
 558   // Many ogg files have negative starting timestamps, so ensure demuxing and
 559   // seeking work correctly with a negative start time.
 560   CreateDemuxer("sync2.ogv");
 561   InitializeDemuxer();
 562
 563   // Attempt a read from the video stream and run the message loop until done.
 564   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 565   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 566
 567   // Run the test twice with a seek in between.
 568   for (int i = 0; i < 2; ++i) {
 569     audio->Read(NewReadCBWithCheckedDiscard(
 570         FROM_HERE, 1, 0, base::TimeDelta::FromMicroseconds(2902), true));
 571     message_loop_.Run();
 572
 573     audio->Read(NewReadCB(FROM_HERE, 1, 2902, true));
 574     message_loop_.Run();
 575     EXPECT_EQ(base::TimeDelta::FromMicroseconds(-2902),
 576               demuxer_->start_time());
 577
 578     // Though the internal start time may be below zero, the exposed media time
 579     // must always be greater than zero.
 580     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 581
 582     video->Read(NewReadCB(FROM_HERE, 9997, 0, true));
 583     message_loop_.Run();
 584
 585     video->Read(NewReadCB(FROM_HERE, 16, 33241, false));
 586     message_loop_.Run();
 587
 588     video->Read(NewReadCB(FROM_HERE, 631, 66482, false));
 589     message_loop_.Run();
 590
 591     // Seek back to the beginning and repeat the test.
 592     WaitableMessageLoopEvent event;
 593     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 594     event.RunAndWaitForStatus(PIPELINE_OK);
 595   }
 596 }
 597
 598 // Similar to the test above, but using an opus clip with a large amount of
 599 // pre-skip, which ffmpeg encodes as negative timestamps.
 600 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusDiscard_Sync) {
 601   CreateDemuxer("opus-trimming-video-test.webm");
 602   InitializeDemuxer();
 603
 604   // Attempt a read from the video stream and run the message loop until done.
 605   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 606   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 607   EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 65535);
 608
 609   // Packet size to timestamp (in microseconds) mapping for the first N packets
 610   // which should be fully discarded.
 611   static const int kTestExpectations[][2] = {
 612       {635, 0},      {594, 120000},  {597, 240000}, {591, 360000},
 613       {582, 480000}, {583, 600000},  {592, 720000}, {567, 840000},
 614       {579, 960000}, {572, 1080000}, {583, 1200000}};
 615
 616   // Run the test twice with a seek in between.
 617   for (int i = 0; i < 2; ++i) {
 618     for (size_t j = 0; j < arraysize(kTestExpectations); ++j) {
 619       audio->Read(NewReadCB(FROM_HERE, kTestExpectations[j][0],
 620                             kTestExpectations[j][1], true));
 621       message_loop_.Run();
 622     }
 623
 624     // Though the internal start time may be below zero, the exposed media time
 625     // must always be greater than zero.
 626     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 627
 628     video->Read(NewReadCB(FROM_HERE, 16009, 0, true));
 629     message_loop_.Run();
 630
 631     video->Read(NewReadCB(FROM_HERE, 2715, 1000, false));
 632     message_loop_.Run();
 633
 634     video->Read(NewReadCB(FROM_HERE, 427, 33000, false));
 635     message_loop_.Run();
 636
 637     // Seek back to the beginning and repeat the test.
 638     WaitableMessageLoopEvent event;
 639     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 640     event.RunAndWaitForStatus(PIPELINE_OK);
 641   }
 642 }
 643
 644 // Similar to the test above, but using sfx-opus.ogg, which has a much smaller
 645 // amount of discard padding and no |start_time| set on the AVStream.
 646 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusSfxDiscard_Sync) {
 647   CreateDemuxer("sfx-opus.ogg");
 648   InitializeDemuxer();
 649
 650   // Attempt a read from the video stream and run the message loop until done.
 651   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 652   EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 312);
 653
 654    // Run the test twice with a seek in between.
 655   for (int i = 0; i < 2; ++i) {
 656     audio->Read(NewReadCB(FROM_HERE, 314, 0, true));
 657     message_loop_.Run();
 658
 659     audio->Read(NewReadCB(FROM_HERE, 244, 20000, true));
 660     message_loop_.Run();
 661
 662     // Though the internal start time may be below zero, the exposed media time
 663     // must always be greater than zero.
 664     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 665
 666     // Seek back to the beginning and repeat the test.
 667     WaitableMessageLoopEvent event;
 668     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
 669     event.RunAndWaitForStatus(PIPELINE_OK);
 670   }
 671 }
 672
 673 TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
 674   // Verify that end of stream buffers are created.
 675   CreateDemuxer("bear-320x240.webm");
 676   InitializeDemuxer();
 677   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 678 }
 679
 680 TEST_F(FFmpegDemuxerTest, Read_EndOfStreamText) {
 681   // Verify that end of stream buffers are created.
 682   CreateDemuxer("bear-vp8-webvtt.webm");
 683   DemuxerStream* text_stream = NULL;
 684   EXPECT_CALL(host_, AddTextStream(_, _))
 685       .WillOnce(SaveArg<0>(&text_stream));
 686   InitializeDemuxerText(true);
 687   ASSERT_TRUE(text_stream);
 688   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 689
 690   bool got_eos_buffer = false;
 691   const int kMaxBuffers = 10;
 692   for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
 693     text_stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
 694     message_loop_.Run();
 695   }
 696
 697   EXPECT_TRUE(got_eos_buffer);
 698 }
 699
 700 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
 701   // Verify that end of stream buffers are created.
 702   CreateDemuxer("bear-320x240.webm");
 703   InitializeDemuxer();
 704   set_duration_known(false);
 705   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
 706   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 707   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
 708 }
 709
 710 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_VideoOnly) {
 711   // Verify that end of stream buffers are created.
 712   CreateDemuxer("bear-320x240-video-only.webm");
 713   InitializeDemuxer();
 714   set_duration_known(false);
 715   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2736)));
 716   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
 717 }
 718
 719 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_AudioOnly) {
 720   // Verify that end of stream buffers are created.
 721   CreateDemuxer("bear-320x240-audio-only.webm");
 722   InitializeDemuxer();
 723   set_duration_known(false);
 724   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
 725   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 726 }
 727
 728 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_UnsupportedStream) {
 729   // Verify that end of stream buffers are created and we don't crash
 730   // if there are streams in the file that we don't support.
 731   CreateDemuxer("vorbis_audio_wmv_video.mkv");
 732   InitializeDemuxer();
 733   set_duration_known(false);
 734   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(1014)));
 735   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 736 }
 737
 738 TEST_F(FFmpegDemuxerTest, Seek) {
 739   // We're testing that the demuxer frees all queued packets when it receives
 740   // a Seek().
 741   CreateDemuxer("bear-320x240.webm");
 742   InitializeDemuxer();
 743
 744   // Get our streams.
 745   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 746   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 747   ASSERT_TRUE(video);
 748   ASSERT_TRUE(audio);
 749
 750   // Read a video packet and release it.
 751   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
 752   message_loop_.Run();
 753
 754   // Issue a simple forward seek, which should discard queued packets.
 755   WaitableMessageLoopEvent event;
 756   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
 757                  event.GetPipelineStatusCB());
 758   event.RunAndWaitForStatus(PIPELINE_OK);
 759
 760   // Audio read #1.
 761   audio->Read(NewReadCB(FROM_HERE, 145, 803000, true));
 762   message_loop_.Run();
 763
 764   // Audio read #2.
 765   audio->Read(NewReadCB(FROM_HERE, 148, 826000, true));
 766   message_loop_.Run();
 767
 768   // Video read #1.
 769   video->Read(NewReadCB(FROM_HERE, 5425, 801000, true));
 770   message_loop_.Run();
 771
 772   // Video read #2.
 773   video->Read(NewReadCB(FROM_HERE, 1906, 834000, false));
 774   message_loop_.Run();
 775 }
 776
 777 TEST_F(FFmpegDemuxerTest, SeekText) {
 778   // We're testing that the demuxer frees all queued packets when it receives
 779   // a Seek().
 780   CreateDemuxer("bear-vp8-webvtt.webm");
 781   DemuxerStream* text_stream = NULL;
 782   EXPECT_CALL(host_, AddTextStream(_, _))
 783       .WillOnce(SaveArg<0>(&text_stream));
 784   InitializeDemuxerText(true);
 785   ASSERT_TRUE(text_stream);
 786   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 787
 788   // Get our streams.
 789   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 790   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 791   ASSERT_TRUE(video);
 792   ASSERT_TRUE(audio);
 793
 794   // Read a text packet and release it.
 795   text_stream->Read(NewReadCB(FROM_HERE, 31, 0, true));
 796   message_loop_.Run();
 797
 798   // Issue a simple forward seek, which should discard queued packets.
 799   WaitableMessageLoopEvent event;
 800   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
 801                  event.GetPipelineStatusCB());
 802   event.RunAndWaitForStatus(PIPELINE_OK);
 803
 804   // Audio read #1.
 805   audio->Read(NewReadCB(FROM_HERE, 145, 803000, true));
 806   message_loop_.Run();
 807
 808   // Audio read #2.
 809   audio->Read(NewReadCB(FROM_HERE, 148, 826000, true));
 810   message_loop_.Run();
 811
 812   // Video read #1.
 813   video->Read(NewReadCB(FROM_HERE, 5425, 801000, true));
 814   message_loop_.Run();
 815
 816   // Video read #2.
 817   video->Read(NewReadCB(FROM_HERE, 1906, 834000, false));
 818   message_loop_.Run();
 819
 820   // Text read #1.
 821   text_stream->Read(NewReadCB(FROM_HERE, 19, 500000, true));
 822   message_loop_.Run();
 823
 824   // Text read #2.
 825   text_stream->Read(NewReadCB(FROM_HERE, 19, 1000000, true));
 826   message_loop_.Run();
 827 }
 828
 829 class MockReadCB {
 830  public:
 831   MockReadCB() {}
 832   ~MockReadCB() {}
 833
 834   MOCK_METHOD2(Run, void(DemuxerStream::Status status,
 835                          const scoped_refptr<DecoderBuffer>& buffer));
 836  private:
 837   DISALLOW_COPY_AND_ASSIGN(MockReadCB);
 838 };
 839
 840 TEST_F(FFmpegDemuxerTest, Stop) {
 841   // Tests that calling Read() on a stopped demuxer stream immediately deletes
 842   // the callback.
 843   CreateDemuxer("bear-320x240.webm");
 844   InitializeDemuxer();
 845
 846   // Get our stream.
 847   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 848   ASSERT_TRUE(audio);
 849
 850   demuxer_->Stop();
 851
 852   // Reads after being stopped are all EOS buffers.
 853   StrictMock<MockReadCB> callback;
 854   EXPECT_CALL(callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
 855
 856   // Attempt the read...
 857   audio->Read(base::Bind(&MockReadCB::Run, base::Unretained(&callback)));
 858   message_loop_.RunUntilIdle();
 859
 860   // Don't let the test call Stop() again.
 861   demuxer_.reset();
 862 }
 863
 864 // Verify that seek works properly when the WebM cues data is at the start of
 865 // the file instead of at the end.
 866 TEST_F(FFmpegDemuxerTest, SeekWithCuesBeforeFirstCluster) {
 867   CreateDemuxer("bear-320x240-cues-in-front.webm");
 868   InitializeDemuxer();
 869
 870   // Get our streams.
 871   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 872   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 873   ASSERT_TRUE(video);
 874   ASSERT_TRUE(audio);
 875
 876   // Read a video packet and release it.
 877   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
 878   message_loop_.Run();
 879
 880   // Issue a simple forward seek, which should discard queued packets.
 881   WaitableMessageLoopEvent event;
 882   demuxer_->Seek(base::TimeDelta::FromMicroseconds(2500000),
 883                  event.GetPipelineStatusCB());
 884   event.RunAndWaitForStatus(PIPELINE_OK);
 885
 886   // Audio read #1.
 887   audio->Read(NewReadCB(FROM_HERE, 40, 2403000, true));
 888   message_loop_.Run();
 889
 890   // Audio read #2.
 891   audio->Read(NewReadCB(FROM_HERE, 42, 2406000, true));
 892   message_loop_.Run();
 893
 894   // Video read #1.
 895   video->Read(NewReadCB(FROM_HERE, 5276, 2402000, true));
 896   message_loop_.Run();
 897
 898   // Video read #2.
 899   video->Read(NewReadCB(FROM_HERE, 1740, 2436000, false));
 900   message_loop_.Run();
 901 }
 902
 903 #if defined(USE_PROPRIETARY_CODECS)
 904 // Ensure ID3v1 tag reading is disabled.  id3_test.mp3 has an ID3v1 tag with the
 905 // field "title" set to "sample for id3 test".
 906 TEST_F(FFmpegDemuxerTest, NoID3TagData) {
 907   CreateDemuxer("id3_test.mp3");
 908   InitializeDemuxer();
 909   EXPECT_FALSE(av_dict_get(format_context()->metadata, "title", NULL, 0));
 910 }
 911 #endif
 912
 913 #if defined(USE_PROPRIETARY_CODECS)
 914 // Ensure MP3 files with large image/video based ID3 tags demux okay.  FFmpeg
 915 // will hand us a video stream to the data which will likely be in a format we
 916 // don't accept as video; e.g. PNG.
 917 TEST_F(FFmpegDemuxerTest, Mp3WithVideoStreamID3TagData) {
 918   CreateDemuxer("id3_png_test.mp3");
 919   InitializeDemuxer();
 920
 921   // Ensure the expected streams are present.
 922   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
 923   EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
 924 }
 925 #endif
 926
 927 // Ensure a video with an unsupported audio track still results in the video
 928 // stream being demuxed.
 929 TEST_F(FFmpegDemuxerTest, UnsupportedAudioSupportedVideoDemux) {
 930   CreateDemuxer("speex_audio_vorbis_video.ogv");
 931   InitializeDemuxer();
 932
 933   // Ensure the expected streams are present.
 934   EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::VIDEO));
 935   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::AUDIO));
 936 }
 937
 938 // Ensure a video with an unsupported video track still results in the audio
 939 // stream being demuxed.
 940 TEST_F(FFmpegDemuxerTest, UnsupportedVideoSupportedAudioDemux) {
 941   CreateDemuxer("vorbis_audio_wmv_video.mkv");
 942   InitializeDemuxer();
 943
 944   // Ensure the expected streams are present.
 945   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
 946   EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
 947 }
 948
 949 #if defined(USE_PROPRIETARY_CODECS)
 950 // FFmpeg returns null data pointers when samples have zero size, leading to
 951 // mistakenly creating end of stream buffers http://crbug.com/169133
 952 TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
 953   CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
 954   InitializeDemuxer();
 955   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 956 }
 957
 958
 959 static void ValidateAnnexB(DemuxerStream* stream,
 960                            DemuxerStream::Status status,
 961                            const scoped_refptr<DecoderBuffer>& buffer) {
 962   EXPECT_EQ(status, DemuxerStream::kOk);
 963
 964   if (buffer->end_of_stream()) {
 965     base::MessageLoop::current()->PostTask(
 966         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 967     return;
 968   }
 969
 970   std::vector<SubsampleEntry> subsamples;
 971
 972   if (buffer->decrypt_config())
 973     subsamples = buffer->decrypt_config()->subsamples();
 974
 975   bool is_valid =
 976       mp4::AVC::IsValidAnnexB(buffer->data(), buffer->data_size(),
 977                               subsamples);
 978   EXPECT_TRUE(is_valid);
 979
 980   if (!is_valid) {
 981     LOG(ERROR) << "Buffer contains invalid Annex B data.";
 982     base::MessageLoop::current()->PostTask(
 983         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 984     return;
 985   }
 986
 987   stream->Read(base::Bind(&ValidateAnnexB, stream));
 988 };
 989
 990 TEST_F(FFmpegDemuxerTest, IsValidAnnexB) {
 991   const char* files[] = {
 992     "bear-1280x720-av_frag.mp4",
 993     "bear-1280x720-av_with-aud-nalus_frag.mp4"
 994   };
 995
 996   for (size_t i = 0; i < arraysize(files); ++i) {
 997     DVLOG(1) << "Testing " << files[i];
 998     CreateDemuxer(files[i]);
 999     InitializeDemuxer();
1000
1001     // Ensure the expected streams are present.
1002     DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1003     ASSERT_TRUE(stream);
1004     stream->EnableBitstreamConverter();
1005
1006     stream->Read(base::Bind(&ValidateAnnexB, stream));
1007     message_loop_.Run();
1008
1009     demuxer_->Stop();
1010     demuxer_.reset();
1011     data_source_.reset();
1012   }
1013 }
1014
1015 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_0) {
1016   CreateDemuxer("bear_rotate_0.mp4");
1017   InitializeDemuxer();
1018
1019   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1020   ASSERT_TRUE(stream);
1021   ASSERT_EQ(VIDEO_ROTATION_0, stream->video_rotation());
1022 }
1023
1024 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_90) {
1025   CreateDemuxer("bear_rotate_90.mp4");
1026   InitializeDemuxer();
1027
1028   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1029   ASSERT_TRUE(stream);
1030   ASSERT_EQ(VIDEO_ROTATION_90, stream->video_rotation());
1031 }
1032
1033 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_180) {
1034   CreateDemuxer("bear_rotate_180.mp4");
1035   InitializeDemuxer();
1036
1037   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1038   ASSERT_TRUE(stream);
1039   ASSERT_EQ(VIDEO_ROTATION_180, stream->video_rotation());
1040 }
1041
1042 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_270) {
1043   CreateDemuxer("bear_rotate_270.mp4");
1044   InitializeDemuxer();
1045
1046   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1047   ASSERT_TRUE(stream);
1048   ASSERT_EQ(VIDEO_ROTATION_270, stream->video_rotation());
1049 }
1050
1051 TEST_F(FFmpegDemuxerTest, NaturalSizeWithoutPASP) {
1052   CreateDemuxer("bear-640x360-non_square_pixel-without_pasp.mp4");
1053   InitializeDemuxer();
1054
1055   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1056   ASSERT_TRUE(stream);
1057
1058   const VideoDecoderConfig& video_config = stream->video_decoder_config();
1059   EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
1060 }
1061
1062 TEST_F(FFmpegDemuxerTest, NaturalSizeWithPASP) {
1063   CreateDemuxer("bear-640x360-non_square_pixel-with_pasp.mp4");
1064   InitializeDemuxer();
1065
1066   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
1067   ASSERT_TRUE(stream);
1068
1069   const VideoDecoderConfig& video_config = stream->video_decoder_config();
1070   EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
1071 }
1072
1073 #endif
1074
1075 #if defined(ENABLE_HEVC_DEMUXING)
1076 TEST_F(FFmpegDemuxerTest, HEVC_in_MP4_container) {
1077   CreateDemuxer("bear-hevc-frag.mp4");
1078   InitializeDemuxer();
1079
1080   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
1081   ASSERT_TRUE(video);
1082
1083   video->Read(NewReadCB(FROM_HERE, 3569, 66733, true));
1084   message_loop_.Run();
1085
1086   video->Read(NewReadCB(FROM_HERE, 1042, 200200, false));
1087   message_loop_.Run();
1088 }
1089 #endif
1090
1091 }  // namespace media