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 "media/filters/chunk_demuxer.h" | 5 #include "media/filters/chunk_demuxer.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <utility> | 10 #include <utility> |
(...skipping 169 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
180 init_segment_received_cb_ = base::Bind( | 180 init_segment_received_cb_ = base::Bind( |
181 &ChunkDemuxerTest::InitSegmentReceived, base::Unretained(this)); | 181 &ChunkDemuxerTest::InitSegmentReceived, base::Unretained(this)); |
182 CreateNewDemuxer(); | 182 CreateNewDemuxer(); |
183 } | 183 } |
184 | 184 |
185 void CreateNewDemuxer() { | 185 void CreateNewDemuxer() { |
186 base::Closure open_cb = | 186 base::Closure open_cb = |
187 base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this)); | 187 base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this)); |
188 Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind( | 188 Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind( |
189 &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this)); | 189 &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this)); |
190 demuxer_.reset(new ChunkDemuxer(open_cb, encrypted_media_init_data_cb, | 190 demuxer_.reset( |
191 media_log_, true)); | 191 new ChunkDemuxer(open_cb, encrypted_media_init_data_cb, media_log_)); |
192 } | 192 } |
193 | 193 |
194 virtual ~ChunkDemuxerTest() { | 194 virtual ~ChunkDemuxerTest() { |
195 ShutdownDemuxer(); | 195 ShutdownDemuxer(); |
196 } | 196 } |
197 | 197 |
198 void CreateInitSegment(int stream_flags, | 198 void CreateInitSegment(int stream_flags, |
199 bool is_audio_encrypted, | 199 bool is_audio_encrypted, |
200 bool is_video_encrypted, | 200 bool is_video_encrypted, |
201 std::unique_ptr<uint8_t[]>* buffer, | 201 std::unique_ptr<uint8_t[]>* buffer, |
(...skipping 661 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
863 // Note: Offsets here and below are derived from | 863 // Note: Offsets here and below are derived from |
864 // media/test/data/bear-640x360-manifest.js and | 864 // media/test/data/bear-640x360-manifest.js and |
865 // media/test/data/bear-320x240-manifest.js which were | 865 // media/test/data/bear-320x240-manifest.js which were |
866 // generated from media/test/data/bear-640x360.webm and | 866 // generated from media/test/data/bear-640x360.webm and |
867 // media/test/data/bear-320x240.webm respectively. | 867 // media/test/data/bear-320x240.webm respectively. |
868 EXPECT_CALL(*this, InitSegmentReceivedMock(_)); | 868 EXPECT_CALL(*this, InitSegmentReceivedMock(_)); |
869 EXPECT_TRUE(AppendData(bear2->data(), 4340)); | 869 EXPECT_TRUE(AppendData(bear2->data(), 4340)); |
870 | 870 |
871 // Append a media segment that goes from [0.527000, 1.014000). | 871 // Append a media segment that goes from [0.527000, 1.014000). |
872 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)); | 872 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)); |
873 EXPECT_MEDIA_LOG(GeneratedSplice(20000, 527000)); | 873 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(527000, 524000, 20000)); |
874 EXPECT_TRUE(AppendData(bear2->data() + 55290, 18785)); | 874 EXPECT_TRUE(AppendData(bear2->data() + 55290, 18785)); |
875 CheckExpectedRanges("{ [0,1027) [1201,2736) }"); | 875 CheckExpectedRanges("{ [0,1027) [1201,2736) }"); |
876 | 876 |
877 // Append initialization segment for bear1 & fill gap with [779-1197) | 877 // Append initialization segment for bear1 & fill gap with [779-1197) |
878 // segment. | 878 // segment. |
879 EXPECT_CALL(*this, InitSegmentReceivedMock(_)); | 879 EXPECT_CALL(*this, InitSegmentReceivedMock(_)); |
880 EXPECT_TRUE(AppendData(bear1->data(), 4370)); | 880 EXPECT_TRUE(AppendData(bear1->data(), 4370)); |
881 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)); | 881 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)); |
882 EXPECT_MEDIA_LOG(GeneratedSplice(26000, 779000)); | 882 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(779000, 759000, 3000)); |
883 EXPECT_TRUE(AppendData(bear1->data() + 72737, 28183)); | 883 EXPECT_TRUE(AppendData(bear1->data() + 72737, 28183)); |
884 CheckExpectedRanges("{ [0,2736) }"); | 884 CheckExpectedRanges("{ [0,2736) }"); |
885 | 885 |
886 MarkEndOfStream(PIPELINE_OK); | 886 MarkEndOfStream(PIPELINE_OK); |
887 return true; | 887 return true; |
888 } | 888 } |
889 | 889 |
890 void ShutdownDemuxer() { | 890 void ShutdownDemuxer() { |
891 if (demuxer_) { | 891 if (demuxer_) { |
892 demuxer_->Shutdown(); | 892 demuxer_->Shutdown(); |
(...skipping 835 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1728 ReadVideo(base::Bind(&OnReadDone, | 1728 ReadVideo(base::Bind(&OnReadDone, |
1729 base::TimeDelta::FromMilliseconds(0), | 1729 base::TimeDelta::FromMilliseconds(0), |
1730 &video_read_done)); | 1730 &video_read_done)); |
1731 | 1731 |
1732 EXPECT_TRUE(audio_read_done); | 1732 EXPECT_TRUE(audio_read_done); |
1733 EXPECT_TRUE(video_read_done); | 1733 EXPECT_TRUE(video_read_done); |
1734 } | 1734 } |
1735 | 1735 |
1736 TEST_F(ChunkDemuxerTest, OutOfOrderClusters) { | 1736 TEST_F(ChunkDemuxerTest, OutOfOrderClusters) { |
1737 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); | 1737 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); |
1738 DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO); | |
1739 DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO); | |
1740 | |
1738 ASSERT_TRUE(AppendCluster(kDefaultFirstCluster())); | 1741 ASSERT_TRUE(AppendCluster(kDefaultFirstCluster())); |
1739 EXPECT_MEDIA_LOG(GeneratedSplice(13000, 10000)); | 1742 CheckExpectedBuffers(audio_stream, "0K 23K"); |
1743 CheckExpectedBuffers(video_stream, "0K 33"); | |
1744 // Note: splice trimming changes durations. These are verified in lower level | |
1745 // tests. See SourceBufferStreamTest.Audio_SpliceTrimmingForOverlap. | |
1746 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(10000, 0, 13000)); | |
1740 ASSERT_TRUE(AppendCluster(GenerateCluster(10, 4))); | 1747 ASSERT_TRUE(AppendCluster(GenerateCluster(10, 4))); |
1748 Seek(base::TimeDelta()); | |
1749 CheckExpectedBuffers(audio_stream, "0K 10K 33K"); | |
1750 CheckExpectedBuffers(video_stream, "0K 10K 43"); | |
1741 | 1751 |
1742 // Make sure that AppendCluster() does not fail with a cluster that has | 1752 // Make sure that AppendCluster() does not fail with a cluster that has |
1743 // overlaps with the previously appended cluster. | 1753 // overlaps with the previously appended cluster. |
1744 EXPECT_MEDIA_LOG(SkippingSpliceAlreadySpliced(0)); | 1754 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(5000, 0, 5000)); |
1745 ASSERT_TRUE(AppendCluster(GenerateCluster(5, 4))); | 1755 ASSERT_TRUE(AppendCluster(GenerateCluster(5, 4))); |
1756 Seek(base::TimeDelta()); | |
1757 CheckExpectedBuffers(audio_stream, "0K 5K 28K"); | |
1758 CheckExpectedBuffers(video_stream, "0K 5K 38"); | |
1746 | 1759 |
1747 // Verify that AppendData() can still accept more data. | 1760 // Verify that AppendData() can still accept more data. |
1748 std::unique_ptr<Cluster> cluster_c(GenerateCluster(45, 2)); | 1761 std::unique_ptr<Cluster> cluster_c(GenerateCluster(45, 2)); |
1749 EXPECT_MEDIA_LOG(GeneratedSplice(6000, 45000)); | 1762 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(45000, 28000, 6000)); |
1750 ASSERT_TRUE(demuxer_->AppendData( | 1763 ASSERT_TRUE(demuxer_->AppendData( |
1751 kSourceId, cluster_c->data(), cluster_c->size(), | 1764 kSourceId, cluster_c->data(), cluster_c->size(), |
1752 append_window_start_for_next_append_, append_window_end_for_next_append_, | 1765 append_window_start_for_next_append_, append_window_end_for_next_append_, |
1753 ×tamp_offset_map_[kSourceId])); | 1766 ×tamp_offset_map_[kSourceId])); |
1767 Seek(base::TimeDelta::FromMilliseconds(45)); | |
1768 CheckExpectedBuffers(audio_stream, "45K"); | |
1769 CheckExpectedBuffers(video_stream, "45K"); | |
1754 } | 1770 } |
1755 | 1771 |
1756 TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) { | 1772 TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) { |
1757 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); | 1773 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); |
1758 ASSERT_TRUE(AppendCluster(kDefaultFirstCluster())); | 1774 ASSERT_TRUE(AppendCluster(kDefaultFirstCluster())); |
1759 | 1775 |
1760 ClusterBuilder cb; | 1776 ClusterBuilder cb; |
1761 | 1777 |
1762 // Test the case where block timecodes are not monotonically | 1778 // Test the case where block timecodes are not monotonically |
1763 // increasing but stay above the cluster timecode. | 1779 // increasing but stay above the cluster timecode. |
(...skipping 308 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2072 // affect the expected ranges. | 2088 // affect the expected ranges. |
2073 CheckExpectedRanges("{ [0,66) }"); | 2089 CheckExpectedRanges("{ [0,66) }"); |
2074 | 2090 |
2075 // Unmark end of stream state and verify that the ranges return to | 2091 // Unmark end of stream state and verify that the ranges return to |
2076 // their pre-"end of stream" values. | 2092 // their pre-"end of stream" values. |
2077 demuxer_->UnmarkEndOfStream(); | 2093 demuxer_->UnmarkEndOfStream(); |
2078 CheckExpectedRanges("{ [0,46) }"); | 2094 CheckExpectedRanges("{ [0,46) }"); |
2079 | 2095 |
2080 // Add text track data and verify that the buffered ranges don't change | 2096 // Add text track data and verify that the buffered ranges don't change |
2081 // since the intersection of all the tracks doesn't change. | 2097 // since the intersection of all the tracks doesn't change. |
2082 EXPECT_MEDIA_LOG(SkippingSpliceAtOrBefore(0, 0)); | |
2083 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(200))); | 2098 EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(200))); |
2084 AppendMuxedCluster(MuxedStreamInfo(kVideoTrackNum, "0K 33", 33), | 2099 AppendMuxedCluster(MuxedStreamInfo(kVideoTrackNum, "0K 33", 33), |
2085 MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23), | 2100 MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23), |
2086 MuxedStreamInfo(kTextTrackNum, "0K 100K")); | 2101 MuxedStreamInfo(kTextTrackNum, "0K 100K")); |
2087 CheckExpectedRanges("{ [0,46) }"); | 2102 CheckExpectedRanges("{ [0,46) }"); |
2088 | 2103 |
2089 // Mark end of stream and verify that text track data is reflected in | 2104 // Mark end of stream and verify that text track data is reflected in |
2090 // the new range. | 2105 // the new range. |
2091 MarkEndOfStream(PIPELINE_OK); | 2106 MarkEndOfStream(PIPELINE_OK); |
2092 CheckExpectedRanges("{ [0,200) }"); | 2107 CheckExpectedRanges("{ [0,200) }"); |
(...skipping 685 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2778 audio_id, GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70))); | 2793 audio_id, GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70))); |
2779 ASSERT_TRUE(AppendCluster( | 2794 ASSERT_TRUE(AppendCluster( |
2780 video_id, GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30))); | 2795 video_id, GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30))); |
2781 CheckExpectedRanges(DemuxerStream::AUDIO, | 2796 CheckExpectedRanges(DemuxerStream::AUDIO, |
2782 "{ [0,23) [300,400) [520,590) [720,750) [900,970) }"); | 2797 "{ [0,23) [300,400) [520,590) [720,750) [900,970) }"); |
2783 CheckExpectedRanges(DemuxerStream::VIDEO, | 2798 CheckExpectedRanges(DemuxerStream::VIDEO, |
2784 "{ [0,33) [320,420) [500,570) [700,770) [920,950) }"); | 2799 "{ [0,33) [320,420) [500,570) [700,770) [920,950) }"); |
2785 CheckExpectedRangesForMediaSource( | 2800 CheckExpectedRangesForMediaSource( |
2786 "{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); | 2801 "{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); |
2787 | 2802 |
2788 // Appending within buffered range should not affect buffered ranges. | 2803 // Audio buffered ranges are trimmed from 970 to 950 due to splicing the |
2789 EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000)); | 2804 // previously buffered audio frame |
2805 // - existing frame trimmed from [900, 970) to [900-930), | |
2806 // - newly appended audio from [930, 950). | |
2807 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(930000, 900000, 40000)); | |
2790 ASSERT_TRUE(AppendCluster( | 2808 ASSERT_TRUE(AppendCluster( |
2791 audio_id, GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20))); | 2809 audio_id, GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20))); |
2810 CheckExpectedRanges(DemuxerStream::AUDIO, | |
2811 "{ [0,23) [300,400) [520,590) [720,750) [900,950) }"); | |
2812 | |
2813 // Video buffer range is unchanged by next append. The time and duration of | |
2814 // the new key frame line up with previous range boundaries. | |
2792 ASSERT_TRUE(AppendCluster( | 2815 ASSERT_TRUE(AppendCluster( |
2793 video_id, GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20))); | 2816 video_id, GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20))); |
2794 CheckExpectedRanges(DemuxerStream::AUDIO, | |
2795 "{ [0,23) [300,400) [520,590) [720,750) [900,970) }"); | |
2796 CheckExpectedRanges(DemuxerStream::VIDEO, | 2817 CheckExpectedRanges(DemuxerStream::VIDEO, |
2797 "{ [0,33) [320,420) [500,570) [700,770) [920,950) }"); | 2818 "{ [0,33) [320,420) [500,570) [700,770) [920,950) }"); |
2819 | |
2798 CheckExpectedRangesForMediaSource( | 2820 CheckExpectedRangesForMediaSource( |
2799 "{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); | 2821 "{ [0,23) [320,400) [520,570) [720,750) [920,950) }"); |
2800 } | 2822 } |
2801 | 2823 |
2802 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) { | 2824 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) { |
2803 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); | 2825 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO)); |
2804 | 2826 |
2805 // Audio block: 0 -> 23 | 2827 // Audio block: 0 -> 23 |
2806 // Video block: 0 -> 33 | 2828 // Video block: 0 -> 33 |
2807 // Buffered Range: 0 -> 23 | 2829 // Buffered Range: 0 -> 23 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2859 // 900, so the added buffered range is 900 -> 950 | 2881 // 900, so the added buffered range is 900 -> 950 |
2860 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "900D70K"), | 2882 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "900D70K"), |
2861 MuxedStreamInfo(kVideoTrackNum, "920D30K")); | 2883 MuxedStreamInfo(kVideoTrackNum, "920D30K")); |
2862 | 2884 |
2863 CheckExpectedRanges(DemuxerStream::AUDIO, | 2885 CheckExpectedRanges(DemuxerStream::AUDIO, |
2864 "{ [0,23) [300,400) [500,590) [700,750) [900,970) }"); | 2886 "{ [0,23) [300,400) [500,590) [700,750) [900,970) }"); |
2865 CheckExpectedRanges(DemuxerStream::VIDEO, | 2887 CheckExpectedRanges(DemuxerStream::VIDEO, |
2866 "{ [0,33) [300,420) [500,570) [700,770) [900,950) }"); | 2888 "{ [0,33) [300,420) [500,570) [700,770) [900,950) }"); |
2867 CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }"); | 2889 CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }"); |
2868 | 2890 |
2869 // Appending within buffered range should not affect buffered ranges. | 2891 // Appending within buffered existing buffered range. |
wolenetz
2016/10/28 23:08:19
nit: s/buffered existing buffered/existing buffere
chcunningham
2016/11/02 01:28:42
Done.
| |
2870 EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000)); | 2892 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(930000, 900000, 40000)); |
2871 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "930D20K"), | 2893 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "930D20K"), |
2872 MuxedStreamInfo(kVideoTrackNum, "930D20K")); | 2894 MuxedStreamInfo(kVideoTrackNum, "930D20K")); |
2873 CheckExpectedRanges(DemuxerStream::AUDIO, | 2895 // Video buffer range is unchanged. The time and duration of the new key frame |
2874 "{ [0,23) [300,400) [500,590) [700,750) [900,970) }"); | 2896 // line up with previous range boundaries. |
2875 CheckExpectedRanges(DemuxerStream::VIDEO, | 2897 CheckExpectedRanges(DemuxerStream::VIDEO, |
2876 "{ [0,33) [300,420) [500,570) [700,770) [900,950) }"); | 2898 "{ [0,33) [300,420) [500,570) [700,770) [900,950) }"); |
2899 | |
2900 // Audio buffered ranges are trimmed from 970 to 950 due to splicing the | |
2901 // previously buffered audio frame. | |
2902 // - existing frame trimmed from [900, 970) to [900, 930), | |
2903 // - newly appended audio from [930, 950). | |
2904 CheckExpectedRanges(DemuxerStream::AUDIO, | |
2905 "{ [0,23) [300,400) [500,590) [700,750) [900,950) }"); | |
2906 | |
2877 CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }"); | 2907 CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }"); |
2878 } | 2908 } |
2879 | 2909 |
2880 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideoText) { | 2910 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideoText) { |
2881 EXPECT_CALL(host_, AddTextStream(_, _)); | 2911 EXPECT_CALL(host_, AddTextStream(_, _)); |
2882 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT)); | 2912 ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT)); |
2883 | 2913 |
2884 // Append audio & video data | 2914 // Append audio & video data |
2885 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23), | 2915 AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23), |
2886 MuxedStreamInfo(kVideoTrackNum, "0K 33", 33)); | 2916 MuxedStreamInfo(kVideoTrackNum, "0K 33", 33)); |
(...skipping 302 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3189 // config changes. | 3219 // config changes. |
3190 ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp); | 3220 ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp); |
3191 ASSERT_EQ(status, DemuxerStream::kOk); | 3221 ASSERT_EQ(status, DemuxerStream::kOk); |
3192 } | 3222 } |
3193 | 3223 |
3194 TEST_F(ChunkDemuxerTest, ConfigChange_Audio) { | 3224 TEST_F(ChunkDemuxerTest, ConfigChange_Audio) { |
3195 InSequence s; | 3225 InSequence s; |
3196 | 3226 |
3197 ASSERT_TRUE(InitDemuxerWithConfigChangeData()); | 3227 ASSERT_TRUE(InitDemuxerWithConfigChangeData()); |
3198 | 3228 |
3229 /* | |
wolenetz
2016/10/28 23:08:19
Please uncomment this test's body :)
chcunningham
2016/11/02 01:28:42
Lol, Done.
| |
3230 | |
3199 DemuxerStream::Status status; | 3231 DemuxerStream::Status status; |
3200 base::TimeDelta last_timestamp; | 3232 base::TimeDelta last_timestamp; |
3201 | 3233 |
3202 DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO); | 3234 DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO); |
3203 | 3235 |
3204 // Fetch initial audio config and verify it matches what we expect. | 3236 // Fetch initial audio config and verify it matches what we expect. |
3205 const AudioDecoderConfig& audio_config_1 = audio->audio_decoder_config(); | 3237 const AudioDecoderConfig& audio_config_1 = audio->audio_decoder_config(); |
3206 ASSERT_TRUE(audio_config_1.IsValidConfig()); | 3238 ASSERT_TRUE(audio_config_1.IsValidConfig()); |
3207 EXPECT_EQ(audio_config_1.samples_per_second(), 44100); | 3239 EXPECT_EQ(audio_config_1.samples_per_second(), 44100); |
3208 EXPECT_EQ(audio_config_1.extra_data().size(), 3863u); | 3240 EXPECT_EQ(audio_config_1.extra_data().size(), 3863u); |
3209 | 3241 |
3210 ExpectRead(DemuxerStream::AUDIO, 0); | 3242 ExpectRead(DemuxerStream::AUDIO, 0); |
3211 | 3243 |
3212 // The first config change seen is from a splice frame representing an overlap | 3244 // Read until we encounter config 2. |
3213 // of buffer from config 1 by buffers from config 2. | |
3214 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); | 3245 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); |
3215 ASSERT_EQ(status, DemuxerStream::kConfigChanged); | 3246 ASSERT_EQ(status, DemuxerStream::kConfigChanged); |
3216 EXPECT_EQ(last_timestamp.InMilliseconds(), 524); | 3247 EXPECT_EQ(last_timestamp.InMilliseconds(), 524); |
3217 | 3248 |
3218 // Fetch the new decoder config. | 3249 // Fetch the new decoder config. |
3219 const AudioDecoderConfig& audio_config_2 = audio->audio_decoder_config(); | 3250 const AudioDecoderConfig& audio_config_2 = audio->audio_decoder_config(); |
3220 ASSERT_TRUE(audio_config_2.IsValidConfig()); | 3251 ASSERT_TRUE(audio_config_2.IsValidConfig()); |
3221 EXPECT_EQ(audio_config_2.samples_per_second(), 44100); | 3252 EXPECT_EQ(audio_config_2.samples_per_second(), 44100); |
3222 EXPECT_EQ(audio_config_2.extra_data().size(), 3935u); | 3253 EXPECT_EQ(audio_config_2.extra_data().size(), 3935u); |
3223 | 3254 |
3224 // The next config change is from a splice frame representing an overlap of | 3255 // Read until we encounter config 1 again. |
3225 // buffers from config 2 by buffers from config 1. | |
3226 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); | 3256 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); |
3227 ASSERT_EQ(status, DemuxerStream::kConfigChanged); | 3257 ASSERT_EQ(status, DemuxerStream::kConfigChanged); |
3228 EXPECT_EQ(last_timestamp.InMilliseconds(), 782); | 3258 EXPECT_EQ(last_timestamp.InMilliseconds(), 759); |
3229 ASSERT_TRUE(audio_config_1.Matches(audio->audio_decoder_config())); | 3259 ASSERT_TRUE(audio_config_1.Matches(audio->audio_decoder_config())); |
3230 | 3260 |
3231 // Read until the end of the stream just to make sure there aren't any other | 3261 // Read until the end of the stream just to make sure there aren't any other |
3232 // config changes. | 3262 // config changes. |
3233 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); | 3263 ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp); |
3234 ASSERT_EQ(status, DemuxerStream::kOk); | 3264 ASSERT_EQ(status, DemuxerStream::kOk); |
3235 EXPECT_EQ(last_timestamp.InMilliseconds(), 2744); | 3265 EXPECT_EQ(last_timestamp.InMilliseconds(), 2744); |
3266 */ | |
3236 } | 3267 } |
3237 | 3268 |
3238 TEST_F(ChunkDemuxerTest, ConfigChange_Seek) { | 3269 TEST_F(ChunkDemuxerTest, ConfigChange_Seek) { |
3239 InSequence s; | 3270 InSequence s; |
3240 | 3271 |
3241 ASSERT_TRUE(InitDemuxerWithConfigChangeData()); | 3272 ASSERT_TRUE(InitDemuxerWithConfigChangeData()); |
3242 | 3273 |
3243 DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO); | 3274 DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO); |
3244 | 3275 |
3245 // Fetch initial video config and verify it matches what we expect. | 3276 // Fetch initial video config and verify it matches what we expect. |
(...skipping 278 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3524 true, true, true, true, false, | 3555 true, true, true, true, false, |
3525 }; | 3556 }; |
3526 | 3557 |
3527 static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues), | 3558 static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues), |
3528 "test arrays out of sync"); | 3559 "test arrays out of sync"); |
3529 static_assert(arraysize(kBuffer) == sizeof(kBuffer), | 3560 static_assert(arraysize(kBuffer) == sizeof(kBuffer), |
3530 "there should be one byte per index"); | 3561 "there should be one byte per index"); |
3531 | 3562 |
3532 ASSERT_TRUE(InitDemuxer(HAS_AUDIO)); | 3563 ASSERT_TRUE(InitDemuxer(HAS_AUDIO)); |
3533 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)).Times(2); | 3564 EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)).Times(2); |
3534 EXPECT_MEDIA_LOG(GeneratedSplice(22000, 2000)); | 3565 EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(2000, 1000, 22000)); |
3535 for (size_t i = 0; i < sizeof(kBuffer); i++) { | 3566 for (size_t i = 0; i < sizeof(kBuffer); i++) { |
3536 DVLOG(3) << "Appending and testing index " << i; | 3567 DVLOG(3) << "Appending and testing index " << i; |
3537 ASSERT_TRUE(AppendData(kBuffer + i, 1)); | 3568 ASSERT_TRUE(AppendData(kBuffer + i, 1)); |
3538 bool expected_return_value = kExpectedReturnValues[i]; | 3569 bool expected_return_value = kExpectedReturnValues[i]; |
3539 EXPECT_EQ(expected_return_value, | 3570 EXPECT_EQ(expected_return_value, |
3540 demuxer_->IsParsingMediaSegment(kSourceId)); | 3571 demuxer_->IsParsingMediaSegment(kSourceId)); |
3541 } | 3572 } |
3542 } | 3573 } |
3543 | 3574 |
3544 TEST_F(ChunkDemuxerTest, DurationChange) { | 3575 TEST_F(ChunkDemuxerTest, DurationChange) { |
(...skipping 1167 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4712 demuxer_->RemoveId(kId1); | 4743 demuxer_->RemoveId(kId1); |
4713 EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO)); | 4744 EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO)); |
4714 EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO)); | 4745 EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO)); |
4715 } | 4746 } |
4716 | 4747 |
4717 // TODO(servolk): Add a unit test with multiple audio/video tracks using the | 4748 // TODO(servolk): Add a unit test with multiple audio/video tracks using the |
4718 // same codec type in a single SourceBufferState, when WebM parser supports | 4749 // same codec type in a single SourceBufferState, when WebM parser supports |
4719 // multiple tracks. crbug.com/646900 | 4750 // multiple tracks. crbug.com/646900 |
4720 | 4751 |
4721 } // namespace media | 4752 } // namespace media |
OLD | NEW |