Add gapless playback support for AAC playback.

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 862 matching lines @@
       scoped_refptr<DecoderBuffer> buffer;
       stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
                               base::Unretained(this), &status, &buffer));
       base::MessageLoop::current()->RunUntilIdle();
       if (status != DemuxerStream::kOk || buffer->end_of_stream())
         break;
 
       if (i > 0)
         ss << " ";
       ss << buffer->timestamp().InMilliseconds();
+
+      // Handle preroll buffers.
+      if (EndsWith(timestamps[i], "P", true)) {
+        scoped_refptr<DecoderBuffer> preroll_buffer;
+        preroll_buffer.swap(buffer);
+
+        // When a preroll buffer is encountered we should be able to request one
+        // more buffer.  The first buffer should have a timestamp equal to the
+        // second buffer and its discard_padding() should be its duration.
+        stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
+                                base::Unretained(this), &status, &buffer));
+        base::MessageLoop::current()->RunUntilIdle();
+        ASSERT_EQ(preroll_buffer->timestamp(), buffer->timestamp());
+        ASSERT_EQ(preroll_buffer->discard_padding().first,
+                  preroll_buffer->duration());
+        ss << "P";
+      }
     }
     EXPECT_EQ(expected, ss.str());
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
   struct BufferTimestamps {
     int video_time_ms;
     int audio_time_ms;
   };
@@ skipping 2159 matching lines @@
     EXPECT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO | HAS_VIDEO));
 
     demuxer_->Remove(kSourceId, base::TimeDelta::FromMilliseconds(0),
                      base::TimeDelta::FromMilliseconds(1));
 }
 
 TEST_P(ChunkDemuxerTest, AppendWindow_Video) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
-  // Set the append window to [20,280).
-  append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
+  // Set the append window to [50,280).

[wolenetz, 2014/05/17 00:41:17]

Why increase 20 -> 50? Currently, video does not support partial append window
trimming, so preroll (or even partial append window trimming itself) shouldn't
change the result, below, right?
Perhaps video keyframe preroll and partial append window trimming should be
supported for video? (separate CL)

[DaleCurtis, 2014/05/17 00:55:41]

I changed them both because I thought it was a better test.

+  append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "0K 30 60 90 120K 150 180 210 240K 270 300 330K");
 
   // Verify that GOPs that start outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
   // window and extend beyond the end of the window are not included.
   CheckExpectedRanges(kSourceId, "{ [120,270) }");
   CheckExpectedBuffers(stream, "120 150 180 210 240");
 
   // Extend the append window to [20,650).

[wolenetz, 2014/05/17 00:41:17]

nit: Fix comment if we keep to 50ms window start.

[DaleCurtis, 2014/05/22 23:58:57]

Done.

   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that adding buffers start at the next
   // keyframe.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
   CheckExpectedRanges(kSourceId, "{ [120,270) [420,630) }");
 }
 
 TEST_P(ChunkDemuxerTest, AppendWindow_Audio) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
-  // Set the append window to [20,280).
-  append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
+  // Set the append window to [50,280).
+  append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "0K 30K 60K 90K 120K 150K 180K 210K 240K 270K 300K 330K");
 
   // Verify that frames that end outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
   // window and extend beyond the end of the window are not included.
   //
-  // The first 20ms of the first buffer should be trimmed off since it
-  // overlaps the start of the append window.
-  CheckExpectedRanges(kSourceId, "{ [20,270) }");
-  CheckExpectedBuffers(stream, "20 30 60 90 120 150 180 210 240");
+  // The first 20ms of the second buffer should be trimmed off since it
+  // overlaps the start of the append window.  The first buffer should be
+  // added as preroll to the second buffer.
+  CheckExpectedRanges(kSourceId, "{ [50,270) }");
+  CheckExpectedBuffers(stream, "50P 60 90 120 150 180 210 240");
 
-  // Extend the append window to [20,650).
+  // Extend the append window to [50,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "360K 390K 420K 450K 480K 510K 540K 570K 600K 630K");
-  CheckExpectedRanges(kSourceId, "{ [20,270) [360,630) }");
+  CheckExpectedRanges(kSourceId, "{ [50,270) [360,630) }");
 }
 
 TEST_P(ChunkDemuxerTest, AppendWindow_AudioOverlapStartAndEnd) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   // Set the append window to [10,20).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(10);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
 
   // Append a cluster that starts before and ends after the append window.
@@ skipping 147 matching lines @@
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 // TODO(wolenetz): Enable testing of new frame processor based on this flag,
 // once the new processor has landed. See http://crbug.com/249422.
 INSTANTIATE_TEST_CASE_P(LegacyFrameProcessor, ChunkDemuxerTest, Values(true));
 
 }  // namespace media