Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(81)

Side by Side Diff: media/filters/chunk_demuxer_unittest.cc

Issue 17408005: Refactored DecoderBuffer to use unix_hacker_style naming. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@localrefactor
Patch Set: Fixed naming error that somehow got reverted" Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 <algorithm> 5 #include <algorithm>
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/message_loop.h" 8 #include "base/message_loop.h"
9 #include "media/base/audio_decoder_config.h" 9 #include "media/base/audio_decoder_config.h"
10 #include "media/base/decoder_buffer.h" 10 #include "media/base/decoder_buffer.h"
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
81 DCHECK(number >= 0 && number < GG_LONGLONG(0x00FFFFFFFFFFFFFF)); 81 DCHECK(number >= 0 && number < GG_LONGLONG(0x00FFFFFFFFFFFFFF));
82 buffer[0] = 0x01; 82 buffer[0] = 0x01;
83 int64 tmp = number; 83 int64 tmp = number;
84 for (int i = 7; i > 0; i--) { 84 for (int i = 7; i > 0; i--) {
85 buffer[i] = tmp & 0xff; 85 buffer[i] = tmp & 0xff;
86 tmp >>= 8; 86 tmp >>= 8;
87 } 87 }
88 } 88 }
89 89
90 MATCHER_P(HasTimestamp, timestamp_in_ms, "") { 90 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
91 return arg.get() && !arg->IsEndOfStream() && 91 return arg.get() && !arg->end_of_stream() &&
92 arg->GetTimestamp().InMilliseconds() == timestamp_in_ms; 92 arg->timestamp().InMilliseconds() == timestamp_in_ms;
93 } 93 }
94 94
95 MATCHER(IsEndOfStream, "") { return arg.get() && arg->IsEndOfStream(); } 95 MATCHER(IsEndOfStream, "") { return arg.get() && arg->end_of_stream(); }
96 96
97 static void OnReadDone(const base::TimeDelta& expected_time, 97 static void OnReadDone(const base::TimeDelta& expected_time,
98 bool* called, 98 bool* called,
99 DemuxerStream::Status status, 99 DemuxerStream::Status status,
100 const scoped_refptr<DecoderBuffer>& buffer) { 100 const scoped_refptr<DecoderBuffer>& buffer) {
101 EXPECT_EQ(status, DemuxerStream::kOk); 101 EXPECT_EQ(status, DemuxerStream::kOk);
102 EXPECT_EQ(expected_time, buffer->GetTimestamp()); 102 EXPECT_EQ(expected_time, buffer->timestamp());
103 *called = true; 103 *called = true;
104 } 104 }
105 105
106 static void OnReadDone_AbortExpected( 106 static void OnReadDone_AbortExpected(
107 bool* called, DemuxerStream::Status status, 107 bool* called, DemuxerStream::Status status,
108 const scoped_refptr<DecoderBuffer>& buffer) { 108 const scoped_refptr<DecoderBuffer>& buffer) {
109 EXPECT_EQ(status, DemuxerStream::kAborted); 109 EXPECT_EQ(status, DemuxerStream::kAborted);
110 EXPECT_EQ(NULL, buffer.get()); 110 EXPECT_EQ(NULL, buffer.get());
111 *called = true; 111 *called = true;
112 } 112 }
113 113
114 static void OnReadDone_EOSExpected(bool* called, 114 static void OnReadDone_EOSExpected(bool* called,
115 DemuxerStream::Status status, 115 DemuxerStream::Status status,
116 const scoped_refptr<DecoderBuffer>& buffer) { 116 const scoped_refptr<DecoderBuffer>& buffer) {
117 EXPECT_EQ(status, DemuxerStream::kOk); 117 EXPECT_EQ(status, DemuxerStream::kOk);
118 EXPECT_TRUE(buffer->IsEndOfStream()); 118 EXPECT_TRUE(buffer->end_of_stream());
119 *called = true; 119 *called = true;
120 } 120 }
121 121
122 static void OnSeekDone_OKExpected(bool* called, PipelineStatus status) { 122 static void OnSeekDone_OKExpected(bool* called, PipelineStatus status) {
123 EXPECT_EQ(status, PIPELINE_OK); 123 EXPECT_EQ(status, PIPELINE_OK);
124 *called = true; 124 *called = true;
125 } 125 }
126 126
127 class ChunkDemuxerTest : public testing::Test { 127 class ChunkDemuxerTest : public testing::Test {
128 protected: 128 protected:
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
177 scoped_refptr<DecoderBuffer> video_content_encodings; 177 scoped_refptr<DecoderBuffer> video_content_encodings;
178 178
179 ebml_header = ReadTestDataFile("webm_ebml_element"); 179 ebml_header = ReadTestDataFile("webm_ebml_element");
180 180
181 info = ReadTestDataFile("webm_info_element"); 181 info = ReadTestDataFile("webm_info_element");
182 182
183 int tracks_element_size = 0; 183 int tracks_element_size = 0;
184 184
185 if (has_audio) { 185 if (has_audio) {
186 audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry"); 186 audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry");
187 tracks_element_size += audio_track_entry->GetDataSize(); 187 tracks_element_size += audio_track_entry->data_size();
188 if (is_audio_encrypted) { 188 if (is_audio_encrypted) {
189 audio_content_encodings = ReadTestDataFile("webm_content_encodings"); 189 audio_content_encodings = ReadTestDataFile("webm_content_encodings");
190 tracks_element_size += audio_content_encodings->GetDataSize(); 190 tracks_element_size += audio_content_encodings->data_size();
191 } 191 }
192 } 192 }
193 193
194 if (has_video) { 194 if (has_video) {
195 video_track_entry = ReadTestDataFile("webm_vp8_track_entry"); 195 video_track_entry = ReadTestDataFile("webm_vp8_track_entry");
196 tracks_element_size += video_track_entry->GetDataSize(); 196 tracks_element_size += video_track_entry->data_size();
197 if (is_video_encrypted) { 197 if (is_video_encrypted) {
198 video_content_encodings = ReadTestDataFile("webm_content_encodings"); 198 video_content_encodings = ReadTestDataFile("webm_content_encodings");
199 tracks_element_size += video_content_encodings->GetDataSize(); 199 tracks_element_size += video_content_encodings->data_size();
200 } 200 }
201 } 201 }
202 202
203 *size = ebml_header->GetDataSize() + info->GetDataSize() + 203 *size = ebml_header->data_size() + info->data_size() +
204 kTracksHeaderSize + tracks_element_size; 204 kTracksHeaderSize + tracks_element_size;
205 205
206 buffer->reset(new uint8[*size]); 206 buffer->reset(new uint8[*size]);
207 207
208 uint8* buf = buffer->get(); 208 uint8* buf = buffer->get();
209 memcpy(buf, ebml_header->GetData(), ebml_header->GetDataSize()); 209 memcpy(buf, ebml_header->data(), ebml_header->data_size());
210 buf += ebml_header->GetDataSize(); 210 buf += ebml_header->data_size();
211 211
212 memcpy(buf, info->GetData(), info->GetDataSize()); 212 memcpy(buf, info->data(), info->data_size());
213 buf += info->GetDataSize(); 213 buf += info->data_size();
214 214
215 memcpy(buf, kTracksHeader, kTracksHeaderSize); 215 memcpy(buf, kTracksHeader, kTracksHeaderSize);
216 WriteInt64(buf + kTracksSizeOffset, tracks_element_size); 216 WriteInt64(buf + kTracksSizeOffset, tracks_element_size);
217 buf += kTracksHeaderSize; 217 buf += kTracksHeaderSize;
218 218
219 // TODO(xhwang): Simplify this! Probably have test data files that contain 219 // TODO(xhwang): Simplify this! Probably have test data files that contain
220 // ContentEncodings directly instead of trying to create one at run-time. 220 // ContentEncodings directly instead of trying to create one at run-time.
221 if (has_audio) { 221 if (has_audio) {
222 memcpy(buf, audio_track_entry->GetData(), 222 memcpy(buf, audio_track_entry->data(),
223 audio_track_entry->GetDataSize()); 223 audio_track_entry->data_size());
224 if (is_audio_encrypted) { 224 if (is_audio_encrypted) {
225 memcpy(buf + audio_track_entry->GetDataSize(), 225 memcpy(buf + audio_track_entry->data_size(),
226 audio_content_encodings->GetData(), 226 audio_content_encodings->data(),
227 audio_content_encodings->GetDataSize()); 227 audio_content_encodings->data_size());
228 WriteInt64(buf + kAudioTrackSizeOffset, 228 WriteInt64(buf + kAudioTrackSizeOffset,
229 audio_track_entry->GetDataSize() + 229 audio_track_entry->data_size() +
230 audio_content_encodings->GetDataSize() - 230 audio_content_encodings->data_size() -
231 kAudioTrackEntryHeaderSize); 231 kAudioTrackEntryHeaderSize);
232 buf += audio_content_encodings->GetDataSize(); 232 buf += audio_content_encodings->data_size();
233 } 233 }
234 buf += audio_track_entry->GetDataSize(); 234 buf += audio_track_entry->data_size();
235 } 235 }
236 236
237 if (has_video) { 237 if (has_video) {
238 memcpy(buf, video_track_entry->GetData(), 238 memcpy(buf, video_track_entry->data(),
239 video_track_entry->GetDataSize()); 239 video_track_entry->data_size());
240 if (is_video_encrypted) { 240 if (is_video_encrypted) {
241 memcpy(buf + video_track_entry->GetDataSize(), 241 memcpy(buf + video_track_entry->data_size(),
242 video_content_encodings->GetData(), 242 video_content_encodings->data(),
243 video_content_encodings->GetDataSize()); 243 video_content_encodings->data_size());
244 WriteInt64(buf + kVideoTrackSizeOffset, 244 WriteInt64(buf + kVideoTrackSizeOffset,
245 video_track_entry->GetDataSize() + 245 video_track_entry->data_size() +
246 video_content_encodings->GetDataSize() - 246 video_content_encodings->data_size() -
247 kVideoTrackEntryHeaderSize); 247 kVideoTrackEntryHeaderSize);
248 buf += video_content_encodings->GetDataSize(); 248 buf += video_content_encodings->data_size();
249 } 249 }
250 buf += video_track_entry->GetDataSize(); 250 buf += video_track_entry->data_size();
251 } 251 }
252 } 252 }
253 253
254 ChunkDemuxer::Status AddId() { 254 ChunkDemuxer::Status AddId() {
255 return AddId(kSourceId, true, true); 255 return AddId(kSourceId, true, true);
256 } 256 }
257 257
258 ChunkDemuxer::Status AddId(const std::string& source_id, 258 ChunkDemuxer::Status AddId(const std::string& source_id,
259 bool has_audio, bool has_video) { 259 bool has_audio, bool has_video) {
260 std::vector<std::string> codecs; 260 std::vector<std::string> codecs;
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after
427 427
428 EXPECT_CALL(*this, DemuxerOpened()); 428 EXPECT_CALL(*this, DemuxerOpened());
429 demuxer_->Initialize( 429 demuxer_->Initialize(
430 &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), 430 &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
431 PIPELINE_OK)); 431 PIPELINE_OK));
432 432
433 if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk) 433 if (AddId(kSourceId, true, true) != ChunkDemuxer::kOk)
434 return false; 434 return false;
435 435
436 // Append the whole bear1 file. 436 // Append the whole bear1 file.
437 AppendData(bear1->GetData(), bear1->GetDataSize()); 437 AppendData(bear1->data(), bear1->data_size());
438 CheckExpectedRanges(kSourceId, "{ [0,2737) }"); 438 CheckExpectedRanges(kSourceId, "{ [0,2737) }");
439 439
440 // Append initialization segment for bear2. 440 // Append initialization segment for bear2.
441 // Note: Offsets here and below are derived from 441 // Note: Offsets here and below are derived from
442 // media/test/data/bear-640x360-manifest.js and 442 // media/test/data/bear-640x360-manifest.js and
443 // media/test/data/bear-320x240-manifest.js which were 443 // media/test/data/bear-320x240-manifest.js which were
444 // generated from media/test/data/bear-640x360.webm and 444 // generated from media/test/data/bear-640x360.webm and
445 // media/test/data/bear-320x240.webm respectively. 445 // media/test/data/bear-320x240.webm respectively.
446 AppendData(bear2->GetData(), 4340); 446 AppendData(bear2->data(), 4340);
447 447
448 // Append a media segment that goes from [0.527000, 1.014000). 448 // Append a media segment that goes from [0.527000, 1.014000).
449 AppendData(bear2->GetData() + 55290, 18785); 449 AppendData(bear2->data() + 55290, 18785);
450 CheckExpectedRanges(kSourceId, "{ [0,1028) [1201,2737) }"); 450 CheckExpectedRanges(kSourceId, "{ [0,1028) [1201,2737) }");
451 451
452 // Append initialization segment for bear1 & fill gap with [779-1197) 452 // Append initialization segment for bear1 & fill gap with [779-1197)
453 // segment. 453 // segment.
454 AppendData(bear1->GetData(), 4370); 454 AppendData(bear1->data(), 4370);
455 AppendData(bear1->GetData() + 72737, 28183); 455 AppendData(bear1->data() + 72737, 28183);
456 CheckExpectedRanges(kSourceId, "{ [0,2737) }"); 456 CheckExpectedRanges(kSourceId, "{ [0,2737) }");
457 457
458 demuxer_->EndOfStream(PIPELINE_OK); 458 demuxer_->EndOfStream(PIPELINE_OK);
459 return true; 459 return true;
460 } 460 }
461 461
462 void ShutdownDemuxer() { 462 void ShutdownDemuxer() {
463 if (demuxer_) 463 if (demuxer_)
464 demuxer_->Shutdown(); 464 demuxer_->Shutdown();
465 } 465 }
(...skipping 206 matching lines...) Expand 10 before | Expand all | Expand 10 after
672 DemuxerStream::Status* status, 672 DemuxerStream::Status* status,
673 base::TimeDelta* last_timestamp) { 673 base::TimeDelta* last_timestamp) {
674 DemuxerStream* stream = demuxer_->GetStream(type); 674 DemuxerStream* stream = demuxer_->GetStream(type);
675 scoped_refptr<DecoderBuffer> buffer; 675 scoped_refptr<DecoderBuffer> buffer;
676 676
677 *last_timestamp = kNoTimestamp(); 677 *last_timestamp = kNoTimestamp();
678 do { 678 do {
679 stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer, 679 stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
680 base::Unretained(this), status, &buffer)); 680 base::Unretained(this), status, &buffer));
681 base::MessageLoop::current()->RunUntilIdle(); 681 base::MessageLoop::current()->RunUntilIdle();
682 if (*status == DemuxerStream::kOk && !buffer->IsEndOfStream()) 682 if (*status == DemuxerStream::kOk && !buffer->end_of_stream())
683 *last_timestamp = buffer->GetTimestamp(); 683 *last_timestamp = buffer->timestamp();
684 } while (*status == DemuxerStream::kOk && !buffer->IsEndOfStream()); 684 } while (*status == DemuxerStream::kOk && !buffer->end_of_stream());
685 } 685 }
686 686
687 void ExpectEndOfStream(DemuxerStream::Type type) { 687 void ExpectEndOfStream(DemuxerStream::Type type) {
688 EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream())); 688 EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
689 demuxer_->GetStream(type)->Read(base::Bind( 689 demuxer_->GetStream(type)->Read(base::Bind(
690 &ChunkDemuxerTest::ReadDone, base::Unretained(this))); 690 &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
691 message_loop_.RunUntilIdle(); 691 message_loop_.RunUntilIdle();
692 } 692 }
693 693
694 void ExpectRead(DemuxerStream::Type type, int64 timestamp_in_ms) { 694 void ExpectRead(DemuxerStream::Type type, int64 timestamp_in_ms) {
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
732 bool has_audio, bool has_video) { 732 bool has_audio, bool has_video) {
733 EXPECT_CALL(*this, DemuxerOpened()); 733 EXPECT_CALL(*this, DemuxerOpened());
734 demuxer_->Initialize( 734 demuxer_->Initialize(
735 &host_, CreateInitDoneCB(duration, PIPELINE_OK)); 735 &host_, CreateInitDoneCB(duration, PIPELINE_OK));
736 736
737 if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk) 737 if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
738 return false; 738 return false;
739 739
740 // Read a WebM file into memory and send the data to the demuxer. 740 // Read a WebM file into memory and send the data to the demuxer.
741 scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename); 741 scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
742 AppendDataInPieces(buffer->GetData(), buffer->GetDataSize(), 512); 742 AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
743 743
744 // Verify that the timestamps on the first few packets match what we 744 // Verify that the timestamps on the first few packets match what we
745 // expect. 745 // expect.
746 for (size_t i = 0; 746 for (size_t i = 0;
747 (timestamps[i].audio_time_ms != kSkip || 747 (timestamps[i].audio_time_ms != kSkip ||
748 timestamps[i].video_time_ms != kSkip); 748 timestamps[i].video_time_ms != kSkip);
749 i++) { 749 i++) {
750 bool audio_read_done = false; 750 bool audio_read_done = false;
751 bool video_read_done = false; 751 bool video_read_done = false;
752 752
(...skipping 407 matching lines...) Expand 10 before | Expand all | Expand 10 after
1160 EXPECT_EQ(expected, audio_read_done_); 1160 EXPECT_EQ(expected, audio_read_done_);
1161 EXPECT_EQ(expected, video_read_done_); 1161 EXPECT_EQ(expected, video_read_done_);
1162 } 1162 }
1163 1163
1164 private: 1164 private:
1165 static void OnEndOfStreamReadDone( 1165 static void OnEndOfStreamReadDone(
1166 bool* called, 1166 bool* called,
1167 DemuxerStream::Status status, 1167 DemuxerStream::Status status,
1168 const scoped_refptr<DecoderBuffer>& buffer) { 1168 const scoped_refptr<DecoderBuffer>& buffer) {
1169 EXPECT_EQ(status, DemuxerStream::kOk); 1169 EXPECT_EQ(status, DemuxerStream::kOk);
1170 EXPECT_TRUE(buffer->IsEndOfStream()); 1170 EXPECT_TRUE(buffer->end_of_stream());
1171 *called = true; 1171 *called = true;
1172 } 1172 }
1173 1173
1174 Demuxer* demuxer_; 1174 Demuxer* demuxer_;
1175 bool audio_read_done_; 1175 bool audio_read_done_;
1176 bool video_read_done_; 1176 bool video_read_done_;
1177 1177
1178 DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper); 1178 DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
1179 }; 1179 };
1180 1180
(...skipping 1371 matching lines...) Expand 10 before | Expand all | Expand 10 after
2552 EXPECT_FALSE(audio_read_done); 2552 EXPECT_FALSE(audio_read_done);
2553 EXPECT_FALSE(video_read_done); 2553 EXPECT_FALSE(video_read_done);
2554 2554
2555 demuxer_->EndOfStream(PIPELINE_OK); 2555 demuxer_->EndOfStream(PIPELINE_OK);
2556 2556
2557 EXPECT_TRUE(audio_read_done); 2557 EXPECT_TRUE(audio_read_done);
2558 EXPECT_TRUE(video_read_done); 2558 EXPECT_TRUE(video_read_done);
2559 } 2559 }
2560 2560
2561 } // namespace media 2561 } // namespace media
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698