?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow supervised users to delete profiles in about:settings.
[chromium-blink-merge.git] / media / base / audio_splicer_unittest.cc
blobd64302c7627349cd7a641ca8597a0e40f56075e4
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/memory/scoped_ptr.h"
6 #include "media/base/audio_buffer.h"
7 #include "media/base/audio_bus.h"
8 #include "media/base/audio_splicer.h"
9 #include "media/base/audio_timestamp_helper.h"
10 #include "media/base/buffers.h"
11 #include "media/base/test_helpers.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 namespace media {
15
16 // Do not change this format. AddInput() and GetValue() only work with float.
17 static const SampleFormat kSampleFormat = kSampleFormatF32;
18 static_assert(kSampleFormat == kSampleFormatF32, "invalid splice format");
19
20 static const int kChannels = 1;
21 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_MONO;
22 static const int kDefaultSampleRate = 44100;
23 static const int kDefaultBufferSize = 100;
24
25 class AudioSplicerTest : public ::testing::Test {
26 public:
27 AudioSplicerTest()
28 : splicer_(kDefaultSampleRate),
29 input_timestamp_helper_(kDefaultSampleRate) {
30 input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta());
31 }
32
33 scoped_refptr<AudioBuffer> GetNextInputBuffer(float value) {
34 return GetNextInputBuffer(value, kDefaultBufferSize);
35 }
36
37 scoped_refptr<AudioBuffer> GetNextInputBuffer(float value, int frame_size) {
38 scoped_refptr<AudioBuffer> buffer =
39 MakeAudioBuffer<float>(kSampleFormat,
40 kChannelLayout,
41 kChannels,
42 kDefaultSampleRate,
43 value,
44 0.0f,
45 frame_size,
46 input_timestamp_helper_.GetTimestamp());
47 input_timestamp_helper_.AddFrames(frame_size);
48 return buffer;
49 }
50
51 float GetValue(const scoped_refptr<AudioBuffer>& buffer) {
52 return reinterpret_cast<const float*>(buffer->channel_data()[0])[0];
53 }
54
55 bool VerifyData(const scoped_refptr<AudioBuffer>& buffer, float value) {
56 int frames = buffer->frame_count();
57 scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
58 buffer->ReadFrames(frames, 0, 0, bus.get());
59 for (int ch = 0; ch < buffer->channel_count(); ++ch) {
60 for (int i = 0; i < frames; ++i) {
61 if (bus->channel(ch)[i] != value)
62 return false;
63 }
64 }
65 return true;
66 }
67
68 void VerifyNextBuffer(const scoped_refptr<AudioBuffer>& input) {
69 ASSERT_TRUE(splicer_.HasNextBuffer());
70 scoped_refptr<AudioBuffer> output = splicer_.GetNextBuffer();
71 EXPECT_EQ(input->timestamp(), output->timestamp());
72 EXPECT_EQ(input->duration(), output->duration());
73 EXPECT_EQ(input->frame_count(), output->frame_count());
74 EXPECT_TRUE(VerifyData(output, GetValue(input)));
75 }
76
77 void VerifyPreSpliceOutput(
78 const scoped_refptr<AudioBuffer>& overlapped_buffer,
79 const scoped_refptr<AudioBuffer>& overlapping_buffer,
80 int expected_pre_splice_size,
81 base::TimeDelta expected_pre_splice_duration) {
82 ASSERT_TRUE(splicer_.HasNextBuffer());
83 scoped_refptr<AudioBuffer> pre_splice_output = splicer_.GetNextBuffer();
84 EXPECT_EQ(overlapped_buffer->timestamp(), pre_splice_output->timestamp());
85 EXPECT_EQ(expected_pre_splice_size, pre_splice_output->frame_count());
86 EXPECT_EQ(expected_pre_splice_duration, pre_splice_output->duration());
87 EXPECT_TRUE(VerifyData(pre_splice_output, GetValue(overlapped_buffer)));
88 }
89
90 void VerifyCrossfadeOutput(
91 const scoped_refptr<AudioBuffer>& overlapped_buffer_1,
92 const scoped_refptr<AudioBuffer>& overlapped_buffer_2,
93 const scoped_refptr<AudioBuffer>& overlapping_buffer,
94 int second_overlap_index,
95 int expected_crossfade_size,
96 base::TimeDelta expected_crossfade_duration) {
97 ASSERT_TRUE(splicer_.HasNextBuffer());
98
99 scoped_refptr<AudioBuffer> crossfade_output = splicer_.GetNextBuffer();
100 EXPECT_EQ(expected_crossfade_size, crossfade_output->frame_count());
101 EXPECT_EQ(expected_crossfade_duration, crossfade_output->duration());
102
103 // The splice timestamp may be adjusted by a microsecond.
104 EXPECT_NEAR(overlapping_buffer->timestamp().InMicroseconds(),
105 crossfade_output->timestamp().InMicroseconds(),
106 1);
107
108 // Verify the actual crossfade.
109 const int frames = crossfade_output->frame_count();
110 float overlapped_value = GetValue(overlapped_buffer_1);
111 const float overlapping_value = GetValue(overlapping_buffer);
112 scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
113 crossfade_output->ReadFrames(frames, 0, 0, bus.get());
114 for (int ch = 0; ch < crossfade_output->channel_count(); ++ch) {
115 float cf_ratio = 0;
116 const float cf_increment = 1.0f / frames;
117 for (int i = 0; i < frames; ++i, cf_ratio += cf_increment) {
118 if (overlapped_buffer_2.get() && i >= second_overlap_index)
119 overlapped_value = GetValue(overlapped_buffer_2);
120 const float actual = bus->channel(ch)[i];
121 const float expected =
122 (1.0f - cf_ratio) * overlapped_value + cf_ratio * overlapping_value;
123 ASSERT_FLOAT_EQ(expected, actual) << "i=" << i;
124 }
125 }
126 }
127
128 bool AddInput(const scoped_refptr<AudioBuffer>& input) {
129 // Since the splicer doesn't make copies it's working directly on the input
130 // buffers. We must make a copy before adding to ensure the original buffer
131 // is not modified in unexpected ways.
132 scoped_refptr<AudioBuffer> buffer_copy =
133 input->end_of_stream()
134 ? AudioBuffer::CreateEOSBuffer()
135 : AudioBuffer::CopyFrom(kSampleFormat,
136 input->channel_layout(),
137 input->channel_count(),
138 input->sample_rate(),
139 input->frame_count(),
140 &input->channel_data()[0],
141 input->timestamp());
142 return splicer_.AddInput(buffer_copy);
143 }
144
145 base::TimeDelta max_crossfade_duration() {
146 return splicer_.max_crossfade_duration_;
147 }
148
149 protected:
150 AudioSplicer splicer_;
151 AudioTimestampHelper input_timestamp_helper_;
152
153 DISALLOW_COPY_AND_ASSIGN(AudioSplicerTest);
154 };
155
156 TEST_F(AudioSplicerTest, PassThru) {
157 EXPECT_FALSE(splicer_.HasNextBuffer());
158
159 // Test single buffer pass-thru behavior.
160 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
161 EXPECT_TRUE(AddInput(input_1));
162 VerifyNextBuffer(input_1);
163 EXPECT_FALSE(splicer_.HasNextBuffer());
164
165 // Test that multiple buffers can be queued in the splicer.
166 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
167 scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
168 EXPECT_TRUE(AddInput(input_2));
169 EXPECT_TRUE(AddInput(input_3));
170 VerifyNextBuffer(input_2);
171 VerifyNextBuffer(input_3);
172 EXPECT_FALSE(splicer_.HasNextBuffer());
173 }
174
175 TEST_F(AudioSplicerTest, Reset) {
176 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
177 EXPECT_TRUE(AddInput(input_1));
178 ASSERT_TRUE(splicer_.HasNextBuffer());
179
180 splicer_.Reset();
181 EXPECT_FALSE(splicer_.HasNextBuffer());
182
183 // Add some bytes to the timestamp helper so that the
184 // next buffer starts many frames beyond the end of
185 // |input_1|. This is to make sure that Reset() actually
186 // clears its state and doesn't try to insert a gap.
187 input_timestamp_helper_.AddFrames(100);
188
189 // Verify that a new input buffer passes through as expected.
190 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
191 EXPECT_TRUE(AddInput(input_2));
192 VerifyNextBuffer(input_2);
193 EXPECT_FALSE(splicer_.HasNextBuffer());
194 }
195
196 TEST_F(AudioSplicerTest, EndOfStream) {
197 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
198 scoped_refptr<AudioBuffer> input_2 = AudioBuffer::CreateEOSBuffer();
199 scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.2f);
200 EXPECT_TRUE(input_2->end_of_stream());
201
202 EXPECT_TRUE(AddInput(input_1));
203 EXPECT_TRUE(AddInput(input_2));
204
205 VerifyNextBuffer(input_1);
206
207 scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
208 EXPECT_FALSE(splicer_.HasNextBuffer());
209 EXPECT_TRUE(output_2->end_of_stream());
210
211 // Verify that buffers can be added again after Reset().
212 splicer_.Reset();
213 EXPECT_TRUE(AddInput(input_3));
214 VerifyNextBuffer(input_3);
215 EXPECT_FALSE(splicer_.HasNextBuffer());
216 }
217
218 // Test the gap insertion code.
219 // +--------------+ +--------------+
220 // |11111111111111| |22222222222222|
221 // +--------------+ +--------------+
222 // Results in:
223 // +--------------+----+--------------+
224 // |11111111111111|0000|22222222222222|
225 // +--------------+----+--------------+
226 TEST_F(AudioSplicerTest, GapInsertion) {
227 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
228
229 // Add bytes to the timestamp helper so that the next buffer
230 // will have a starting timestamp that indicates a gap is
231 // present.
232 const int kGapSize = 7;
233 input_timestamp_helper_.AddFrames(kGapSize);
234 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
235
236 EXPECT_TRUE(AddInput(input_1));
237 EXPECT_TRUE(AddInput(input_2));
238
239 // Verify that the first input buffer passed through unmodified.
240 VerifyNextBuffer(input_1);
241
242 // Verify the contents of the gap buffer.
243 scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
244 base::TimeDelta gap_timestamp =
245 input_1->timestamp() + input_1->duration();
246 base::TimeDelta gap_duration = input_2->timestamp() - gap_timestamp;
247 EXPECT_GT(gap_duration, base::TimeDelta());
248 EXPECT_EQ(gap_timestamp, output_2->timestamp());
249 EXPECT_NEAR(
250 gap_duration.InMicroseconds(), output_2->duration().InMicroseconds(), 1);
251 EXPECT_EQ(kGapSize, output_2->frame_count());
252 EXPECT_TRUE(VerifyData(output_2, 0.0f));
253
254 // Verify that the second input buffer passed through unmodified.
255 VerifyNextBuffer(input_2);
256 EXPECT_FALSE(splicer_.HasNextBuffer());
257 }
258
259 // Test that an error is signalled when the gap between input buffers is
260 // too large.
261 TEST_F(AudioSplicerTest, GapTooLarge) {
262 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
263
264 // Add a seconds worth of bytes so that an unacceptably large
265 // gap exists between |input_1| and |input_2|.
266 const int kGapSize = kDefaultSampleRate;
267 input_timestamp_helper_.AddFrames(kGapSize);
268 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
269
270 EXPECT_TRUE(AddInput(input_1));
271 EXPECT_FALSE(AddInput(input_2));
272
273 VerifyNextBuffer(input_1);
274
275 // Verify that the second buffer is not available.
276 EXPECT_FALSE(splicer_.HasNextBuffer());
277
278 // Reset the timestamp helper so it can generate a buffer that is
279 // right after |input_1|.
280 input_timestamp_helper_.SetBaseTimestamp(
281 input_1->timestamp() + input_1->duration());
282
283 // Verify that valid buffers are still accepted.
284 scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
285 EXPECT_TRUE(AddInput(input_3));
286 VerifyNextBuffer(input_3);
287 EXPECT_FALSE(splicer_.HasNextBuffer());
288 }
289
290 // Verifies that an error is signalled if AddInput() is called
291 // with a timestamp that is earlier than the first buffer added.
292 TEST_F(AudioSplicerTest, BufferAddedBeforeBase) {
293 input_timestamp_helper_.SetBaseTimestamp(
294 base::TimeDelta::FromMicroseconds(10));
295 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
296
297 // Reset the timestamp helper so the next buffer will have a timestamp earlier
298 // than |input_1|.
299 input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta::FromSeconds(0));
300 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.1f);
301
302 EXPECT_GT(input_1->timestamp(), input_2->timestamp());
303 EXPECT_TRUE(AddInput(input_1));
304 EXPECT_FALSE(AddInput(input_2));
305 }
306
307 // Test when one buffer partially overlaps another.
308 // +--------------+
309 // |11111111111111|
310 // +--------------+
311 // +--------------+
312 // |22222222222222|
313 // +--------------+
314 // Results in:
315 // +--------------+----------+
316 // |11111111111111|2222222222|
317 // +--------------+----------+
318 TEST_F(AudioSplicerTest, PartialOverlap) {
319 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
320
321 // Reset timestamp helper so that the next buffer will have a
322 // timestamp that starts in the middle of |input_1|.
323 const int kOverlapSize = input_1->frame_count() / 4;
324 input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
325 input_timestamp_helper_.AddFrames(input_1->frame_count() - kOverlapSize);
326
327 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
328
329 EXPECT_TRUE(AddInput(input_1));
330 EXPECT_TRUE(AddInput(input_2));
331
332 // Verify that the first input buffer passed through unmodified.
333 VerifyNextBuffer(input_1);
334
335 ASSERT_TRUE(splicer_.HasNextBuffer());
336 scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
337 EXPECT_FALSE(splicer_.HasNextBuffer());
338
339 // Verify that the second input buffer was truncated to only contain
340 // the samples that are after the end of |input_1|.
341 base::TimeDelta expected_timestamp =
342 input_1->timestamp() + input_1->duration();
343 base::TimeDelta expected_duration =
344 (input_2->timestamp() + input_2->duration()) - expected_timestamp;
345 EXPECT_EQ(expected_timestamp, output_2->timestamp());
346 EXPECT_EQ(expected_duration, output_2->duration());
347 EXPECT_TRUE(VerifyData(output_2, GetValue(input_2)));
348 }
349
350 // Test that an input buffer that is completely overlapped by a buffer
351 // that was already added is dropped.
352 // +--------------+
353 // |11111111111111|
354 // +--------------+
355 // +-----+
356 // |22222|
357 // +-----+
358 // +-------------+
359 // |3333333333333|
360 // +-------------+
361 // Results in:
362 // +--------------+-------------+
363 // |11111111111111|3333333333333|
364 // +--------------+-------------+
365 TEST_F(AudioSplicerTest, DropBuffer) {
366 scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
367
368 // Reset timestamp helper so that the next buffer will have a
369 // timestamp that starts in the middle of |input_1|.
370 const int kOverlapOffset = input_1->frame_count() / 2;
371 const int kOverlapSize = input_1->frame_count() / 4;
372 input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
373 input_timestamp_helper_.AddFrames(kOverlapOffset);
374
375 scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f, kOverlapSize);
376
377 // Reset the timestamp helper so the next buffer will be right after
378 // |input_1|.
379 input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
380 input_timestamp_helper_.AddFrames(input_1->frame_count());
381 scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
382
383 EXPECT_TRUE(AddInput(input_1));
384 EXPECT_TRUE(AddInput(input_2));
385 EXPECT_TRUE(AddInput(input_3));
386
387 VerifyNextBuffer(input_1);
388 VerifyNextBuffer(input_3);
389 EXPECT_FALSE(splicer_.HasNextBuffer());
390 }
391
392 // Test crossfade when one buffer partially overlaps another.
393 // +--------------+
394 // |11111111111111|
395 // +--------------+
396 // +--------------+
397 // |22222222222222|
398 // +--------------+
399 // Results in:
400 // +----------+----+----------+
401 // |1111111111|xxxx|2222222222|
402 // +----------+----+----------+
403 // Where "xxxx" represents the crossfaded portion of the signal.
404 TEST_F(AudioSplicerTest, PartialOverlapCrossfade) {
405 const int kCrossfadeSize =
406 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
407 const int kBufferSize = kCrossfadeSize * 2;
408
409 scoped_refptr<AudioBuffer> extra_pre_splice_buffer =
410 GetNextInputBuffer(0.2f, kBufferSize);
411 scoped_refptr<AudioBuffer> overlapped_buffer =
412 GetNextInputBuffer(1.0f, kBufferSize);
413
414 // Reset timestamp helper so that the next buffer will have a timestamp that
415 // starts in the middle of |overlapped_buffer|.
416 input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
417 input_timestamp_helper_.AddFrames(overlapped_buffer->frame_count() -
418 kCrossfadeSize);
419 splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
420 scoped_refptr<AudioBuffer> overlapping_buffer =
421 GetNextInputBuffer(0.0f, kBufferSize);
422
423 // |extra_pre_splice_buffer| is entirely before the splice and should be ready
424 // for output.
425 EXPECT_TRUE(AddInput(extra_pre_splice_buffer));
426 VerifyNextBuffer(extra_pre_splice_buffer);
427
428 // The splicer should be internally queuing input since |overlapped_buffer| is
429 // part of the splice.
430 EXPECT_TRUE(AddInput(overlapped_buffer));
431 EXPECT_FALSE(splicer_.HasNextBuffer());
432
433 // |overlapping_buffer| completes the splice.
434 splicer_.SetSpliceTimestamp(kNoTimestamp());
435 EXPECT_TRUE(AddInput(overlapping_buffer));
436 ASSERT_TRUE(splicer_.HasNextBuffer());
437
438 // Add one more buffer to make sure it's passed through untouched.
439 scoped_refptr<AudioBuffer> extra_post_splice_buffer =
440 GetNextInputBuffer(0.5f, kBufferSize);
441 EXPECT_TRUE(AddInput(extra_post_splice_buffer));
442
443 VerifyPreSpliceOutput(overlapped_buffer,
444 overlapping_buffer,
445 221,
446 base::TimeDelta::FromMicroseconds(5011));
447
448 // Due to rounding the crossfade size may vary by up to a frame.
449 const int kExpectedCrossfadeSize = 220;
450 EXPECT_NEAR(kExpectedCrossfadeSize, kCrossfadeSize, 1);
451
452 VerifyCrossfadeOutput(overlapped_buffer,
453 NULL,
454 overlapping_buffer,
455 0,
456 kExpectedCrossfadeSize,
457 base::TimeDelta::FromMicroseconds(4988));
458
459 // Retrieve the remaining portion after crossfade.
460 ASSERT_TRUE(splicer_.HasNextBuffer());
461 scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
462 EXPECT_EQ(base::TimeDelta::FromMicroseconds(20022),
463 post_splice_output->timestamp());
464 EXPECT_EQ(overlapping_buffer->frame_count() - kExpectedCrossfadeSize,
465 post_splice_output->frame_count());
466 EXPECT_EQ(base::TimeDelta::FromMicroseconds(5034),
467 post_splice_output->duration());
468
469 EXPECT_TRUE(VerifyData(post_splice_output, GetValue(overlapping_buffer)));
470
471 VerifyNextBuffer(extra_post_splice_buffer);
472 EXPECT_FALSE(splicer_.HasNextBuffer());
473 }
474
475 // Test crossfade when one buffer partially overlaps another, but an end of
476 // stream buffer is received before the crossfade duration is reached.
477 // +--------------+
478 // |11111111111111|
479 // +--------------+
480 // +---------++---+
481 // |222222222||EOS|
482 // +---------++---+
483 // Results in:
484 // +----------+----+----++---+
485 // |1111111111|xxxx|2222||EOS|
486 // +----------+----+----++---+
487 // Where "x" represents the crossfaded portion of the signal.
488 TEST_F(AudioSplicerTest, PartialOverlapCrossfadeEndOfStream) {
489 const int kCrossfadeSize =
490 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
491
492 scoped_refptr<AudioBuffer> overlapped_buffer =
493 GetNextInputBuffer(1.0f, kCrossfadeSize * 2);
494
495 // Reset timestamp helper so that the next buffer will have a timestamp that
496 // starts 3/4 of the way into |overlapped_buffer|.
497 input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
498 input_timestamp_helper_.AddFrames(3 * overlapped_buffer->frame_count() / 4);
499 splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
500 scoped_refptr<AudioBuffer> overlapping_buffer =
501 GetNextInputBuffer(0.0f, kCrossfadeSize / 3);
502
503 // The splicer should be internally queuing input since |overlapped_buffer| is
504 // part of the splice.
505 EXPECT_TRUE(AddInput(overlapped_buffer));
506 EXPECT_FALSE(splicer_.HasNextBuffer());
507
508 // |overlapping_buffer| should not have enough data to complete the splice, so
509 // ensure output is not available.
510 splicer_.SetSpliceTimestamp(kNoTimestamp());
511 EXPECT_TRUE(AddInput(overlapping_buffer));
512 EXPECT_FALSE(splicer_.HasNextBuffer());
513
514 // Now add an EOS buffer which should complete the splice.
515 EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
516
517 VerifyPreSpliceOutput(overlapped_buffer,
518 overlapping_buffer,
519 331,
520 base::TimeDelta::FromMicroseconds(7505));
521 VerifyCrossfadeOutput(overlapped_buffer,
522 NULL,
523 overlapping_buffer,
524 0,
525 overlapping_buffer->frame_count(),
526 overlapping_buffer->duration());
527
528 // Ensure the last buffer is an EOS buffer.
529 ASSERT_TRUE(splicer_.HasNextBuffer());
530 scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
531 EXPECT_TRUE(post_splice_output->end_of_stream());
532
533 EXPECT_FALSE(splicer_.HasNextBuffer());
534 }
535
536 // Test crossfade when one buffer partially overlaps another, but the amount of
537 // overlapped data is less than the crossfade duration.
538 // +------------+
539 // |111111111111|
540 // +------------+
541 // +--------------+
542 // |22222222222222|
543 // +--------------+
544 // Results in:
545 // +----------+-+------------+
546 // |1111111111|x|222222222222|
547 // +----------+-+------------+
548 // Where "x" represents the crossfaded portion of the signal.
549 TEST_F(AudioSplicerTest, PartialOverlapCrossfadeShortPreSplice) {
550 const int kCrossfadeSize =
551 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration());
552
553 scoped_refptr<AudioBuffer> overlapped_buffer =
554 GetNextInputBuffer(1.0f, kCrossfadeSize / 2);
555
556 // Reset timestamp helper so that the next buffer will have a timestamp that
557 // starts in the middle of |overlapped_buffer|.
558 input_timestamp_helper_.SetBaseTimestamp(overlapped_buffer->timestamp());
559 input_timestamp_helper_.AddFrames(overlapped_buffer->frame_count() / 2);
560 splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
561 scoped_refptr<AudioBuffer> overlapping_buffer =
562 GetNextInputBuffer(0.0f, kCrossfadeSize * 2);
563
564 // The splicer should be internally queuing input since |overlapped_buffer| is
565 // part of the splice.
566 EXPECT_TRUE(AddInput(overlapped_buffer));
567 EXPECT_FALSE(splicer_.HasNextBuffer());
568
569 // |overlapping_buffer| completes the splice.
570 splicer_.SetSpliceTimestamp(kNoTimestamp());
571 EXPECT_TRUE(AddInput(overlapping_buffer));
572
573 const int kExpectedPreSpliceSize = 55;
574 const base::TimeDelta kExpectedPreSpliceDuration =
575 base::TimeDelta::FromMicroseconds(1247);
576 VerifyPreSpliceOutput(overlapped_buffer,
577 overlapping_buffer,
578 kExpectedPreSpliceSize,
579 kExpectedPreSpliceDuration);
580 VerifyCrossfadeOutput(overlapped_buffer,
581 NULL,
582 overlapping_buffer,
583 0,
584 kExpectedPreSpliceSize,
585 kExpectedPreSpliceDuration);
586
587 // Retrieve the remaining portion after crossfade.
588 ASSERT_TRUE(splicer_.HasNextBuffer());
589 scoped_refptr<AudioBuffer> post_splice_output = splicer_.GetNextBuffer();
590 EXPECT_EQ(overlapping_buffer->timestamp() + kExpectedPreSpliceDuration,
591 post_splice_output->timestamp());
592 EXPECT_EQ(overlapping_buffer->frame_count() - kExpectedPreSpliceSize,
593 post_splice_output->frame_count());
594 EXPECT_EQ(overlapping_buffer->duration() - kExpectedPreSpliceDuration,
595 post_splice_output->duration());
596
597 EXPECT_TRUE(VerifyData(post_splice_output, GetValue(overlapping_buffer)));
598 EXPECT_FALSE(splicer_.HasNextBuffer());
599 }
600
601 // Test behavior when a splice frame is incorrectly marked and does not actually
602 // overlap.
603 // +----------+
604 // |1111111111|
605 // +----------+
606 // +--------------+
607 // |22222222222222|
608 // +--------------+
609 // Results in:
610 // +----------+--------------+
611 // |1111111111|22222222222222|
612 // +----------+--------------+
613 TEST_F(AudioSplicerTest, IncorrectlyMarkedSplice) {
614 const int kBufferSize =
615 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration()) * 2;
616
617 scoped_refptr<AudioBuffer> first_buffer =
618 GetNextInputBuffer(1.0f, kBufferSize);
619 // Fuzz the duration slightly so that the buffer overlaps the splice timestamp
620 // by a microsecond, which is not enough to crossfade.
621 const base::TimeDelta kSpliceTimestamp =
622 input_timestamp_helper_.GetTimestamp() -
623 base::TimeDelta::FromMicroseconds(1);
624 splicer_.SetSpliceTimestamp(kSpliceTimestamp);
625 scoped_refptr<AudioBuffer> second_buffer =
626 GetNextInputBuffer(0.0f, kBufferSize);
627 second_buffer->set_timestamp(kSpliceTimestamp);
628
629 // The splicer should be internally queuing input since |first_buffer| is part
630 // of the supposed splice.
631 EXPECT_TRUE(AddInput(first_buffer));
632 EXPECT_FALSE(splicer_.HasNextBuffer());
633
634 // |second_buffer| should complete the supposed splice, so ensure output is
635 // now available.
636 splicer_.SetSpliceTimestamp(kNoTimestamp());
637 EXPECT_TRUE(AddInput(second_buffer));
638
639 VerifyNextBuffer(first_buffer);
640 VerifyNextBuffer(second_buffer);
641 EXPECT_FALSE(splicer_.HasNextBuffer());
642 }
643
644 // Test behavior when a splice frame is incorrectly marked and there is a gap
645 // between whats in the pre splice and post splice.
646 // +--------+
647 // |11111111|
648 // +--------+
649 // +--------------+
650 // |22222222222222|
651 // +--------------+
652 // Results in:
653 // +--------+-+--------------+
654 // |11111111|0|22222222222222|
655 // +--------+-+--------------+
656 TEST_F(AudioSplicerTest, IncorrectlyMarkedSpliceWithGap) {
657 const int kBufferSize =
658 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration()) * 2;
659 const int kGapSize = 2;
660
661 scoped_refptr<AudioBuffer> first_buffer =
662 GetNextInputBuffer(1.0f, kBufferSize - kGapSize);
663 scoped_refptr<AudioBuffer> gap_buffer =
664 GetNextInputBuffer(0.0f, kGapSize);
665 splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
666 scoped_refptr<AudioBuffer> second_buffer =
667 GetNextInputBuffer(0.0f, kBufferSize);
668
669 // The splicer should pass through the first buffer since it's not part of the
670 // splice.
671 EXPECT_TRUE(AddInput(first_buffer));
672 VerifyNextBuffer(first_buffer);
673
674 // Do not add |gap_buffer|.
675
676 // |second_buffer| will complete the supposed splice.
677 splicer_.SetSpliceTimestamp(kNoTimestamp());
678 EXPECT_TRUE(AddInput(second_buffer));
679
680 VerifyNextBuffer(gap_buffer);
681 VerifyNextBuffer(second_buffer);
682 EXPECT_FALSE(splicer_.HasNextBuffer());
683 }
684
685 // Test behavior when a splice frame is incorrectly marked and there is a gap
686 // between what's in the pre splice and post splice that is too large to recover
687 // from.
688 // +--------+
689 // |11111111|
690 // +--------+
691 // +------+
692 // |222222|
693 // +------+
694 // Results in an error and not a crash.
695 TEST_F(AudioSplicerTest, IncorrectlyMarkedSpliceWithBadGap) {
696 const int kBufferSize =
697 input_timestamp_helper_.GetFramesToTarget(max_crossfade_duration()) * 2;
698 const int kGapSize = kBufferSize +
699 input_timestamp_helper_.GetFramesToTarget(
700 base::TimeDelta::FromMilliseconds(
701 AudioSplicer::kMaxTimeDeltaInMilliseconds + 1));
702
703 scoped_refptr<AudioBuffer> first_buffer =
704 GetNextInputBuffer(1.0f, kBufferSize);
705 scoped_refptr<AudioBuffer> gap_buffer =
706 GetNextInputBuffer(0.0f, kGapSize);
707 splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
708 scoped_refptr<AudioBuffer> second_buffer =
709 GetNextInputBuffer(0.0f, kBufferSize);
710
711 // The splicer should pass through the first buffer since it's not part of the
712 // splice.
713 EXPECT_TRUE(AddInput(first_buffer));
714 VerifyNextBuffer(first_buffer);
715
716 // Do not add |gap_buffer|.
717
718 // |second_buffer| will complete the supposed splice.
719 splicer_.SetSpliceTimestamp(kNoTimestamp());
720 EXPECT_FALSE(AddInput(second_buffer));
721 }
722
723 // Ensure we don't crash when a splice frame is incorrectly marked such that the
724 // splice timestamp has already passed when SetSpliceTimestamp() is called.
725 // This can happen if the encoded timestamps are too far behind the decoded
726 // timestamps.
727 TEST_F(AudioSplicerTest, IncorrectlyMarkedPastSplice) {
728 const int kBufferSize = 200;
729
730 scoped_refptr<AudioBuffer> first_buffer =
731 GetNextInputBuffer(1.0f, kBufferSize);
732 EXPECT_TRUE(AddInput(first_buffer));
733 VerifyNextBuffer(first_buffer);
734
735 // Start the splice at a timestamp which has already occurred.
736 splicer_.SetSpliceTimestamp(base::TimeDelta());
737
738 scoped_refptr<AudioBuffer> second_buffer =
739 GetNextInputBuffer(0.5f, kBufferSize);
740 EXPECT_TRUE(AddInput(second_buffer));
741 EXPECT_FALSE(splicer_.HasNextBuffer());
742
743 // |third_buffer| will complete the supposed splice. The buffer size is set
744 // such that unchecked the splicer would try to trim off a negative number of
745 // frames.
746 splicer_.SetSpliceTimestamp(kNoTimestamp());
747 scoped_refptr<AudioBuffer> third_buffer =
748 GetNextInputBuffer(0.0f, kBufferSize * 10);
749 third_buffer->set_timestamp(base::TimeDelta());
750 EXPECT_TRUE(AddInput(third_buffer));
751
752 // The second buffer should come through unmodified.
753 VerifyNextBuffer(second_buffer);
754
755 // The third buffer should be partially dropped since it overlaps the second.
756 ASSERT_TRUE(splicer_.HasNextBuffer());
757 const base::TimeDelta second_buffer_end_ts =
758 second_buffer->timestamp() + second_buffer->duration();
759 scoped_refptr<AudioBuffer> output = splicer_.GetNextBuffer();
760 EXPECT_EQ(second_buffer_end_ts, output->timestamp());
761 EXPECT_EQ(third_buffer->duration() -
762 (second_buffer_end_ts - third_buffer->timestamp()),
763 output->duration());
764 EXPECT_TRUE(VerifyData(output, GetValue(third_buffer)));
765 }
766
767 } // namespace media