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 "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/message_loop.h" | 6 #include "base/message_loop.h" |
7 #include "media/base/audio_decoder_config.h" | 7 #include "media/base/audio_decoder_config.h" |
8 #include "media/base/decoder_buffer.h" | 8 #include "media/base/decoder_buffer.h" |
9 #include "media/base/mock_callback.h" | 9 #include "media/base/mock_callback.h" |
10 #include "media/base/mock_demuxer_host.h" | 10 #include "media/base/mock_demuxer_host.h" |
11 #include "media/base/test_data_util.h" | 11 #include "media/base/test_data_util.h" |
12 #include "media/filters/chunk_demuxer.h" | 12 #include "media/filters/chunk_demuxer.h" |
13 #include "media/webm/cluster_builder.h" | 13 #include "media/webm/cluster_builder.h" |
14 #include "media/webm/webm_constants.h" | 14 #include "media/webm/webm_constants.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 using ::testing::AnyNumber; | 17 using ::testing::AnyNumber; |
| 18 using ::testing::Exactly; |
18 using ::testing::InSequence; | 19 using ::testing::InSequence; |
19 using ::testing::NotNull; | 20 using ::testing::NotNull; |
20 using ::testing::Return; | 21 using ::testing::Return; |
21 using ::testing::SaveArg; | 22 using ::testing::SaveArg; |
22 using ::testing::SetArgumentPointee; | 23 using ::testing::SetArgumentPointee; |
23 using ::testing::_; | 24 using ::testing::_; |
24 | 25 |
25 namespace media { | 26 namespace media { |
26 | 27 |
27 static const uint8 kTracksHeader[] = { | 28 static const uint8 kTracksHeader[] = { |
28 0x16, 0x54, 0xAE, 0x6B, // Tracks ID | 29 0x16, 0x54, 0xAE, 0x6B, // Tracks ID |
29 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tracks(size = 0) | 30 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tracks(size = 0) |
30 }; | 31 }; |
31 | 32 |
32 static const int kTracksHeaderSize = sizeof(kTracksHeader); | 33 static const int kTracksHeaderSize = sizeof(kTracksHeader); |
33 static const int kTracksSizeOffset = 4; | 34 static const int kTracksSizeOffset = 4; |
34 | 35 |
| 36 // The size of TrackEntry element in test file "webm_vorbis_track_entry" starts |
| 37 // at index 1 and spans 8 bytes. |
| 38 static const int kAudioTrackSizeOffset = 1; |
| 39 static const int kAudioTrackSizeWidth = 8; |
| 40 static const int kAudioTrackEntryHeaderSize = kAudioTrackSizeOffset + |
| 41 kAudioTrackSizeWidth; |
| 42 |
35 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at | 43 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at |
36 // index 1 and spans 8 bytes. | 44 // index 1 and spans 8 bytes. |
37 static const int kVideoTrackSizeOffset = 1; | 45 static const int kVideoTrackSizeOffset = 1; |
38 static const int kVideoTrackSizeWidth = 8; | 46 static const int kVideoTrackSizeWidth = 8; |
39 static const int kVideoTrackEntryHeaderSize = kVideoTrackSizeOffset + | 47 static const int kVideoTrackEntryHeaderSize = kVideoTrackSizeOffset + |
40 kVideoTrackSizeWidth; | 48 kVideoTrackSizeWidth; |
41 | 49 |
42 static const int kVideoTrackNum = 1; | 50 static const int kVideoTrackNum = 1; |
43 static const int kAudioTrackNum = 2; | 51 static const int kAudioTrackNum = 2; |
44 | 52 |
(...skipping 110 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 ChunkDemuxer::NeedKeyCB need_key_cb = | 163 ChunkDemuxer::NeedKeyCB need_key_cb = |
156 base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this)); | 164 base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this)); |
157 demuxer_ = new ChunkDemuxer(open_cb, need_key_cb); | 165 demuxer_ = new ChunkDemuxer(open_cb, need_key_cb); |
158 } | 166 } |
159 | 167 |
160 virtual ~ChunkDemuxerTest() { | 168 virtual ~ChunkDemuxerTest() { |
161 ShutdownDemuxer(); | 169 ShutdownDemuxer(); |
162 } | 170 } |
163 | 171 |
164 void CreateInitSegment(bool has_audio, bool has_video, | 172 void CreateInitSegment(bool has_audio, bool has_video, |
165 bool video_content_encoded, | 173 bool is_audio_encrypted, bool is_video_encrypted, |
166 scoped_array<uint8>* buffer, | 174 scoped_array<uint8>* buffer, |
167 int* size) { | 175 int* size) { |
168 scoped_refptr<DecoderBuffer> ebml_header; | 176 scoped_refptr<DecoderBuffer> ebml_header; |
169 scoped_refptr<DecoderBuffer> info; | 177 scoped_refptr<DecoderBuffer> info; |
170 scoped_refptr<DecoderBuffer> audio_track_entry; | 178 scoped_refptr<DecoderBuffer> audio_track_entry; |
171 scoped_refptr<DecoderBuffer> video_track_entry; | 179 scoped_refptr<DecoderBuffer> video_track_entry; |
| 180 scoped_refptr<DecoderBuffer> audio_content_encodings; |
172 scoped_refptr<DecoderBuffer> video_content_encodings; | 181 scoped_refptr<DecoderBuffer> video_content_encodings; |
173 | 182 |
174 ebml_header = ReadTestDataFile("webm_ebml_element"); | 183 ebml_header = ReadTestDataFile("webm_ebml_element"); |
175 | 184 |
176 info = ReadTestDataFile("webm_info_element"); | 185 info = ReadTestDataFile("webm_info_element"); |
177 | 186 |
178 int tracks_element_size = 0; | 187 int tracks_element_size = 0; |
179 | 188 |
180 if (has_audio) { | 189 if (has_audio) { |
181 audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry"); | 190 audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry"); |
182 tracks_element_size += audio_track_entry->GetDataSize(); | 191 tracks_element_size += audio_track_entry->GetDataSize(); |
| 192 if (is_audio_encrypted) { |
| 193 audio_content_encodings = ReadTestDataFile("webm_content_encodings"); |
| 194 tracks_element_size += audio_content_encodings->GetDataSize(); |
| 195 } |
183 } | 196 } |
184 | 197 |
185 if (has_video) { | 198 if (has_video) { |
186 video_track_entry = ReadTestDataFile("webm_vp8_track_entry"); | 199 video_track_entry = ReadTestDataFile("webm_vp8_track_entry"); |
187 tracks_element_size += video_track_entry->GetDataSize(); | 200 tracks_element_size += video_track_entry->GetDataSize(); |
188 if (video_content_encoded) { | 201 if (is_video_encrypted) { |
189 video_content_encodings = ReadTestDataFile("webm_content_encodings"); | 202 video_content_encodings = ReadTestDataFile("webm_content_encodings"); |
190 tracks_element_size += video_content_encodings->GetDataSize(); | 203 tracks_element_size += video_content_encodings->GetDataSize(); |
191 } | 204 } |
192 } | 205 } |
193 | 206 |
194 *size = ebml_header->GetDataSize() + info->GetDataSize() + | 207 *size = ebml_header->GetDataSize() + info->GetDataSize() + |
195 kTracksHeaderSize + tracks_element_size; | 208 kTracksHeaderSize + tracks_element_size; |
196 | 209 |
197 buffer->reset(new uint8[*size]); | 210 buffer->reset(new uint8[*size]); |
198 | 211 |
199 uint8* buf = buffer->get(); | 212 uint8* buf = buffer->get(); |
200 memcpy(buf, ebml_header->GetData(), ebml_header->GetDataSize()); | 213 memcpy(buf, ebml_header->GetData(), ebml_header->GetDataSize()); |
201 buf += ebml_header->GetDataSize(); | 214 buf += ebml_header->GetDataSize(); |
202 | 215 |
203 memcpy(buf, info->GetData(), info->GetDataSize()); | 216 memcpy(buf, info->GetData(), info->GetDataSize()); |
204 buf += info->GetDataSize(); | 217 buf += info->GetDataSize(); |
205 | 218 |
206 memcpy(buf, kTracksHeader, kTracksHeaderSize); | 219 memcpy(buf, kTracksHeader, kTracksHeaderSize); |
207 WriteInt64(buf + kTracksSizeOffset, tracks_element_size); | 220 WriteInt64(buf + kTracksSizeOffset, tracks_element_size); |
208 buf += kTracksHeaderSize; | 221 buf += kTracksHeaderSize; |
209 | 222 |
| 223 // TODO(xhwang): Simplify this! Probably have test data files that contain |
| 224 // ContentEncodings directly instead of trying to create one at run-time. |
210 if (has_audio) { | 225 if (has_audio) { |
211 memcpy(buf, audio_track_entry->GetData(), | 226 memcpy(buf, audio_track_entry->GetData(), |
212 audio_track_entry->GetDataSize()); | 227 audio_track_entry->GetDataSize()); |
| 228 if (is_audio_encrypted) { |
| 229 memcpy(buf + audio_track_entry->GetDataSize(), |
| 230 audio_content_encodings->GetData(), |
| 231 audio_content_encodings->GetDataSize()); |
| 232 WriteInt64(buf + kAudioTrackSizeOffset, |
| 233 audio_track_entry->GetDataSize() + |
| 234 audio_content_encodings->GetDataSize() - |
| 235 kAudioTrackEntryHeaderSize); |
| 236 buf += audio_content_encodings->GetDataSize(); |
| 237 } |
213 buf += audio_track_entry->GetDataSize(); | 238 buf += audio_track_entry->GetDataSize(); |
214 } | 239 } |
215 | 240 |
216 if (has_video) { | 241 if (has_video) { |
217 memcpy(buf, video_track_entry->GetData(), | 242 memcpy(buf, video_track_entry->GetData(), |
218 video_track_entry->GetDataSize()); | 243 video_track_entry->GetDataSize()); |
219 if (video_content_encoded) { | 244 if (is_video_encrypted) { |
220 memcpy(buf + video_track_entry->GetDataSize(), | 245 memcpy(buf + video_track_entry->GetDataSize(), |
221 video_content_encodings->GetData(), | 246 video_content_encodings->GetData(), |
222 video_content_encodings->GetDataSize()); | 247 video_content_encodings->GetDataSize()); |
223 WriteInt64(buf + kVideoTrackSizeOffset, | 248 WriteInt64(buf + kVideoTrackSizeOffset, |
224 video_track_entry->GetDataSize() + | 249 video_track_entry->GetDataSize() + |
225 video_content_encodings->GetDataSize() - | 250 video_content_encodings->GetDataSize() - |
226 kVideoTrackEntryHeaderSize); | 251 kVideoTrackEntryHeaderSize); |
227 buf += video_content_encodings->GetDataSize(); | 252 buf += video_content_encodings->GetDataSize(); |
228 } | 253 } |
229 buf += video_track_entry->GetDataSize(); | 254 buf += video_track_entry->GetDataSize(); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
282 while (start < end) { | 307 while (start < end) { |
283 size_t append_size = std::min(piece_size, | 308 size_t append_size = std::min(piece_size, |
284 static_cast<size_t>(end - start)); | 309 static_cast<size_t>(end - start)); |
285 if (!AppendData(start, append_size)) | 310 if (!AppendData(start, append_size)) |
286 return false; | 311 return false; |
287 start += append_size; | 312 start += append_size; |
288 } | 313 } |
289 return true; | 314 return true; |
290 } | 315 } |
291 | 316 |
292 bool AppendInitSegment(bool has_audio, bool has_video, | 317 bool AppendInitSegment(bool has_audio, bool has_video) { |
293 bool video_content_encoded) { | 318 return AppendInitSegmentWithSourceId(kSourceId, has_audio, has_video); |
294 return AppendInitSegment(kSourceId, has_audio, has_video, | |
295 video_content_encoded); | |
296 } | 319 } |
297 | 320 |
298 bool AppendInitSegment(const std::string& source_id, | 321 bool AppendInitSegmentWithSourceId(const std::string& source_id, |
299 bool has_audio, bool has_video, | 322 bool has_audio, bool has_video) { |
300 bool video_content_encoded) { | 323 return AppendInitSegmentWithEncryptedInfo( |
| 324 source_id, has_audio, has_video, false, false); |
| 325 } |
| 326 |
| 327 bool AppendInitSegmentWithEncryptedInfo(const std::string& source_id, |
| 328 bool has_audio, bool has_video, |
| 329 bool is_audio_encrypted, |
| 330 bool is_video_encrypted) { |
301 scoped_array<uint8> info_tracks; | 331 scoped_array<uint8> info_tracks; |
302 int info_tracks_size = 0; | 332 int info_tracks_size = 0; |
303 CreateInitSegment(has_audio, has_video, video_content_encoded, | 333 CreateInitSegment(has_audio, has_video, |
| 334 is_audio_encrypted, is_video_encrypted, |
304 &info_tracks, &info_tracks_size); | 335 &info_tracks, &info_tracks_size); |
305 return AppendData(source_id, info_tracks.get(), info_tracks_size); | 336 return AppendData(source_id, info_tracks.get(), info_tracks_size); |
306 } | 337 } |
307 | 338 |
308 bool AppendGarbage() { | 339 bool AppendGarbage() { |
309 // Fill up an array with gibberish. | 340 // Fill up an array with gibberish. |
310 int garbage_cluster_size = 10; | 341 int garbage_cluster_size = 10; |
311 scoped_array<uint8> garbage_cluster(new uint8[garbage_cluster_size]); | 342 scoped_array<uint8> garbage_cluster(new uint8[garbage_cluster_size]); |
312 for (int i = 0; i < garbage_cluster_size; ++i) | 343 for (int i = 0; i < garbage_cluster_size; ++i) |
313 garbage_cluster[i] = i; | 344 garbage_cluster[i] = i; |
(...skipping 16 matching lines...) Expand all Loading... |
330 EXPECT_CALL(host_, SetDuration(expected_duration)); | 361 EXPECT_CALL(host_, SetDuration(expected_duration)); |
331 return CreateInitDoneCB(expected_status); | 362 return CreateInitDoneCB(expected_status); |
332 } | 363 } |
333 | 364 |
334 PipelineStatusCB CreateInitDoneCB(PipelineStatus expected_status) { | 365 PipelineStatusCB CreateInitDoneCB(PipelineStatus expected_status) { |
335 return base::Bind(&ChunkDemuxerTest::InitDoneCalled, | 366 return base::Bind(&ChunkDemuxerTest::InitDoneCalled, |
336 base::Unretained(this), | 367 base::Unretained(this), |
337 expected_status); | 368 expected_status); |
338 } | 369 } |
339 | 370 |
340 bool InitDemuxer(bool has_audio, bool has_video, | 371 bool InitDemuxer(bool has_audio, bool has_video) { |
341 bool video_content_encoded) { | 372 return InitDemuxerWithEncryptionInfo(has_audio, has_video, false, false); |
| 373 } |
| 374 |
| 375 bool InitDemuxerWithEncryptionInfo( |
| 376 bool has_audio, bool has_video, |
| 377 bool is_audio_encrypted, bool is_video_encrypted) { |
342 PipelineStatus expected_status = | 378 PipelineStatus expected_status = |
343 (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN; | 379 (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN; |
344 | 380 |
345 base::TimeDelta expected_duration = kNoTimestamp(); | 381 base::TimeDelta expected_duration = kNoTimestamp(); |
346 if (expected_status == PIPELINE_OK) | 382 if (expected_status == PIPELINE_OK) |
347 expected_duration = kDefaultDuration(); | 383 expected_duration = kDefaultDuration(); |
348 | 384 |
349 EXPECT_CALL(*this, DemuxerOpened()); | 385 EXPECT_CALL(*this, DemuxerOpened()); |
350 demuxer_->Initialize( | 386 demuxer_->Initialize( |
351 &host_, CreateInitDoneCB(expected_duration, expected_status)); | 387 &host_, CreateInitDoneCB(expected_duration, expected_status)); |
352 | 388 |
353 if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk) | 389 if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk) |
354 return false; | 390 return false; |
355 | 391 |
356 return AppendInitSegment(has_audio, has_video, video_content_encoded); | 392 return AppendInitSegmentWithEncryptedInfo( |
| 393 kSourceId, has_audio, has_video, |
| 394 is_audio_encrypted, is_video_encrypted); |
357 } | 395 } |
358 | 396 |
359 bool InitDemuxerAudioAndVideoSources(const std::string& audio_id, | 397 bool InitDemuxerAudioAndVideoSources(const std::string& audio_id, |
360 const std::string& video_id) { | 398 const std::string& video_id) { |
361 EXPECT_CALL(*this, DemuxerOpened()); | 399 EXPECT_CALL(*this, DemuxerOpened()); |
362 demuxer_->Initialize( | 400 demuxer_->Initialize( |
363 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); | 401 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); |
364 | 402 |
365 if (AddId(audio_id, true, false) != ChunkDemuxer::kOk) | 403 if (AddId(audio_id, true, false) != ChunkDemuxer::kOk) |
366 return false; | 404 return false; |
367 if (AddId(video_id, false, true) != ChunkDemuxer::kOk) | 405 if (AddId(video_id, false, true) != ChunkDemuxer::kOk) |
368 return false; | 406 return false; |
369 | 407 |
370 bool success = AppendInitSegment(audio_id, true, false, false); | 408 bool success = AppendInitSegmentWithSourceId(audio_id, true, false); |
371 success &= AppendInitSegment(video_id, false, true, false); | 409 success &= AppendInitSegmentWithSourceId(video_id, false, true); |
372 return success; | 410 return success; |
373 } | 411 } |
374 | 412 |
375 // Initializes the demuxer with data from 2 files with different | 413 // Initializes the demuxer with data from 2 files with different |
376 // decoder configurations. This is used to test the decoder config change | 414 // decoder configurations. This is used to test the decoder config change |
377 // logic. | 415 // logic. |
378 // | 416 // |
379 // bear-320x240.webm VideoDecoderConfig returns 320x240 for its natural_size() | 417 // bear-320x240.webm VideoDecoderConfig returns 320x240 for its natural_size() |
380 // bear-640x360.webm VideoDecoderConfig returns 640x360 for its natural_size() | 418 // bear-640x360.webm VideoDecoderConfig returns 640x360 for its natural_size() |
381 // The resulting video stream returns data from each file for the following | 419 // The resulting video stream returns data from each file for the following |
(...skipping 320 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
702 MessageLoop message_loop_; | 740 MessageLoop message_loop_; |
703 MockDemuxerHost host_; | 741 MockDemuxerHost host_; |
704 | 742 |
705 scoped_refptr<ChunkDemuxer> demuxer_; | 743 scoped_refptr<ChunkDemuxer> demuxer_; |
706 | 744 |
707 private: | 745 private: |
708 DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest); | 746 DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest); |
709 }; | 747 }; |
710 | 748 |
711 TEST_F(ChunkDemuxerTest, TestInit) { | 749 TEST_F(ChunkDemuxerTest, TestInit) { |
712 // Test no streams, audio-only, video-only, and audio & video scenarios, | 750 // Test no streams, audio-only, video-only, and audio & video scenarios. |
713 // with video encrypted or not. | 751 // Audio and video streams can be encrypted or not encrypted. |
714 for (int i = 0; i < 8; i++) { | 752 for (int i = 0; i < 16; i++) { |
715 bool has_audio = (i & 0x1) != 0; | 753 bool has_audio = (i & 0x1) != 0; |
716 bool has_video = (i & 0x2) != 0; | 754 bool has_video = (i & 0x2) != 0; |
717 bool is_video_encrypted = (i & 0x4) != 0; | 755 bool is_audio_encrypted = (i & 0x4) != 0; |
| 756 bool is_video_encrypted = (i & 0x8) != 0; |
718 | 757 |
719 // No test on invalid combination. | 758 // No test on invalid combination. |
720 if (!has_video && is_video_encrypted) | 759 if ((!has_audio && is_audio_encrypted) || |
| 760 (!has_video && is_video_encrypted)) { |
721 continue; | 761 continue; |
| 762 } |
722 | 763 |
723 CreateNewDemuxer(); | 764 CreateNewDemuxer(); |
724 if (has_video && is_video_encrypted) | |
725 EXPECT_CALL(*this, NeedKeyMock(NotNull(), 16)); | |
726 | 765 |
727 ASSERT_TRUE(InitDemuxer(has_audio, has_video, is_video_encrypted)); | 766 if (is_audio_encrypted || is_video_encrypted) { |
| 767 int need_key_count = (is_audio_encrypted ? 1 : 0) + |
| 768 (is_video_encrypted ? 1 : 0); |
| 769 EXPECT_CALL(*this, NeedKeyMock(NotNull(), 16)) |
| 770 .Times(Exactly(need_key_count)); |
| 771 } |
| 772 |
| 773 ASSERT_TRUE(InitDemuxerWithEncryptionInfo( |
| 774 has_audio, has_video, is_audio_encrypted, is_video_encrypted)); |
728 | 775 |
729 scoped_refptr<DemuxerStream> audio_stream = | 776 scoped_refptr<DemuxerStream> audio_stream = |
730 demuxer_->GetStream(DemuxerStream::AUDIO); | 777 demuxer_->GetStream(DemuxerStream::AUDIO); |
731 if (has_audio) { | 778 if (has_audio) { |
732 ASSERT_TRUE(audio_stream); | 779 ASSERT_TRUE(audio_stream); |
733 | 780 |
734 const AudioDecoderConfig& config = audio_stream->audio_decoder_config(); | 781 const AudioDecoderConfig& config = audio_stream->audio_decoder_config(); |
735 EXPECT_EQ(kCodecVorbis, config.codec()); | 782 EXPECT_EQ(kCodecVorbis, config.codec()); |
736 EXPECT_EQ(16, config.bits_per_channel()); | 783 EXPECT_EQ(16, config.bits_per_channel()); |
737 EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout()); | 784 EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout()); |
738 EXPECT_EQ(44100, config.samples_per_second()); | 785 EXPECT_EQ(44100, config.samples_per_second()); |
739 EXPECT_TRUE(config.extra_data()); | 786 EXPECT_TRUE(config.extra_data()); |
740 EXPECT_GT(config.extra_data_size(), 0u); | 787 EXPECT_GT(config.extra_data_size(), 0u); |
| 788 EXPECT_EQ(is_audio_encrypted, |
| 789 audio_stream->audio_decoder_config().is_encrypted()); |
741 } else { | 790 } else { |
742 EXPECT_FALSE(audio_stream); | 791 EXPECT_FALSE(audio_stream); |
743 } | 792 } |
744 | 793 |
745 scoped_refptr<DemuxerStream> video_stream = | 794 scoped_refptr<DemuxerStream> video_stream = |
746 demuxer_->GetStream(DemuxerStream::VIDEO); | 795 demuxer_->GetStream(DemuxerStream::VIDEO); |
747 if (has_video) { | 796 if (has_video) { |
748 EXPECT_TRUE(video_stream); | 797 EXPECT_TRUE(video_stream); |
749 EXPECT_EQ(is_video_encrypted, | 798 EXPECT_EQ(is_video_encrypted, |
750 video_stream->video_decoder_config().is_encrypted()); | 799 video_stream->video_decoder_config().is_encrypted()); |
(...skipping 10 matching lines...) Expand all Loading... |
761 // is called before all the initialization segments are appended. | 810 // is called before all the initialization segments are appended. |
762 TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) { | 811 TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) { |
763 EXPECT_CALL(*this, DemuxerOpened()); | 812 EXPECT_CALL(*this, DemuxerOpened()); |
764 demuxer_->Initialize( | 813 demuxer_->Initialize( |
765 &host_, CreateInitDoneCB( | 814 &host_, CreateInitDoneCB( |
766 kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN)); | 815 kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN)); |
767 | 816 |
768 EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk); | 817 EXPECT_EQ(AddId("audio", true, false), ChunkDemuxer::kOk); |
769 EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk); | 818 EXPECT_EQ(AddId("video", false, true), ChunkDemuxer::kOk); |
770 | 819 |
771 EXPECT_TRUE(AppendInitSegment("audio", true, false, false)); | 820 EXPECT_TRUE(AppendInitSegmentWithSourceId("audio", true, false)); |
772 } | 821 } |
773 | 822 |
774 // Test that Seek() completes successfully when the first cluster | 823 // Test that Seek() completes successfully when the first cluster |
775 // arrives. | 824 // arrives. |
776 TEST_F(ChunkDemuxerTest, TestAppendDataAfterSeek) { | 825 TEST_F(ChunkDemuxerTest, TestAppendDataAfterSeek) { |
777 ASSERT_TRUE(InitDemuxer(true, true, false)); | 826 ASSERT_TRUE(InitDemuxer(true, true)); |
778 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); | 827 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); |
779 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 828 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
780 | 829 |
781 InSequence s; | 830 InSequence s; |
782 | 831 |
783 EXPECT_CALL(*this, Checkpoint(1)); | 832 EXPECT_CALL(*this, Checkpoint(1)); |
784 | 833 |
785 demuxer_->Seek(base::TimeDelta::FromMilliseconds(46), | 834 demuxer_->Seek(base::TimeDelta::FromMilliseconds(46), |
786 NewExpectedStatusCB(PIPELINE_OK)); | 835 NewExpectedStatusCB(PIPELINE_OK)); |
787 | 836 |
788 EXPECT_CALL(*this, Checkpoint(2)); | 837 EXPECT_CALL(*this, Checkpoint(2)); |
789 | 838 |
790 scoped_ptr<Cluster> cluster(kDefaultSecondCluster()); | 839 scoped_ptr<Cluster> cluster(kDefaultSecondCluster()); |
791 | 840 |
792 Checkpoint(1); | 841 Checkpoint(1); |
793 | 842 |
794 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 843 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
795 | 844 |
796 Checkpoint(2); | 845 Checkpoint(2); |
797 } | 846 } |
798 | 847 |
799 // Test that parsing errors are handled for clusters appended after init. | 848 // Test that parsing errors are handled for clusters appended after init. |
800 TEST_F(ChunkDemuxerTest, TestErrorWhileParsingClusterAfterInit) { | 849 TEST_F(ChunkDemuxerTest, TestErrorWhileParsingClusterAfterInit) { |
801 ASSERT_TRUE(InitDemuxer(true, true, false)); | 850 ASSERT_TRUE(InitDemuxer(true, true)); |
802 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); | 851 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); |
803 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 852 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
804 | 853 |
805 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); | 854 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); |
806 ASSERT_TRUE(AppendGarbage()); | 855 ASSERT_TRUE(AppendGarbage()); |
807 } | 856 } |
808 | 857 |
809 // Test the case where a Seek() is requested while the parser | 858 // Test the case where a Seek() is requested while the parser |
810 // is in the middle of cluster. This is to verify that the parser | 859 // is in the middle of cluster. This is to verify that the parser |
811 // does not reset itself on a seek. | 860 // does not reset itself on a seek. |
812 TEST_F(ChunkDemuxerTest, TestSeekWhileParsingCluster) { | 861 TEST_F(ChunkDemuxerTest, TestSeekWhileParsingCluster) { |
813 ASSERT_TRUE(InitDemuxer(true, true, false)); | 862 ASSERT_TRUE(InitDemuxer(true, true)); |
814 | 863 |
815 scoped_refptr<DemuxerStream> audio = | 864 scoped_refptr<DemuxerStream> audio = |
816 demuxer_->GetStream(DemuxerStream::AUDIO); | 865 demuxer_->GetStream(DemuxerStream::AUDIO); |
817 scoped_refptr<DemuxerStream> video = | 866 scoped_refptr<DemuxerStream> video = |
818 demuxer_->GetStream(DemuxerStream::VIDEO); | 867 demuxer_->GetStream(DemuxerStream::VIDEO); |
819 | 868 |
820 InSequence s; | 869 InSequence s; |
821 | 870 |
822 scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 6)); | 871 scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 6)); |
823 | 872 |
(...skipping 24 matching lines...) Expand all Loading... |
848 // in the new cluster are returned. | 897 // in the new cluster are returned. |
849 scoped_ptr<Cluster> cluster_b(GenerateCluster(5000, 6)); | 898 scoped_ptr<Cluster> cluster_b(GenerateCluster(5000, 6)); |
850 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); | 899 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); |
851 GenerateExpectedReads(5000, 6, audio, video); | 900 GenerateExpectedReads(5000, 6, audio, video); |
852 } | 901 } |
853 | 902 |
854 // Test the case where AppendData() is called before Init(). | 903 // Test the case where AppendData() is called before Init(). |
855 TEST_F(ChunkDemuxerTest, TestAppendDataBeforeInit) { | 904 TEST_F(ChunkDemuxerTest, TestAppendDataBeforeInit) { |
856 scoped_array<uint8> info_tracks; | 905 scoped_array<uint8> info_tracks; |
857 int info_tracks_size = 0; | 906 int info_tracks_size = 0; |
858 CreateInitSegment(true, true, false, &info_tracks, &info_tracks_size); | 907 CreateInitSegment(true, true, false, false, &info_tracks, &info_tracks_size); |
859 | 908 |
860 EXPECT_FALSE(demuxer_->AppendData(kSourceId, info_tracks.get(), | 909 EXPECT_FALSE(demuxer_->AppendData(kSourceId, info_tracks.get(), |
861 info_tracks_size)); | 910 info_tracks_size)); |
862 } | 911 } |
863 | 912 |
864 // Make sure Read() callbacks are dispatched with the proper data. | 913 // Make sure Read() callbacks are dispatched with the proper data. |
865 TEST_F(ChunkDemuxerTest, TestRead) { | 914 TEST_F(ChunkDemuxerTest, TestRead) { |
866 ASSERT_TRUE(InitDemuxer(true, true, false)); | 915 ASSERT_TRUE(InitDemuxer(true, true)); |
867 | 916 |
868 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); | 917 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); |
869 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 918 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
870 | 919 |
871 scoped_refptr<DemuxerStream> audio = | 920 scoped_refptr<DemuxerStream> audio = |
872 demuxer_->GetStream(DemuxerStream::AUDIO); | 921 demuxer_->GetStream(DemuxerStream::AUDIO); |
873 scoped_refptr<DemuxerStream> video = | 922 scoped_refptr<DemuxerStream> video = |
874 demuxer_->GetStream(DemuxerStream::VIDEO); | 923 demuxer_->GetStream(DemuxerStream::VIDEO); |
875 | 924 |
876 bool audio_read_done = false; | 925 bool audio_read_done = false; |
877 bool video_read_done = false; | 926 bool video_read_done = false; |
878 audio->Read(base::Bind(&OnReadDone, | 927 audio->Read(base::Bind(&OnReadDone, |
879 base::TimeDelta::FromMilliseconds(0), | 928 base::TimeDelta::FromMilliseconds(0), |
880 &audio_read_done)); | 929 &audio_read_done)); |
881 video->Read(base::Bind(&OnReadDone, | 930 video->Read(base::Bind(&OnReadDone, |
882 base::TimeDelta::FromMilliseconds(0), | 931 base::TimeDelta::FromMilliseconds(0), |
883 &video_read_done)); | 932 &video_read_done)); |
884 | 933 |
885 EXPECT_TRUE(audio_read_done); | 934 EXPECT_TRUE(audio_read_done); |
886 EXPECT_TRUE(video_read_done); | 935 EXPECT_TRUE(video_read_done); |
887 } | 936 } |
888 | 937 |
889 TEST_F(ChunkDemuxerTest, TestOutOfOrderClusters) { | 938 TEST_F(ChunkDemuxerTest, TestOutOfOrderClusters) { |
890 ASSERT_TRUE(InitDemuxer(true, true, false)); | 939 ASSERT_TRUE(InitDemuxer(true, true)); |
891 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); | 940 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); |
892 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 941 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
893 | 942 |
894 scoped_ptr<Cluster> cluster_a(GenerateCluster(10, 4)); | 943 scoped_ptr<Cluster> cluster_a(GenerateCluster(10, 4)); |
895 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 944 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
896 | 945 |
897 // Cluster B starts before cluster_a and has data | 946 // Cluster B starts before cluster_a and has data |
898 // that overlaps. | 947 // that overlaps. |
899 scoped_ptr<Cluster> cluster_b(GenerateCluster(5, 4)); | 948 scoped_ptr<Cluster> cluster_b(GenerateCluster(5, 4)); |
900 | 949 |
901 // Make sure that AppendData() does not fail. | 950 // Make sure that AppendData() does not fail. |
902 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); | 951 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); |
903 | 952 |
904 // Verify that AppendData() can still accept more data. | 953 // Verify that AppendData() can still accept more data. |
905 scoped_ptr<Cluster> cluster_c(GenerateCluster(45, 2)); | 954 scoped_ptr<Cluster> cluster_c(GenerateCluster(45, 2)); |
906 ASSERT_TRUE(demuxer_->AppendData(kSourceId, cluster_c->data(), | 955 ASSERT_TRUE(demuxer_->AppendData(kSourceId, cluster_c->data(), |
907 cluster_c->size())); | 956 cluster_c->size())); |
908 } | 957 } |
909 | 958 |
910 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) { | 959 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) { |
911 ASSERT_TRUE(InitDemuxer(true, true, false)); | 960 ASSERT_TRUE(InitDemuxer(true, true)); |
912 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); | 961 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); |
913 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 962 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
914 | 963 |
915 ClusterBuilder cb; | 964 ClusterBuilder cb; |
916 | 965 |
917 // Test the case where block timecodes are not monotonically | 966 // Test the case where block timecodes are not monotonically |
918 // increasing but stay above the cluster timecode. | 967 // increasing but stay above the cluster timecode. |
919 cb.SetClusterTimecode(5); | 968 cb.SetClusterTimecode(5); |
920 AddSimpleBlock(&cb, kAudioTrackNum, 5); | 969 AddSimpleBlock(&cb, kAudioTrackNum, 5); |
921 AddSimpleBlock(&cb, kVideoTrackNum, 10); | 970 AddSimpleBlock(&cb, kVideoTrackNum, 10); |
922 AddSimpleBlock(&cb, kAudioTrackNum, 7); | 971 AddSimpleBlock(&cb, kAudioTrackNum, 7); |
923 AddSimpleBlock(&cb, kVideoTrackNum, 15); | 972 AddSimpleBlock(&cb, kVideoTrackNum, 15); |
924 scoped_ptr<Cluster> cluster_a(cb.Finish()); | 973 scoped_ptr<Cluster> cluster_a(cb.Finish()); |
925 | 974 |
926 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); | 975 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); |
927 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 976 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
928 | 977 |
929 // Verify that AppendData() doesn't accept more data now. | 978 // Verify that AppendData() doesn't accept more data now. |
930 scoped_ptr<Cluster> cluster_b(GenerateCluster(20, 2)); | 979 scoped_ptr<Cluster> cluster_b(GenerateCluster(20, 2)); |
931 EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(), | 980 EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(), |
932 cluster_b->size())); | 981 cluster_b->size())); |
933 } | 982 } |
934 | 983 |
935 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) { | 984 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) { |
936 ASSERT_TRUE(InitDemuxer(true, true, false)); | 985 ASSERT_TRUE(InitDemuxer(true, true)); |
937 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); | 986 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); |
938 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 987 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
939 | 988 |
940 ClusterBuilder cb; | 989 ClusterBuilder cb; |
941 | 990 |
942 // Test timecodes going backwards and including values less than the cluster | 991 // Test timecodes going backwards and including values less than the cluster |
943 // timecode. | 992 // timecode. |
944 cb.SetClusterTimecode(5); | 993 cb.SetClusterTimecode(5); |
945 AddSimpleBlock(&cb, kAudioTrackNum, 5); | 994 AddSimpleBlock(&cb, kAudioTrackNum, 5); |
946 AddSimpleBlock(&cb, kVideoTrackNum, 5); | 995 AddSimpleBlock(&cb, kVideoTrackNum, 5); |
947 AddSimpleBlock(&cb, kAudioTrackNum, 3); | 996 AddSimpleBlock(&cb, kAudioTrackNum, 3); |
948 AddSimpleBlock(&cb, kVideoTrackNum, 3); | 997 AddSimpleBlock(&cb, kVideoTrackNum, 3); |
949 scoped_ptr<Cluster> cluster_a(cb.Finish()); | 998 scoped_ptr<Cluster> cluster_a(cb.Finish()); |
950 | 999 |
951 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); | 1000 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); |
952 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 1001 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
953 | 1002 |
954 // Verify that AppendData() doesn't accept more data now. | 1003 // Verify that AppendData() doesn't accept more data now. |
955 scoped_ptr<Cluster> cluster_b(GenerateCluster(6, 2)); | 1004 scoped_ptr<Cluster> cluster_b(GenerateCluster(6, 2)); |
956 EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(), | 1005 EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(), |
957 cluster_b->size())); | 1006 cluster_b->size())); |
958 } | 1007 } |
959 | 1008 |
960 | 1009 |
961 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) { | 1010 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) { |
962 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1011 ASSERT_TRUE(InitDemuxer(true, true)); |
963 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); | 1012 scoped_ptr<Cluster> first_cluster(kDefaultFirstCluster()); |
964 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 1013 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
965 | 1014 |
966 ClusterBuilder cb; | 1015 ClusterBuilder cb; |
967 | 1016 |
968 // Test monotonic increasing timestamps on a per stream | 1017 // Test monotonic increasing timestamps on a per stream |
969 // basis. | 1018 // basis. |
970 cb.SetClusterTimecode(5); | 1019 cb.SetClusterTimecode(5); |
971 AddSimpleBlock(&cb, kAudioTrackNum, 5); | 1020 AddSimpleBlock(&cb, kAudioTrackNum, 5); |
972 AddSimpleBlock(&cb, kVideoTrackNum, 5); | 1021 AddSimpleBlock(&cb, kVideoTrackNum, 5); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1009 | 1058 |
1010 CheckExpectedRanges("{ }"); | 1059 CheckExpectedRanges("{ }"); |
1011 demuxer_->EndOfStream(PIPELINE_OK); | 1060 demuxer_->EndOfStream(PIPELINE_OK); |
1012 ShutdownDemuxer(); | 1061 ShutdownDemuxer(); |
1013 CheckExpectedRanges("{ }"); | 1062 CheckExpectedRanges("{ }"); |
1014 demuxer_->RemoveId(kSourceId); | 1063 demuxer_->RemoveId(kSourceId); |
1015 demuxer_ = NULL; | 1064 demuxer_ = NULL; |
1016 } | 1065 } |
1017 | 1066 |
1018 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithNoMediaAppend) { | 1067 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithNoMediaAppend) { |
1019 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1068 ASSERT_TRUE(InitDemuxer(true, true)); |
1020 | 1069 |
1021 CheckExpectedRanges("{ }"); | 1070 CheckExpectedRanges("{ }"); |
1022 demuxer_->EndOfStream(PIPELINE_OK); | 1071 demuxer_->EndOfStream(PIPELINE_OK); |
1023 CheckExpectedRanges("{ }"); | 1072 CheckExpectedRanges("{ }"); |
1024 } | 1073 } |
1025 | 1074 |
1026 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) { | 1075 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) { |
1027 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1076 ASSERT_TRUE(InitDemuxer(true, true)); |
1028 | 1077 |
1029 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); | 1078 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); |
1030 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 1079 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
1031 CheckExpectedRanges(kDefaultFirstClusterRange); | 1080 CheckExpectedRanges(kDefaultFirstClusterRange); |
1032 | 1081 |
1033 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); | 1082 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE)); |
1034 demuxer_->EndOfStream(PIPELINE_ERROR_DECODE); | 1083 demuxer_->EndOfStream(PIPELINE_ERROR_DECODE); |
1035 CheckExpectedRanges(kDefaultFirstClusterRange); | 1084 CheckExpectedRanges(kDefaultFirstClusterRange); |
1036 } | 1085 } |
1037 | 1086 |
1038 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) { | 1087 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) { |
1039 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1088 ASSERT_TRUE(InitDemuxer(true, true)); |
1040 | 1089 |
1041 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); | 1090 scoped_ptr<Cluster> cluster(kDefaultFirstCluster()); |
1042 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 1091 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
1043 CheckExpectedRanges(kDefaultFirstClusterRange); | 1092 CheckExpectedRanges(kDefaultFirstClusterRange); |
1044 | 1093 |
1045 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK)); | 1094 EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK)); |
1046 demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK); | 1095 demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK); |
1047 } | 1096 } |
1048 | 1097 |
1049 // Helper class to reduce duplicate code when testing end of stream | 1098 // Helper class to reduce duplicate code when testing end of stream |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1093 scoped_refptr<Demuxer> demuxer_; | 1142 scoped_refptr<Demuxer> demuxer_; |
1094 bool audio_read_done_; | 1143 bool audio_read_done_; |
1095 bool video_read_done_; | 1144 bool video_read_done_; |
1096 | 1145 |
1097 DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper); | 1146 DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper); |
1098 }; | 1147 }; |
1099 | 1148 |
1100 // Make sure that all pending reads that we don't have media data for get an | 1149 // Make sure that all pending reads that we don't have media data for get an |
1101 // "end of stream" buffer when EndOfStream() is called. | 1150 // "end of stream" buffer when EndOfStream() is called. |
1102 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithPendingReads) { | 1151 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithPendingReads) { |
1103 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1152 ASSERT_TRUE(InitDemuxer(true, true)); |
1104 | 1153 |
1105 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); | 1154 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); |
1106 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 1155 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
1107 | 1156 |
1108 scoped_refptr<DemuxerStream> audio = | 1157 scoped_refptr<DemuxerStream> audio = |
1109 demuxer_->GetStream(DemuxerStream::AUDIO); | 1158 demuxer_->GetStream(DemuxerStream::AUDIO); |
1110 scoped_refptr<DemuxerStream> video = | 1159 scoped_refptr<DemuxerStream> video = |
1111 demuxer_->GetStream(DemuxerStream::VIDEO); | 1160 demuxer_->GetStream(DemuxerStream::VIDEO); |
1112 | 1161 |
1113 bool audio_read_done_1 = false; | 1162 bool audio_read_done_1 = false; |
(...skipping 21 matching lines...) Expand all Loading... |
1135 base::TimeDelta::FromMilliseconds(kVideoBlockDuration))); | 1184 base::TimeDelta::FromMilliseconds(kVideoBlockDuration))); |
1136 demuxer_->EndOfStream(PIPELINE_OK); | 1185 demuxer_->EndOfStream(PIPELINE_OK); |
1137 | 1186 |
1138 end_of_stream_helper_1.CheckIfReadDonesWereCalled(true); | 1187 end_of_stream_helper_1.CheckIfReadDonesWereCalled(true); |
1139 end_of_stream_helper_2.CheckIfReadDonesWereCalled(true); | 1188 end_of_stream_helper_2.CheckIfReadDonesWereCalled(true); |
1140 } | 1189 } |
1141 | 1190 |
1142 // Make sure that all Read() calls after we get an EndOfStream() | 1191 // Make sure that all Read() calls after we get an EndOfStream() |
1143 // call return an "end of stream" buffer. | 1192 // call return an "end of stream" buffer. |
1144 TEST_F(ChunkDemuxerTest, TestReadsAfterEndOfStream) { | 1193 TEST_F(ChunkDemuxerTest, TestReadsAfterEndOfStream) { |
1145 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1194 ASSERT_TRUE(InitDemuxer(true, true)); |
1146 | 1195 |
1147 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); | 1196 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); |
1148 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 1197 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
1149 | 1198 |
1150 scoped_refptr<DemuxerStream> audio = | 1199 scoped_refptr<DemuxerStream> audio = |
1151 demuxer_->GetStream(DemuxerStream::AUDIO); | 1200 demuxer_->GetStream(DemuxerStream::AUDIO); |
1152 scoped_refptr<DemuxerStream> video = | 1201 scoped_refptr<DemuxerStream> video = |
1153 demuxer_->GetStream(DemuxerStream::VIDEO); | 1202 demuxer_->GetStream(DemuxerStream::VIDEO); |
1154 | 1203 |
1155 bool audio_read_done_1 = false; | 1204 bool audio_read_done_1 = false; |
(...skipping 25 matching lines...) Expand all Loading... |
1181 // Request a few more reads and make sure we immediately get | 1230 // Request a few more reads and make sure we immediately get |
1182 // end of stream buffers. | 1231 // end of stream buffers. |
1183 end_of_stream_helper_2.RequestReads(); | 1232 end_of_stream_helper_2.RequestReads(); |
1184 end_of_stream_helper_2.CheckIfReadDonesWereCalled(true); | 1233 end_of_stream_helper_2.CheckIfReadDonesWereCalled(true); |
1185 | 1234 |
1186 end_of_stream_helper_3.RequestReads(); | 1235 end_of_stream_helper_3.RequestReads(); |
1187 end_of_stream_helper_3.CheckIfReadDonesWereCalled(true); | 1236 end_of_stream_helper_3.CheckIfReadDonesWereCalled(true); |
1188 } | 1237 } |
1189 | 1238 |
1190 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringCanceledSeek) { | 1239 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringCanceledSeek) { |
1191 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1240 ASSERT_TRUE(InitDemuxer(true, true)); |
1192 scoped_refptr<DemuxerStream> audio = | 1241 scoped_refptr<DemuxerStream> audio = |
1193 demuxer_->GetStream(DemuxerStream::AUDIO); | 1242 demuxer_->GetStream(DemuxerStream::AUDIO); |
1194 scoped_refptr<DemuxerStream> video = | 1243 scoped_refptr<DemuxerStream> video = |
1195 demuxer_->GetStream(DemuxerStream::VIDEO); | 1244 demuxer_->GetStream(DemuxerStream::VIDEO); |
1196 | 1245 |
1197 ASSERT_TRUE(AppendCluster(0, 10)); | 1246 ASSERT_TRUE(AppendCluster(0, 10)); |
1198 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(138))); | 1247 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(138))); |
1199 EXPECT_TRUE(demuxer_->EndOfStream(PIPELINE_OK)); | 1248 EXPECT_TRUE(demuxer_->EndOfStream(PIPELINE_OK)); |
1200 | 1249 |
1201 // Start the first seek. | 1250 // Start the first seek. |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1238 // Make sure AppendData() will accept elements that span multiple calls. | 1287 // Make sure AppendData() will accept elements that span multiple calls. |
1239 TEST_F(ChunkDemuxerTest, TestAppendingInPieces) { | 1288 TEST_F(ChunkDemuxerTest, TestAppendingInPieces) { |
1240 EXPECT_CALL(*this, DemuxerOpened()); | 1289 EXPECT_CALL(*this, DemuxerOpened()); |
1241 demuxer_->Initialize( | 1290 demuxer_->Initialize( |
1242 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); | 1291 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); |
1243 | 1292 |
1244 ASSERT_EQ(AddId(), ChunkDemuxer::kOk); | 1293 ASSERT_EQ(AddId(), ChunkDemuxer::kOk); |
1245 | 1294 |
1246 scoped_array<uint8> info_tracks; | 1295 scoped_array<uint8> info_tracks; |
1247 int info_tracks_size = 0; | 1296 int info_tracks_size = 0; |
1248 CreateInitSegment(true, true, false, &info_tracks, &info_tracks_size); | 1297 CreateInitSegment(true, true, false, false, &info_tracks, &info_tracks_size); |
1249 | 1298 |
1250 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); | 1299 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); |
1251 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); | 1300 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); |
1252 | 1301 |
1253 size_t buffer_size = info_tracks_size + cluster_a->size() + cluster_b->size(); | 1302 size_t buffer_size = info_tracks_size + cluster_a->size() + cluster_b->size(); |
1254 scoped_array<uint8> buffer(new uint8[buffer_size]); | 1303 scoped_array<uint8> buffer(new uint8[buffer_size]); |
1255 uint8* dst = buffer.get(); | 1304 uint8* dst = buffer.get(); |
1256 memcpy(dst, info_tracks.get(), info_tracks_size); | 1305 memcpy(dst, info_tracks.get(), info_tracks_size); |
1257 dst += info_tracks_size; | 1306 dst += info_tracks_size; |
1258 | 1307 |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1342 {100, 12}, | 1391 {100, 12}, |
1343 {kSkip, kSkip}, | 1392 {kSkip, kSkip}, |
1344 }; | 1393 }; |
1345 | 1394 |
1346 ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps, | 1395 ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps, |
1347 base::TimeDelta::FromMilliseconds(2767))); | 1396 base::TimeDelta::FromMilliseconds(2767))); |
1348 } | 1397 } |
1349 | 1398 |
1350 // Verify that we output buffers before the entire cluster has been parsed. | 1399 // Verify that we output buffers before the entire cluster has been parsed. |
1351 TEST_F(ChunkDemuxerTest, TestIncrementalClusterParsing) { | 1400 TEST_F(ChunkDemuxerTest, TestIncrementalClusterParsing) { |
1352 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1401 ASSERT_TRUE(InitDemuxer(true, true)); |
1353 ASSERT_TRUE(AppendEmptyCluster(0)); | 1402 ASSERT_TRUE(AppendEmptyCluster(0)); |
1354 | 1403 |
1355 scoped_ptr<Cluster> cluster(GenerateCluster(0, 6)); | 1404 scoped_ptr<Cluster> cluster(GenerateCluster(0, 6)); |
1356 scoped_refptr<DemuxerStream> audio = | 1405 scoped_refptr<DemuxerStream> audio = |
1357 demuxer_->GetStream(DemuxerStream::AUDIO); | 1406 demuxer_->GetStream(DemuxerStream::AUDIO); |
1358 scoped_refptr<DemuxerStream> video = | 1407 scoped_refptr<DemuxerStream> video = |
1359 demuxer_->GetStream(DemuxerStream::VIDEO); | 1408 demuxer_->GetStream(DemuxerStream::VIDEO); |
1360 | 1409 |
1361 bool audio_read_done = false; | 1410 bool audio_read_done = false; |
1362 bool video_read_done = false; | 1411 bool video_read_done = false; |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1429 EXPECT_CALL(*this, DemuxerOpened()); | 1478 EXPECT_CALL(*this, DemuxerOpened()); |
1430 demuxer_->Initialize( | 1479 demuxer_->Initialize( |
1431 &host_, CreateInitDoneCB(kNoTimestamp(), | 1480 &host_, CreateInitDoneCB(kNoTimestamp(), |
1432 DEMUXER_ERROR_COULD_NOT_OPEN)); | 1481 DEMUXER_ERROR_COULD_NOT_OPEN)); |
1433 | 1482 |
1434 std::vector<std::string> codecs(1); | 1483 std::vector<std::string> codecs(1); |
1435 codecs[0] = "vorbis"; | 1484 codecs[0] = "vorbis"; |
1436 ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs), | 1485 ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs), |
1437 ChunkDemuxer::kOk); | 1486 ChunkDemuxer::kOk); |
1438 | 1487 |
1439 ASSERT_TRUE(AppendInitSegment(true, true, false)); | 1488 ASSERT_TRUE(AppendInitSegment(true, true)); |
1440 } | 1489 } |
1441 | 1490 |
1442 TEST_F(ChunkDemuxerTest, TestAVHeadersWithVideoOnlyType) { | 1491 TEST_F(ChunkDemuxerTest, TestAVHeadersWithVideoOnlyType) { |
1443 EXPECT_CALL(*this, DemuxerOpened()); | 1492 EXPECT_CALL(*this, DemuxerOpened()); |
1444 demuxer_->Initialize( | 1493 demuxer_->Initialize( |
1445 &host_, CreateInitDoneCB(kNoTimestamp(), | 1494 &host_, CreateInitDoneCB(kNoTimestamp(), |
1446 DEMUXER_ERROR_COULD_NOT_OPEN)); | 1495 DEMUXER_ERROR_COULD_NOT_OPEN)); |
1447 | 1496 |
1448 std::vector<std::string> codecs(1); | 1497 std::vector<std::string> codecs(1); |
1449 codecs[0] = "vp8"; | 1498 codecs[0] = "vp8"; |
1450 ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs), | 1499 ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs), |
1451 ChunkDemuxer::kOk); | 1500 ChunkDemuxer::kOk); |
1452 | 1501 |
1453 ASSERT_TRUE(AppendInitSegment(true, true, false)); | 1502 ASSERT_TRUE(AppendInitSegment(true, true)); |
1454 } | 1503 } |
1455 | 1504 |
1456 TEST_F(ChunkDemuxerTest, TestMultipleHeaders) { | 1505 TEST_F(ChunkDemuxerTest, TestMultipleHeaders) { |
1457 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1506 ASSERT_TRUE(InitDemuxer(true, true)); |
1458 | 1507 |
1459 scoped_refptr<DemuxerStream> audio = | 1508 scoped_refptr<DemuxerStream> audio = |
1460 demuxer_->GetStream(DemuxerStream::AUDIO); | 1509 demuxer_->GetStream(DemuxerStream::AUDIO); |
1461 scoped_refptr<DemuxerStream> video = | 1510 scoped_refptr<DemuxerStream> video = |
1462 demuxer_->GetStream(DemuxerStream::VIDEO); | 1511 demuxer_->GetStream(DemuxerStream::VIDEO); |
1463 | 1512 |
1464 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); | 1513 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); |
1465 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 1514 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
1466 | 1515 |
1467 // Append another identical initialization segment. | 1516 // Append another identical initialization segment. |
1468 ASSERT_TRUE(AppendInitSegment(true, true, false)); | 1517 ASSERT_TRUE(AppendInitSegment(true, true)); |
1469 | 1518 |
1470 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); | 1519 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); |
1471 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); | 1520 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); |
1472 | 1521 |
1473 GenerateExpectedReads(0, 9, audio, video); | 1522 GenerateExpectedReads(0, 9, audio, video); |
1474 } | 1523 } |
1475 | 1524 |
1476 TEST_F(ChunkDemuxerTest, TestAddSeparateSourcesForAudioAndVideo) { | 1525 TEST_F(ChunkDemuxerTest, TestAddSeparateSourcesForAudioAndVideo) { |
1477 std::string audio_id = "audio1"; | 1526 std::string audio_id = "audio1"; |
1478 std::string video_id = "video1"; | 1527 std::string video_id = "video1"; |
(...skipping 23 matching lines...) Expand all Loading... |
1502 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); | 1551 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); |
1503 | 1552 |
1504 std::string audio_id = "audio1"; | 1553 std::string audio_id = "audio1"; |
1505 std::string video_id = "video1"; | 1554 std::string video_id = "video1"; |
1506 | 1555 |
1507 ASSERT_EQ(AddId(audio_id, true, false), ChunkDemuxer::kOk); | 1556 ASSERT_EQ(AddId(audio_id, true, false), ChunkDemuxer::kOk); |
1508 | 1557 |
1509 // Adding an id with audio/video should fail because we already added audio. | 1558 // Adding an id with audio/video should fail because we already added audio. |
1510 ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit); | 1559 ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit); |
1511 | 1560 |
1512 ASSERT_TRUE(AppendInitSegment(audio_id, true, false, false)); | 1561 ASSERT_TRUE(AppendInitSegmentWithSourceId(audio_id, true, false)); |
1513 | 1562 |
1514 // Adding an id after append should fail. | 1563 // Adding an id after append should fail. |
1515 ASSERT_EQ(AddId(video_id, false, true), ChunkDemuxer::kReachedIdLimit); | 1564 ASSERT_EQ(AddId(video_id, false, true), ChunkDemuxer::kReachedIdLimit); |
1516 } | 1565 } |
1517 | 1566 |
1518 // Test that Read() calls after a RemoveId() return "end of stream" buffers. | 1567 // Test that Read() calls after a RemoveId() return "end of stream" buffers. |
1519 TEST_F(ChunkDemuxerTest, TestRemoveId) { | 1568 TEST_F(ChunkDemuxerTest, TestRemoveId) { |
1520 std::string audio_id = "audio1"; | 1569 std::string audio_id = "audio1"; |
1521 std::string video_id = "video1"; | 1570 std::string video_id = "video1"; |
1522 ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id)); | 1571 ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id)); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1556 TEST_F(ChunkDemuxerTest, TestRemoveAndAddId) { | 1605 TEST_F(ChunkDemuxerTest, TestRemoveAndAddId) { |
1557 std::string audio_id_1 = "audio1"; | 1606 std::string audio_id_1 = "audio1"; |
1558 ASSERT_TRUE(AddId(audio_id_1, true, false) == ChunkDemuxer::kOk); | 1607 ASSERT_TRUE(AddId(audio_id_1, true, false) == ChunkDemuxer::kOk); |
1559 demuxer_->RemoveId(audio_id_1); | 1608 demuxer_->RemoveId(audio_id_1); |
1560 | 1609 |
1561 std::string audio_id_2 = "audio2"; | 1610 std::string audio_id_2 = "audio2"; |
1562 ASSERT_TRUE(AddId(audio_id_2, true, false) == ChunkDemuxer::kOk); | 1611 ASSERT_TRUE(AddId(audio_id_2, true, false) == ChunkDemuxer::kOk); |
1563 } | 1612 } |
1564 | 1613 |
1565 TEST_F(ChunkDemuxerTest, TestSeekCanceled) { | 1614 TEST_F(ChunkDemuxerTest, TestSeekCanceled) { |
1566 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1615 ASSERT_TRUE(InitDemuxer(true, true)); |
1567 | 1616 |
1568 scoped_refptr<DemuxerStream> audio = | 1617 scoped_refptr<DemuxerStream> audio = |
1569 demuxer_->GetStream(DemuxerStream::AUDIO); | 1618 demuxer_->GetStream(DemuxerStream::AUDIO); |
1570 scoped_refptr<DemuxerStream> video = | 1619 scoped_refptr<DemuxerStream> video = |
1571 demuxer_->GetStream(DemuxerStream::VIDEO); | 1620 demuxer_->GetStream(DemuxerStream::VIDEO); |
1572 | 1621 |
1573 // Append cluster at the beginning of the stream. | 1622 // Append cluster at the beginning of the stream. |
1574 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4)); | 1623 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4)); |
1575 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); | 1624 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); |
1576 | 1625 |
(...skipping 17 matching lines...) Expand all Loading... |
1594 EXPECT_TRUE(video_read_done); | 1643 EXPECT_TRUE(video_read_done); |
1595 | 1644 |
1596 // A seek back to the buffered region should succeed. | 1645 // A seek back to the buffered region should succeed. |
1597 demuxer_->StartWaitingForSeek(); | 1646 demuxer_->StartWaitingForSeek(); |
1598 demuxer_->Seek(base::TimeDelta::FromSeconds(0), | 1647 demuxer_->Seek(base::TimeDelta::FromSeconds(0), |
1599 NewExpectedStatusCB(PIPELINE_OK)); | 1648 NewExpectedStatusCB(PIPELINE_OK)); |
1600 GenerateExpectedReads(0, 4, audio, video); | 1649 GenerateExpectedReads(0, 4, audio, video); |
1601 } | 1650 } |
1602 | 1651 |
1603 TEST_F(ChunkDemuxerTest, TestSeekCanceledWhileWaitingForSeek) { | 1652 TEST_F(ChunkDemuxerTest, TestSeekCanceledWhileWaitingForSeek) { |
1604 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1653 ASSERT_TRUE(InitDemuxer(true, true)); |
1605 | 1654 |
1606 scoped_refptr<DemuxerStream> audio = | 1655 scoped_refptr<DemuxerStream> audio = |
1607 demuxer_->GetStream(DemuxerStream::AUDIO); | 1656 demuxer_->GetStream(DemuxerStream::AUDIO); |
1608 scoped_refptr<DemuxerStream> video = | 1657 scoped_refptr<DemuxerStream> video = |
1609 demuxer_->GetStream(DemuxerStream::VIDEO); | 1658 demuxer_->GetStream(DemuxerStream::VIDEO); |
1610 | 1659 |
1611 // Append cluster at the beginning of the stream. | 1660 // Append cluster at the beginning of the stream. |
1612 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4)); | 1661 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 4)); |
1613 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); | 1662 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); |
1614 | 1663 |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1701 EXPECT_TRUE(video_read_done); | 1750 EXPECT_TRUE(video_read_done); |
1702 } | 1751 } |
1703 | 1752 |
1704 // Test ranges in an audio-only stream. | 1753 // Test ranges in an audio-only stream. |
1705 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) { | 1754 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) { |
1706 EXPECT_CALL(*this, DemuxerOpened()); | 1755 EXPECT_CALL(*this, DemuxerOpened()); |
1707 demuxer_->Initialize( | 1756 demuxer_->Initialize( |
1708 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); | 1757 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); |
1709 | 1758 |
1710 ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk); | 1759 ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk); |
1711 ASSERT_TRUE(AppendInitSegment(true, false, false)); | 1760 ASSERT_TRUE(AppendInitSegment(true, false)); |
1712 | 1761 |
1713 // Test a simple cluster. | 1762 // Test a simple cluster. |
1714 scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 92, | 1763 scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 92, |
1715 kAudioTrackNum, kAudioBlockDuration)); | 1764 kAudioTrackNum, kAudioBlockDuration)); |
1716 ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size())); | 1765 ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size())); |
1717 | 1766 |
1718 CheckExpectedRanges("{ [0,92) }"); | 1767 CheckExpectedRanges("{ [0,92) }"); |
1719 | 1768 |
1720 // Append a disjoint cluster to check for two separate ranges. | 1769 // Append a disjoint cluster to check for two separate ranges. |
1721 scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 219, | 1770 scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 219, |
1722 kAudioTrackNum, kAudioBlockDuration)); | 1771 kAudioTrackNum, kAudioBlockDuration)); |
1723 | 1772 |
1724 ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size())); | 1773 ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size())); |
1725 | 1774 |
1726 CheckExpectedRanges("{ [0,92) [150,219) }"); | 1775 CheckExpectedRanges("{ [0,92) [150,219) }"); |
1727 } | 1776 } |
1728 | 1777 |
1729 // Test ranges in a video-only stream. | 1778 // Test ranges in a video-only stream. |
1730 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) { | 1779 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) { |
1731 EXPECT_CALL(*this, DemuxerOpened()); | 1780 EXPECT_CALL(*this, DemuxerOpened()); |
1732 demuxer_->Initialize( | 1781 demuxer_->Initialize( |
1733 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); | 1782 &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK)); |
1734 | 1783 |
1735 ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk); | 1784 ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk); |
1736 ASSERT_TRUE(AppendInitSegment(false, true, false)); | 1785 ASSERT_TRUE(AppendInitSegment(false, true)); |
1737 | 1786 |
1738 // Test a simple cluster. | 1787 // Test a simple cluster. |
1739 scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 132, | 1788 scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 132, |
1740 kVideoTrackNum, kVideoBlockDuration)); | 1789 kVideoTrackNum, kVideoBlockDuration)); |
1741 | 1790 |
1742 ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size())); | 1791 ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size())); |
1743 | 1792 |
1744 CheckExpectedRanges("{ [0,132) }"); | 1793 CheckExpectedRanges("{ [0,132) }"); |
1745 | 1794 |
1746 // Append a disjoint cluster to check for two separate ranges. | 1795 // Append a disjoint cluster to check for two separate ranges. |
1747 scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(200, 299, | 1796 scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(200, 299, |
1748 kVideoTrackNum, kVideoBlockDuration)); | 1797 kVideoTrackNum, kVideoBlockDuration)); |
1749 | 1798 |
1750 ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size())); | 1799 ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size())); |
1751 | 1800 |
1752 CheckExpectedRanges("{ [0,132) [200,299) }"); | 1801 CheckExpectedRanges("{ [0,132) [200,299) }"); |
1753 } | 1802 } |
1754 | 1803 |
1755 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) { | 1804 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) { |
1756 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1805 ASSERT_TRUE(InitDemuxer(true, true)); |
1757 | 1806 |
1758 // Audio: 0 -> 23 | 1807 // Audio: 0 -> 23 |
1759 // Video: 0 -> 33 | 1808 // Video: 0 -> 33 |
1760 // Buffered Range: 0 -> 23 | 1809 // Buffered Range: 0 -> 23 |
1761 // Audio block duration is smaller than video block duration, | 1810 // Audio block duration is smaller than video block duration, |
1762 // so the buffered ranges should correspond to the audio blocks. | 1811 // so the buffered ranges should correspond to the audio blocks. |
1763 scoped_ptr<Cluster> cluster_a0( | 1812 scoped_ptr<Cluster> cluster_a0( |
1764 GenerateSingleStreamCluster(0, kAudioBlockDuration, kAudioTrackNum, | 1813 GenerateSingleStreamCluster(0, kAudioBlockDuration, kAudioTrackNum, |
1765 kAudioBlockDuration)); | 1814 kAudioBlockDuration)); |
1766 | 1815 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1840 scoped_ptr<Cluster> cluster_v5( | 1889 scoped_ptr<Cluster> cluster_v5( |
1841 GenerateSingleStreamCluster(1230, 1240, kVideoTrackNum, 10)); | 1890 GenerateSingleStreamCluster(1230, 1240, kVideoTrackNum, 10)); |
1842 ASSERT_TRUE(AppendData(cluster_v5->data(), cluster_v5->size())); | 1891 ASSERT_TRUE(AppendData(cluster_v5->data(), cluster_v5->size())); |
1843 CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); | 1892 CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); |
1844 } | 1893 } |
1845 | 1894 |
1846 // Once EndOfStream() is called, GetBufferedRanges should not cut off any | 1895 // Once EndOfStream() is called, GetBufferedRanges should not cut off any |
1847 // over-hanging tails at the end of the ranges as this is likely due to block | 1896 // over-hanging tails at the end of the ranges as this is likely due to block |
1848 // duration differences. | 1897 // duration differences. |
1849 TEST_F(ChunkDemuxerTest, GetBufferedRanges_EndOfStream) { | 1898 TEST_F(ChunkDemuxerTest, GetBufferedRanges_EndOfStream) { |
1850 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1899 ASSERT_TRUE(InitDemuxer(true, true)); |
1851 | 1900 |
1852 scoped_ptr<Cluster> cluster_a( | 1901 scoped_ptr<Cluster> cluster_a( |
1853 GenerateSingleStreamCluster(0, 90, kAudioTrackNum, 90)); | 1902 GenerateSingleStreamCluster(0, 90, kAudioTrackNum, 90)); |
1854 scoped_ptr<Cluster> cluster_v( | 1903 scoped_ptr<Cluster> cluster_v( |
1855 GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 100)); | 1904 GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 100)); |
1856 | 1905 |
1857 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 1906 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
1858 ASSERT_TRUE(AppendData(cluster_v->data(), cluster_v->size())); | 1907 ASSERT_TRUE(AppendData(cluster_v->data(), cluster_v->size())); |
1859 | 1908 |
1860 CheckExpectedRanges("{ [0,90) }"); | 1909 CheckExpectedRanges("{ [0,90) }"); |
1861 | 1910 |
1862 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(100))); | 1911 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(100))); |
1863 demuxer_->EndOfStream(PIPELINE_OK); | 1912 demuxer_->EndOfStream(PIPELINE_OK); |
1864 | 1913 |
1865 CheckExpectedRanges("{ [0,100) }"); | 1914 CheckExpectedRanges("{ [0,100) }"); |
1866 } | 1915 } |
1867 | 1916 |
1868 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) { | 1917 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) { |
1869 ASSERT_TRUE(InitDemuxer(true, true, false)); | 1918 ASSERT_TRUE(InitDemuxer(true, true)); |
1870 | 1919 |
1871 scoped_refptr<DemuxerStream> audio = | 1920 scoped_refptr<DemuxerStream> audio = |
1872 demuxer_->GetStream(DemuxerStream::AUDIO); | 1921 demuxer_->GetStream(DemuxerStream::AUDIO); |
1873 scoped_refptr<DemuxerStream> video = | 1922 scoped_refptr<DemuxerStream> video = |
1874 demuxer_->GetStream(DemuxerStream::VIDEO); | 1923 demuxer_->GetStream(DemuxerStream::VIDEO); |
1875 | 1924 |
1876 // Create a cluster where the video timecode begins 25ms after the audio. | 1925 // Create a cluster where the video timecode begins 25ms after the audio. |
1877 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 25, 8)); | 1926 scoped_ptr<Cluster> start_cluster(GenerateCluster(0, 25, 8)); |
1878 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); | 1927 ASSERT_TRUE(AppendData(start_cluster->data(), start_cluster->size())); |
1879 | 1928 |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1943 ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size())); | 1992 ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size())); |
1944 | 1993 |
1945 // Should not be able to fulfill a seek to 0. | 1994 // Should not be able to fulfill a seek to 0. |
1946 demuxer_->Seek(base::TimeDelta::FromMilliseconds(0), | 1995 demuxer_->Seek(base::TimeDelta::FromMilliseconds(0), |
1947 NewExpectedStatusCB(PIPELINE_ERROR_ABORT)); | 1996 NewExpectedStatusCB(PIPELINE_ERROR_ABORT)); |
1948 ExpectRead(audio, 0); | 1997 ExpectRead(audio, 0); |
1949 ExpectEndOfStream(video); | 1998 ExpectEndOfStream(video); |
1950 } | 1999 } |
1951 | 2000 |
1952 TEST_F(ChunkDemuxerTest, TestClusterWithNoBuffers) { | 2001 TEST_F(ChunkDemuxerTest, TestClusterWithNoBuffers) { |
1953 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2002 ASSERT_TRUE(InitDemuxer(true, true)); |
1954 | 2003 |
1955 // Generate and append an empty cluster beginning at 0. | 2004 // Generate and append an empty cluster beginning at 0. |
1956 ASSERT_TRUE(AppendEmptyCluster(0)); | 2005 ASSERT_TRUE(AppendEmptyCluster(0)); |
1957 | 2006 |
1958 // Sanity check that data can be appended after this cluster correctly. | 2007 // Sanity check that data can be appended after this cluster correctly. |
1959 scoped_ptr<Cluster> media_data(GenerateCluster(0, 2)); | 2008 scoped_ptr<Cluster> media_data(GenerateCluster(0, 2)); |
1960 ASSERT_TRUE(AppendData(media_data->data(), media_data->size())); | 2009 ASSERT_TRUE(AppendData(media_data->data(), media_data->size())); |
1961 scoped_refptr<DemuxerStream> audio = | 2010 scoped_refptr<DemuxerStream> audio = |
1962 demuxer_->GetStream(DemuxerStream::AUDIO); | 2011 demuxer_->GetStream(DemuxerStream::AUDIO); |
1963 scoped_refptr<DemuxerStream> video = | 2012 scoped_refptr<DemuxerStream> video = |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2039 | 2088 |
2040 CheckExpectedRanges("audio", "{ }"); | 2089 CheckExpectedRanges("audio", "{ }"); |
2041 CheckExpectedRanges("video", "{ }"); | 2090 CheckExpectedRanges("video", "{ }"); |
2042 } | 2091 } |
2043 | 2092 |
2044 // Test that Seek() completes successfully when the first cluster | 2093 // Test that Seek() completes successfully when the first cluster |
2045 // arrives. | 2094 // arrives. |
2046 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringSeek) { | 2095 TEST_F(ChunkDemuxerTest, TestEndOfStreamDuringSeek) { |
2047 InSequence s; | 2096 InSequence s; |
2048 | 2097 |
2049 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2098 ASSERT_TRUE(InitDemuxer(true, true)); |
2050 | 2099 |
2051 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); | 2100 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); |
2052 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); | 2101 scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster()); |
2053 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 2102 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
2054 | 2103 |
2055 demuxer_->StartWaitingForSeek(); | 2104 demuxer_->StartWaitingForSeek(); |
2056 | 2105 |
2057 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); | 2106 ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size())); |
2058 EXPECT_CALL(host_, SetDuration( | 2107 EXPECT_CALL(host_, SetDuration( |
2059 base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp))); | 2108 base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp))); |
(...skipping 155 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2215 NewExpectedStatusCB(PIPELINE_OK)); | 2264 NewExpectedStatusCB(PIPELINE_OK)); |
2216 demuxer_->Seek(base::TimeDelta::FromMilliseconds(801), | 2265 demuxer_->Seek(base::TimeDelta::FromMilliseconds(801), |
2217 NewExpectedStatusCB(PIPELINE_OK)); | 2266 NewExpectedStatusCB(PIPELINE_OK)); |
2218 | 2267 |
2219 // Verify that no config change is signalled. | 2268 // Verify that no config change is signalled. |
2220 ExpectRead(stream, 801); | 2269 ExpectRead(stream, 801); |
2221 ASSERT_TRUE(video_config_1.Matches(stream->video_decoder_config())); | 2270 ASSERT_TRUE(video_config_1.Matches(stream->video_decoder_config())); |
2222 } | 2271 } |
2223 | 2272 |
2224 TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) { | 2273 TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) { |
2225 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2274 ASSERT_TRUE(InitDemuxer(true, true)); |
2226 | 2275 |
2227 ASSERT_TRUE(demuxer_->SetTimestampOffset( | 2276 ASSERT_TRUE(demuxer_->SetTimestampOffset( |
2228 kSourceId, base::TimeDelta::FromSeconds(30))); | 2277 kSourceId, base::TimeDelta::FromSeconds(30))); |
2229 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); | 2278 scoped_ptr<Cluster> cluster(GenerateCluster(0, 2)); |
2230 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 2279 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
2231 | 2280 |
2232 demuxer_->StartWaitingForSeek(); | 2281 demuxer_->StartWaitingForSeek(); |
2233 demuxer_->Seek(base::TimeDelta::FromMilliseconds(30000), | 2282 demuxer_->Seek(base::TimeDelta::FromMilliseconds(30000), |
2234 NewExpectedStatusCB(PIPELINE_OK)); | 2283 NewExpectedStatusCB(PIPELINE_OK)); |
2235 | 2284 |
2236 scoped_refptr<DemuxerStream> audio = | 2285 scoped_refptr<DemuxerStream> audio = |
2237 demuxer_->GetStream(DemuxerStream::AUDIO); | 2286 demuxer_->GetStream(DemuxerStream::AUDIO); |
2238 scoped_refptr<DemuxerStream> video = | 2287 scoped_refptr<DemuxerStream> video = |
2239 demuxer_->GetStream(DemuxerStream::VIDEO); | 2288 demuxer_->GetStream(DemuxerStream::VIDEO); |
2240 GenerateExpectedReads(30000, 2, audio, video); | 2289 GenerateExpectedReads(30000, 2, audio, video); |
2241 } | 2290 } |
2242 | 2291 |
2243 TEST_F(ChunkDemuxerTest, TestTimestampNegativeOffset) { | 2292 TEST_F(ChunkDemuxerTest, TestTimestampNegativeOffset) { |
2244 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2293 ASSERT_TRUE(InitDemuxer(true, true)); |
2245 | 2294 |
2246 ASSERT_TRUE(demuxer_->SetTimestampOffset( | 2295 ASSERT_TRUE(demuxer_->SetTimestampOffset( |
2247 kSourceId, base::TimeDelta::FromSeconds(-1))); | 2296 kSourceId, base::TimeDelta::FromSeconds(-1))); |
2248 scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2); | 2297 scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2); |
2249 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 2298 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
2250 | 2299 |
2251 scoped_refptr<DemuxerStream> audio = | 2300 scoped_refptr<DemuxerStream> audio = |
2252 demuxer_->GetStream(DemuxerStream::AUDIO); | 2301 demuxer_->GetStream(DemuxerStream::AUDIO); |
2253 scoped_refptr<DemuxerStream> video = | 2302 scoped_refptr<DemuxerStream> video = |
2254 demuxer_->GetStream(DemuxerStream::VIDEO); | 2303 demuxer_->GetStream(DemuxerStream::VIDEO); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2300 audio_id, base::TimeDelta::FromMilliseconds(27300))); | 2349 audio_id, base::TimeDelta::FromMilliseconds(27300))); |
2301 ASSERT_TRUE(demuxer_->SetTimestampOffset( | 2350 ASSERT_TRUE(demuxer_->SetTimestampOffset( |
2302 video_id, base::TimeDelta::FromMilliseconds(27300))); | 2351 video_id, base::TimeDelta::FromMilliseconds(27300))); |
2303 ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size())); | 2352 ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size())); |
2304 ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size())); | 2353 ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size())); |
2305 GenerateSingleStreamExpectedReads(27300, 4, video, kVideoBlockDuration); | 2354 GenerateSingleStreamExpectedReads(27300, 4, video, kVideoBlockDuration); |
2306 GenerateSingleStreamExpectedReads(27300, 4, audio, kAudioBlockDuration); | 2355 GenerateSingleStreamExpectedReads(27300, 4, audio, kAudioBlockDuration); |
2307 } | 2356 } |
2308 | 2357 |
2309 TEST_F(ChunkDemuxerTest, TestTimestampOffsetMidParse) { | 2358 TEST_F(ChunkDemuxerTest, TestTimestampOffsetMidParse) { |
2310 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2359 ASSERT_TRUE(InitDemuxer(true, true)); |
2311 | 2360 |
2312 scoped_ptr<Cluster> cluster = GenerateCluster(0, 2); | 2361 scoped_ptr<Cluster> cluster = GenerateCluster(0, 2); |
2313 // Append only part of the cluster data. | 2362 // Append only part of the cluster data. |
2314 ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13)); | 2363 ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13)); |
2315 | 2364 |
2316 // Setting a timestamp should fail because we're in the middle of a cluster. | 2365 // Setting a timestamp should fail because we're in the middle of a cluster. |
2317 ASSERT_FALSE(demuxer_->SetTimestampOffset( | 2366 ASSERT_FALSE(demuxer_->SetTimestampOffset( |
2318 kSourceId, base::TimeDelta::FromSeconds(25))); | 2367 kSourceId, base::TimeDelta::FromSeconds(25))); |
2319 | 2368 |
2320 demuxer_->Abort(kSourceId); | 2369 demuxer_->Abort(kSourceId); |
2321 // After Abort(), setting a timestamp should succeed since we're no longer | 2370 // After Abort(), setting a timestamp should succeed since we're no longer |
2322 // in the middle of a cluster | 2371 // in the middle of a cluster |
2323 ASSERT_TRUE(demuxer_->SetTimestampOffset( | 2372 ASSERT_TRUE(demuxer_->SetTimestampOffset( |
2324 kSourceId, base::TimeDelta::FromSeconds(25))); | 2373 kSourceId, base::TimeDelta::FromSeconds(25))); |
2325 } | 2374 } |
2326 | 2375 |
2327 TEST_F(ChunkDemuxerTest, TestDurationChange) { | 2376 TEST_F(ChunkDemuxerTest, TestDurationChange) { |
2328 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2377 ASSERT_TRUE(InitDemuxer(true, true)); |
2329 static const int kStreamDuration = kDefaultDuration().InMilliseconds(); | 2378 static const int kStreamDuration = kDefaultDuration().InMilliseconds(); |
2330 | 2379 |
2331 // Add data leading up to the currently set duration. | 2380 // Add data leading up to the currently set duration. |
2332 scoped_ptr<Cluster> first_cluster = GenerateCluster( | 2381 scoped_ptr<Cluster> first_cluster = GenerateCluster( |
2333 kStreamDuration - kAudioBlockDuration, | 2382 kStreamDuration - kAudioBlockDuration, |
2334 kStreamDuration - kVideoBlockDuration, 2); | 2383 kStreamDuration - kVideoBlockDuration, 2); |
2335 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); | 2384 ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size())); |
2336 | 2385 |
2337 CheckExpectedRanges(kSourceId, "{ [201191,201224) }"); | 2386 CheckExpectedRanges(kSourceId, "{ [201191,201224) }"); |
2338 | 2387 |
(...skipping 13 matching lines...) Expand all Loading... |
2352 kStreamDuration + kVideoBlockDuration, 2); | 2401 kStreamDuration + kVideoBlockDuration, 2); |
2353 EXPECT_CALL(host_, SetDuration( | 2402 EXPECT_CALL(host_, SetDuration( |
2354 base::TimeDelta::FromMilliseconds(kNewStreamDuration))); | 2403 base::TimeDelta::FromMilliseconds(kNewStreamDuration))); |
2355 ASSERT_TRUE(AppendData(third_cluster->data(), third_cluster->size())); | 2404 ASSERT_TRUE(AppendData(third_cluster->data(), third_cluster->size())); |
2356 | 2405 |
2357 // See that the range has increased appropriately. | 2406 // See that the range has increased appropriately. |
2358 CheckExpectedRanges(kSourceId, "{ [201191,201270) }"); | 2407 CheckExpectedRanges(kSourceId, "{ [201191,201270) }"); |
2359 } | 2408 } |
2360 | 2409 |
2361 TEST_F(ChunkDemuxerTest, TestDurationChangeTimestampOffset) { | 2410 TEST_F(ChunkDemuxerTest, TestDurationChangeTimestampOffset) { |
2362 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2411 ASSERT_TRUE(InitDemuxer(true, true)); |
2363 | 2412 |
2364 ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, kDefaultDuration())); | 2413 ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, kDefaultDuration())); |
2365 scoped_ptr<Cluster> cluster = GenerateCluster(0, 4); | 2414 scoped_ptr<Cluster> cluster = GenerateCluster(0, 4); |
2366 | 2415 |
2367 EXPECT_CALL(host_, SetDuration( | 2416 EXPECT_CALL(host_, SetDuration( |
2368 kDefaultDuration() + base::TimeDelta::FromMilliseconds( | 2417 kDefaultDuration() + base::TimeDelta::FromMilliseconds( |
2369 kAudioBlockDuration * 2))); | 2418 kAudioBlockDuration * 2))); |
2370 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); | 2419 ASSERT_TRUE(AppendData(cluster->data(), cluster->size())); |
2371 } | 2420 } |
2372 | 2421 |
2373 TEST_F(ChunkDemuxerTest, TestEndOfStreamTruncateDuration) { | 2422 TEST_F(ChunkDemuxerTest, TestEndOfStreamTruncateDuration) { |
2374 ASSERT_TRUE(InitDemuxer(true, true, false)); | 2423 ASSERT_TRUE(InitDemuxer(true, true)); |
2375 | 2424 |
2376 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); | 2425 scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster()); |
2377 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); | 2426 ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size())); |
2378 | 2427 |
2379 EXPECT_CALL(host_, SetDuration( | 2428 EXPECT_CALL(host_, SetDuration( |
2380 base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp))); | 2429 base::TimeDelta::FromMilliseconds(kDefaultFirstClusterEndTimestamp))); |
2381 demuxer_->EndOfStream(PIPELINE_OK); | 2430 demuxer_->EndOfStream(PIPELINE_OK); |
2382 } | 2431 } |
2383 | 2432 |
2384 } // namespace media | 2433 } // namespace media |
OLD | NEW |