Move key frame flag from StreamParserBuffer to DecoderBuffer

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 19 matching lines @@
 using ::testing::SetArgumentPointee;
 using ::testing::_;
 
 namespace media {
 
 const uint8 kTracksHeader[] = {
   0x16, 0x54, 0xAE, 0x6B,  // Tracks ID
   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // tracks(size = 0)
 };
 
-// WebM Block bytes that represent a VP8 keyframe.
+// WebM Block bytes that represent a VP8 key frame.
 const uint8 kVP8Keyframe[] = {
   0x010, 0x00, 0x00, 0x9d, 0x01, 0x2a, 0x00, 0x10, 0x00, 0x10, 0x00
 };
 
 // WebM Block bytes that represent a VP8 interframe.
 const uint8 kVP8Interframe[] = { 0x11, 0x00, 0x00 };
 
 static const uint8 kCuesHeader[] = {
   0x1C, 0x53, 0xBB, 0x6B,  // Cues ID
   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // cues(size = 0)
@@ skipping 371 matching lines @@
 
     bool operator< (const BlockInfo& rhs) const {
       return timestamp_in_ms < rhs.timestamp_in_ms;
     }
   };
 
   // |track_number| - The track number to place in
   // |block_descriptions| - A space delimited string of block info that
   //  is used to populate |blocks|. Each block info has a timestamp in
   //  milliseconds and optionally followed by a 'K' to indicate that a block
-  //  should be marked as a keyframe. For example "0K 30 60" should populate
-  //  |blocks| with 3 BlockInfo objects: a keyframe with timestamp 0 and 2
-  //  non-keyframes at 30ms and 60ms.
+  //  should be marked as a key frame. For example "0K 30 60" should populate
+  //  |blocks| with 3 BlockInfo objects: a key frame with timestamp 0 and 2
+  //  non-key-frames at 30ms and 60ms.
   void ParseBlockDescriptions(int track_number,
                               const std::string block_descriptions,
                               std::vector<BlockInfo>* blocks) {
     std::vector<std::string> timestamps;
     base::SplitString(block_descriptions, ' ', &timestamps);
 
     for (size_t i = 0; i < timestamps.size(); ++i) {
       std::string timestamp_str = timestamps[i];
       BlockInfo block_info;
       block_info.track_number = track_number;
       block_info.flags = 0;
       block_info.duration = 0;
 
       if (EndsWith(timestamp_str, "K", true)) {
         block_info.flags = kWebMFlagKeyframe;
         // Remove the "K" off of the token.
         timestamp_str = timestamp_str.substr(0, timestamps[i].length() - 1);
       }
       CHECK(base::StringToInt(timestamp_str, &block_info.timestamp_in_ms));
 
       if (track_number == kTextTrackNum ||
           track_number == kAlternateTextTrackNum) {
         block_info.duration = kTextBlockDuration;
         ASSERT_EQ(kWebMFlagKeyframe, block_info.flags)
             << "Text block with timestamp " << block_info.timestamp_in_ms
-            << " was not marked as a keyframe."
-            << " All text blocks must be keyframes";
+            << " was not marked as a key frame."
+            << " All text blocks must be key frames";
       }
 
       if (track_number == kAudioTrackNum)
         ASSERT_TRUE(block_info.flags & kWebMFlagKeyframe);
 
       blocks->push_back(block_info);
     }
   }
 
   scoped_ptr<Cluster> GenerateCluster(const std::vector<BlockInfo>& blocks,
@@ skipping 362 matching lines @@
                                  first_audio_timecode,
                                  kWebMFlagKeyframe,
                                  kAudioBlockDuration));
       return GenerateCluster(block_queue, unknown_size);
     }
 
     int audio_timecode = first_audio_timecode;
     int video_timecode = first_video_timecode;
 
     // Create simple blocks for everything except the last 2 blocks.
-    // The first video frame must be a keyframe.
+    // The first video frame must be a key frame.
     uint8 video_flag = kWebMFlagKeyframe;
     for (int i = 0; i < block_count - 2; i++) {
       if (audio_timecode <= video_timecode) {
         block_queue.push(BlockInfo(kAudioTrackNum,
                                    audio_timecode,
                                    kWebMFlagKeyframe,
                                    0));
         audio_timecode += kAudioBlockDuration;
         continue;
       }
@@ skipping 212 matching lines @@
       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();
 
+      if (buffer->is_key_frame())
+        ss << "K";
+
       // Handle preroll buffers.
       if (EndsWith(timestamps[i], "P", true)) {
         ASSERT_EQ(kInfiniteDuration(), buffer->discard_padding().first);
         ASSERT_EQ(base::TimeDelta(), buffer->discard_padding().second);
         ss << "P";
       }
     }
     EXPECT_EQ(expected, ss.str());
   }
 
@@ skipping 290 matching lines @@
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId],
                        init_segment_received_cb_);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46K 69K"),
       MuxedStreamInfo(kVideoTrackNum, "60K"),
       MuxedStreamInfo(kAlternateTextTrackNum, "45K"));
 
   CheckExpectedRanges(kSourceId, "{ [0,92) }");
-  CheckExpectedBuffers(audio_stream, "0 23 46 69");
-  CheckExpectedBuffers(video_stream, "0 30 60");
-  CheckExpectedBuffers(text_stream, "10 45");
+  CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
+  CheckExpectedBuffers(video_stream, "0K 30 60K");
+  CheckExpectedBuffers(text_stream, "10K 45K");
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
-  // Tests that non-keyframes following an init segment are allowed
+  // Tests that non-key-frames following an init segment are allowed
   // and dropped, as expected if the initialization segment received
   // algorithm correctly sets the needs random access point flag to true for all
   // track buffers. Note that the first initialization segment is insufficient
   // to fully test this since needs random access point flag initializes to
   // true.
   CreateNewDemuxer();
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "23K"),
       MuxedStreamInfo(kVideoTrackNum, "0 30K"),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
   CheckExpectedRanges(kSourceId, "{ [23,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceived());
   AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46K 69K"),
       MuxedStreamInfo(kVideoTrackNum, "60 90K"),
       MuxedStreamInfo(kTextTrackNum, "80K 90K"));
   CheckExpectedRanges(kSourceId, "{ [23,92) }");
 
-  CheckExpectedBuffers(audio_stream, "23 46 69");
-  CheckExpectedBuffers(video_stream, "30 90");
-  CheckExpectedBuffers(text_stream, "25 40 80 90");
+  CheckExpectedBuffers(audio_stream, "23K 46K 69K");
+  CheckExpectedBuffers(video_stream, "30K 90K");
+  CheckExpectedBuffers(text_stream, "25K 40K 80K 90K");
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
@@ skipping 1964 matching lines @@
   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");
+  CheckExpectedBuffers(stream, "120K 150 180 210 240K");
 
   // Extend the append window to [50,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that adding buffers start at the next
-  // keyframe.
+  // key frame.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
   CheckExpectedRanges(kSourceId, "{ [120,270) [420,630) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // 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 50ms of the range should be truncated since it overlaps
   // the start of the append window.
   CheckExpectedRanges(kSourceId, "{ [50,280) }");
 
   // The "50P" buffer is the "0" buffer marked for complete discard.  The next
   // "50" buffer is the "30" buffer marked with 20ms of start discard.
-  CheckExpectedBuffers(stream, "50P 50 60 90 120 150 180 210 240");
+  CheckExpectedBuffers(stream, "50KP 50K 60K 90K 120K 150K 180K 210K 240K");
 
   // 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, "{ [50,280) [360,650) }");
 }
@@ skipping 26 matching lines @@
 
   // Read a WebM file into memory and send the data to the demuxer.  The chunk
   // size has been chosen carefully to ensure the preroll buffer used by the
   // partial append window trim must come from a previous Append() call.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   EXPECT_CALL(*this, InitSegmentReceived());
   AppendDataInPieces(buffer->data(), buffer->data_size(), 128);
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  CheckExpectedBuffers(stream, "50P 50 62 86 109 122 125 128");
+  CheckExpectedBuffers(stream, "50KP 50K 62K 86K 109K 122K 125K 128K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), PIPELINE_OK),
       true);
   ASSERT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO));
 
@@ skipping 21 matching lines @@
       ReadTestDataFile("bear-320x240-audio-only-48khz.webm");
   EXPECT_CALL(*this, InitSegmentReceived());
   EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
   ASSERT_TRUE(SetTimestampOffset(kSourceId, duration_1));
   AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512);
   CheckExpectedRanges(kSourceId, "{ [2746,5519) }");
 
   Seek(duration_1);
   ExpectConfigChanged(DemuxerStream::AUDIO);
   ASSERT_FALSE(config_1.Matches(stream->audio_decoder_config()));
-  CheckExpectedBuffers(stream, "2746 2767 2789 2810");
+  CheckExpectedBuffers(stream, "2746K 2767K 2789K 2810K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO | HAS_TEXT));
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append
   // window.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "0K 30 60 90 120K 150 180 210 240K 270 300 330K"),
       MuxedStreamInfo(kTextTrackNum, "0K 100K 200K 300K" ));
 
   // Verify that text cues that start outside the window are not included
   // in the buffer. Also verify that cues that extend beyond the
   // window are not included.
   CheckExpectedRanges(kSourceId, "{ [100,270) }");
-  CheckExpectedBuffers(video_stream, "120 150 180 210 240");
-  CheckExpectedBuffers(text_stream, "100");
+  CheckExpectedBuffers(video_stream, "120K 150 180 210 240K");
+  CheckExpectedBuffers(text_stream, "100K");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "360 390 420K 450 480 510 540K 570 600 630K"),
       MuxedStreamInfo(kTextTrackNum, "400K 500K 600K 700K" ));
   CheckExpectedRanges(kSourceId, "{ [100,270) [400,630) }");
 
   // Seek to the new range and verify that the expected buffers are returned.
   Seek(base::TimeDelta::FromMilliseconds(420));
-  CheckExpectedBuffers(video_stream, "420 450 480 510 540 570 600");
-  CheckExpectedBuffers(text_stream, "400 500");
+  CheckExpectedBuffers(video_stream, "420K 450 480 510 540K 570 600");
+  CheckExpectedBuffers(text_stream, "400K 500K");
 }
 
 TEST_F(ChunkDemuxerTest, StartWaitingForSeekAfterParseError) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   AppendGarbage();
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(50);
   demuxer_->StartWaitingForSeek(seek_time);
 }
 
 TEST_F(ChunkDemuxerTest, Remove_AudioVideoText) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "0K 20K 40K 60K 80K 100K 120K 140K"),
       MuxedStreamInfo(kVideoTrackNum, "0K 30 60 90 120K 150 180"),
       MuxedStreamInfo(kTextTrackNum, "0K 100K 200K"));
 
-  CheckExpectedBuffers(audio_stream, "0 20 40 60 80 100 120 140");
-  CheckExpectedBuffers(video_stream, "0 30 60 90 120 150 180");
-  CheckExpectedBuffers(text_stream, "0 100 200");
+  CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
+  CheckExpectedBuffers(video_stream, "0K 30 60 90 120K 150 180");
+  CheckExpectedBuffers(text_stream, "0K 100K 200K");
 
   // Remove the buffers that were added.
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(300));
 
   // Verify that all the appended data has been removed.
   CheckExpectedRanges(kSourceId, "{ }");
 
   // Append new buffers that are clearly different than the original
   // ones and verify that only the new buffers are returned.
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "1K 21K 41K 61K 81K 101K 121K 141K"),
       MuxedStreamInfo(kVideoTrackNum, "1K 31 61 91 121K 151 181"),
       MuxedStreamInfo(kTextTrackNum, "1K 101K 201K"));
 
   Seek(base::TimeDelta());
-  CheckExpectedBuffers(audio_stream, "1 21 41 61 81 101 121 141");
-  CheckExpectedBuffers(video_stream, "1 31 61 91 121 151 181");
-  CheckExpectedBuffers(text_stream, "1 101 201");
+  CheckExpectedBuffers(audio_stream, "1K 21K 41K 61K 81K 101K 121K 141K");
+  CheckExpectedBuffers(video_stream, "1K 31 61 91 121K 151 181");
+  CheckExpectedBuffers(text_stream, "1K 101K 201K");
 }
 
 TEST_F(ChunkDemuxerTest, Remove_StartAtDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Set the duration to something small so that the append that
   // follows updates the duration to reflect the end of the appended data.
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(1)));
   demuxer_->SetDuration(0.001);
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(160)));
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             "0K 20K 40K 60K 80K 100K 120K 140K");
 
   CheckExpectedRanges(kSourceId, "{ [0,160) }");
-  CheckExpectedBuffers(audio_stream, "0 20 40 60 80 100 120 140");
+  CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 
   demuxer_->Remove(kSourceId,
                    base::TimeDelta::FromSecondsD(demuxer_->GetDuration()),
                    kInfiniteDuration());
 
   Seek(base::TimeDelta());
   CheckExpectedRanges(kSourceId, "{ [0,160) }");
-  CheckExpectedBuffers(audio_stream, "0 20 40 60 80 100 120 140");
+  CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 }
 
 // Verifies that a Seek() will complete without text cues for
 // the seek point and will return cues after the seek position
 // when they are eventually appended.
 TEST_F(ChunkDemuxerTest, SeekCompletesWithoutTextCues) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
@@ skipping 19 matching lines @@
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "0K 20K 40K 60K 80K 100K 120K 140K 160K 180K 200K"),
       MuxedStreamInfo(kVideoTrackNum, "0K 30 60 90 120K 150 180 210"));
 
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(seek_cb_was_called);
   EXPECT_FALSE(text_read_done);
 
   // Read some audio & video buffers to further verify seek completion.
-  CheckExpectedBuffers(audio_stream, "120 140");
-  CheckExpectedBuffers(video_stream, "120 150");
+  CheckExpectedBuffers(audio_stream, "120K 140K");
+  CheckExpectedBuffers(video_stream, "120K 150");
 
   EXPECT_FALSE(text_read_done);
 
   // Append text cues that start after the seek point and verify that
   // they are returned by Read() calls.
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "220K 240K 260K 280K"),
       MuxedStreamInfo(kVideoTrackNum, "240K 270 300 330"),
       MuxedStreamInfo(kTextTrackNum, "225K 275K 325K"));
 
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(text_read_done);
 
   // NOTE: we start at 275 here because the buffer at 225 was returned
   // to the pending read initiated above.
-  CheckExpectedBuffers(text_stream, "275 325");
+  CheckExpectedBuffers(text_stream, "275K 325K");
 
   // Verify that audio & video streams continue to return expected values.
-  CheckExpectedBuffers(audio_stream, "160 180");
+  CheckExpectedBuffers(audio_stream, "160K 180K");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 TEST_F(ChunkDemuxerTest, ClusterWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4, true));
   CheckExpectedRanges(kSourceId, "{ [0,46) }");
 
   // A new cluster indicates end of the previous cluster with unknown size.
@@ skipping 18 matching lines @@
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
   CheckExpectedRanges(kSourceId, "{ [0,115) }");
 }
 
 }  // namespace media