OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/test/pipeline_integration_test_base.h" | 5 #include "media/test/pipeline_integration_test_base.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
(...skipping 23 matching lines...) Expand all Loading... |
34 using ::testing::AnyNumber; | 34 using ::testing::AnyNumber; |
35 using ::testing::AtLeast; | 35 using ::testing::AtLeast; |
36 using ::testing::AtMost; | 36 using ::testing::AtMost; |
37 using ::testing::Invoke; | 37 using ::testing::Invoke; |
38 using ::testing::InvokeWithoutArgs; | 38 using ::testing::InvokeWithoutArgs; |
39 using ::testing::Return; | 39 using ::testing::Return; |
40 using ::testing::SaveArg; | 40 using ::testing::SaveArg; |
41 | 41 |
42 namespace media { | 42 namespace media { |
43 | 43 |
| 44 static ScopedVector<VideoDecoder> CreateVideoDecodersForTest( |
| 45 MediaLog* media_log, |
| 46 CreateVideoDecodersCB prepend_video_decoders_cb) { |
| 47 ScopedVector<VideoDecoder> video_decoders; |
| 48 |
| 49 if (!prepend_video_decoders_cb.is_null()) { |
| 50 video_decoders = prepend_video_decoders_cb.Run(); |
| 51 DCHECK(!video_decoders.empty()); |
| 52 } |
| 53 |
| 54 #if !defined(MEDIA_DISABLE_LIBVPX) |
| 55 video_decoders.push_back(new VpxVideoDecoder()); |
| 56 #endif // !defined(MEDIA_DISABLE_LIBVPX) |
| 57 |
| 58 // Android does not have an ffmpeg video decoder. |
| 59 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID) |
| 60 video_decoders.push_back(new FFmpegVideoDecoder(media_log)); |
| 61 #endif |
| 62 return video_decoders; |
| 63 } |
| 64 |
| 65 static ScopedVector<AudioDecoder> CreateAudioDecodersForTest( |
| 66 MediaLog* media_log, |
| 67 const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner, |
| 68 CreateAudioDecodersCB prepend_audio_decoders_cb) { |
| 69 ScopedVector<AudioDecoder> audio_decoders; |
| 70 |
| 71 if (!prepend_audio_decoders_cb.is_null()) { |
| 72 audio_decoders = prepend_audio_decoders_cb.Run(); |
| 73 DCHECK(!audio_decoders.empty()); |
| 74 } |
| 75 |
| 76 #if !defined(MEDIA_DISABLE_FFMPEG) |
| 77 audio_decoders.push_back( |
| 78 new FFmpegAudioDecoder(media_task_runner, media_log)); |
| 79 #endif |
| 80 return audio_decoders; |
| 81 } |
| 82 |
44 const char kNullVideoHash[] = "d41d8cd98f00b204e9800998ecf8427e"; | 83 const char kNullVideoHash[] = "d41d8cd98f00b204e9800998ecf8427e"; |
45 const char kNullAudioHash[] = "0.00,0.00,0.00,0.00,0.00,0.00,"; | 84 const char kNullAudioHash[] = "0.00,0.00,0.00,0.00,0.00,0.00,"; |
46 | 85 |
47 PipelineIntegrationTestBase::PipelineIntegrationTestBase() | 86 PipelineIntegrationTestBase::PipelineIntegrationTestBase() |
48 : hashing_enabled_(false), | 87 : hashing_enabled_(false), |
49 clockless_playback_(false), | 88 clockless_playback_(false), |
50 pipeline_(new PipelineImpl(message_loop_.task_runner(), new MediaLog())), | 89 pipeline_(new PipelineImpl(message_loop_.task_runner(), &media_log_)), |
51 ended_(false), | 90 ended_(false), |
52 pipeline_status_(PIPELINE_OK), | 91 pipeline_status_(PIPELINE_OK), |
53 last_video_frame_format_(PIXEL_FORMAT_UNKNOWN), | 92 last_video_frame_format_(PIXEL_FORMAT_UNKNOWN), |
54 last_video_frame_color_space_(COLOR_SPACE_UNSPECIFIED), | 93 last_video_frame_color_space_(COLOR_SPACE_UNSPECIFIED), |
55 current_duration_(kInfiniteDuration) { | 94 current_duration_(kInfiniteDuration) { |
56 ResetVideoHash(); | 95 ResetVideoHash(); |
57 EXPECT_CALL(*this, OnVideoAverageKeyframeDistanceUpdate()).Times(AnyNumber()); | 96 EXPECT_CALL(*this, OnVideoAverageKeyframeDistanceUpdate()).Times(AnyNumber()); |
58 } | 97 } |
59 | 98 |
60 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() { | 99 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() { |
(...skipping 251 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
312 data_source_ = std::move(data_source); | 351 data_source_ = std::move(data_source); |
313 | 352 |
314 #if !defined(MEDIA_DISABLE_FFMPEG) | 353 #if !defined(MEDIA_DISABLE_FFMPEG) |
315 task_scheduler_.reset(new base::test::ScopedTaskScheduler(&message_loop_)); | 354 task_scheduler_.reset(new base::test::ScopedTaskScheduler(&message_loop_)); |
316 demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer( | 355 demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer( |
317 message_loop_.task_runner(), data_source_.get(), | 356 message_loop_.task_runner(), data_source_.get(), |
318 base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB, | 357 base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB, |
319 base::Unretained(this)), | 358 base::Unretained(this)), |
320 base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB, | 359 base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB, |
321 base::Unretained(this)), | 360 base::Unretained(this)), |
322 new MediaLog())); | 361 &media_log_)); |
323 #endif | 362 #endif |
324 } | 363 } |
325 | 364 |
326 ScopedVector<VideoDecoder> CreateVideoDecodersForTest( | |
327 CreateVideoDecodersCB prepend_video_decoders_cb) { | |
328 ScopedVector<VideoDecoder> video_decoders; | |
329 | |
330 if (!prepend_video_decoders_cb.is_null()) { | |
331 video_decoders = prepend_video_decoders_cb.Run(); | |
332 DCHECK(!video_decoders.empty()); | |
333 } | |
334 | |
335 #if !defined(MEDIA_DISABLE_LIBVPX) | |
336 video_decoders.push_back(new VpxVideoDecoder()); | |
337 #endif // !defined(MEDIA_DISABLE_LIBVPX) | |
338 | |
339 // Android does not have an ffmpeg video decoder. | |
340 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID) | |
341 video_decoders.push_back( | |
342 new FFmpegVideoDecoder(make_scoped_refptr(new MediaLog()))); | |
343 #endif | |
344 return video_decoders; | |
345 } | |
346 | |
347 ScopedVector<AudioDecoder> CreateAudioDecodersForTest( | |
348 const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner, | |
349 CreateAudioDecodersCB prepend_audio_decoders_cb) { | |
350 ScopedVector<AudioDecoder> audio_decoders; | |
351 | |
352 if (!prepend_audio_decoders_cb.is_null()) { | |
353 audio_decoders = prepend_audio_decoders_cb.Run(); | |
354 DCHECK(!audio_decoders.empty()); | |
355 } | |
356 | |
357 #if !defined(MEDIA_DISABLE_FFMPEG) | |
358 audio_decoders.push_back( | |
359 new FFmpegAudioDecoder(media_task_runner, new MediaLog())); | |
360 #endif | |
361 return audio_decoders; | |
362 } | |
363 | |
364 std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer( | 365 std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer( |
365 CreateVideoDecodersCB prepend_video_decoders_cb, | 366 CreateVideoDecodersCB prepend_video_decoders_cb, |
366 CreateAudioDecodersCB prepend_audio_decoders_cb) { | 367 CreateAudioDecodersCB prepend_audio_decoders_cb) { |
367 // Simulate a 60Hz rendering sink. | 368 // Simulate a 60Hz rendering sink. |
368 video_sink_.reset(new NullVideoSink( | 369 video_sink_.reset(new NullVideoSink( |
369 clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60), | 370 clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60), |
370 base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint, | 371 base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint, |
371 base::Unretained(this)), | 372 base::Unretained(this)), |
372 message_loop_.task_runner())); | 373 message_loop_.task_runner())); |
373 | 374 |
374 // Disable frame dropping if hashing is enabled. | 375 // Disable frame dropping if hashing is enabled. |
375 std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl( | 376 std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl( |
376 message_loop_.task_runner(), message_loop_.task_runner().get(), | 377 message_loop_.task_runner(), message_loop_.task_runner().get(), |
377 video_sink_.get(), | 378 video_sink_.get(), |
378 base::Bind(&CreateVideoDecodersForTest, prepend_video_decoders_cb), false, | 379 base::Bind(&CreateVideoDecodersForTest, &media_log_, |
379 nullptr, new MediaLog())); | 380 prepend_video_decoders_cb), |
| 381 false, nullptr, &media_log_)); |
380 | 382 |
381 if (!clockless_playback_) { | 383 if (!clockless_playback_) { |
382 audio_sink_ = new NullAudioSink(message_loop_.task_runner()); | 384 audio_sink_ = new NullAudioSink(message_loop_.task_runner()); |
383 } else { | 385 } else { |
384 clockless_audio_sink_ = new ClocklessAudioSink(OutputDeviceInfo( | 386 clockless_audio_sink_ = new ClocklessAudioSink(OutputDeviceInfo( |
385 "", OUTPUT_DEVICE_STATUS_OK, | 387 "", OUTPUT_DEVICE_STATUS_OK, |
386 // Don't allow the audio renderer to resample buffers if hashing is | 388 // Don't allow the audio renderer to resample buffers if hashing is |
387 // enabled: | 389 // enabled: |
388 hashing_enabled_ | 390 hashing_enabled_ |
389 ? AudioParameters() | 391 ? AudioParameters() |
390 : AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, | 392 : AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, |
391 CHANNEL_LAYOUT_STEREO, 44100, 16, 512))); | 393 CHANNEL_LAYOUT_STEREO, 44100, 16, 512))); |
392 } | 394 } |
393 | 395 |
394 std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl( | 396 std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl( |
395 message_loop_.task_runner(), | 397 message_loop_.task_runner(), |
396 (clockless_playback_) | 398 (clockless_playback_) |
397 ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get()) | 399 ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get()) |
398 : audio_sink_.get(), | 400 : audio_sink_.get(), |
399 base::Bind(&CreateAudioDecodersForTest, message_loop_.task_runner(), | 401 base::Bind(&CreateAudioDecodersForTest, &media_log_, |
400 prepend_audio_decoders_cb), | 402 message_loop_.task_runner(), prepend_audio_decoders_cb), |
401 new MediaLog())); | 403 &media_log_)); |
402 if (hashing_enabled_) { | 404 if (hashing_enabled_) { |
403 if (clockless_playback_) | 405 if (clockless_playback_) |
404 clockless_audio_sink_->StartAudioHashForTesting(); | 406 clockless_audio_sink_->StartAudioHashForTesting(); |
405 else | 407 else |
406 audio_sink_->StartAudioHashForTesting(); | 408 audio_sink_->StartAudioHashForTesting(); |
407 } | 409 } |
408 | 410 |
409 std::unique_ptr<RendererImpl> renderer_impl( | 411 std::unique_ptr<RendererImpl> renderer_impl( |
410 new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer), | 412 new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer), |
411 std::move(video_renderer))); | 413 std::move(video_renderer))); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
469 DCHECK(clockless_playback_); | 471 DCHECK(clockless_playback_); |
470 return clockless_audio_sink_->render_time(); | 472 return clockless_audio_sink_->render_time(); |
471 } | 473 } |
472 | 474 |
473 base::TimeTicks DummyTickClock::NowTicks() { | 475 base::TimeTicks DummyTickClock::NowTicks() { |
474 now_ += base::TimeDelta::FromSeconds(60); | 476 now_ += base::TimeDelta::FromSeconds(60); |
475 return now_; | 477 return now_; |
476 } | 478 } |
477 | 479 |
478 } // namespace media | 480 } // namespace media |
OLD | NEW |