Mirror-Tools
/
shaka-packager
mirror of https://github.com/shaka-project/shaka-packager.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
shaka-packager/packager/media/chunking/text_chunker_unittest.cc

672 lines
23 KiB
C++
Raw Normal View History

chore: Mass-update copyright headers (#1086) Closes #1076
2022-08-26 15:44:59 +00:00
// Copyright 2017 Google LLC. All rights reserved.
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
feat: port media/chunking to CMake (#1223) Port media/chunking to CMake Related to #1047
2023-07-05 22:18:36 +00:00
#include "packager/media/chunking/text_chunker.h"
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "packager/media/base/media_handler_test_base.h"
feat: port media/chunking to CMake (#1223) Port media/chunking to CMake Related to #1047
2023-07-05 22:18:36 +00:00
#include "packager/status/status_test_util.h"
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
using ::testing::_;
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
namespace shaka {
namespace media {
namespace {
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const uint64_t kStreamIndex = 0;
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
const int64_t kTimescaleMs = 1000;
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const size_t kInputs = 1;
const size_t kOutputs = 1;
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const size_t kInput = 0;
const size_t kOutput = 0;
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
const bool kEncrypted = true;
const bool kSubSegment = true;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const char* kNoId = "";
const char* kNoPayload = "";
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
} // namespace
Rename WebVttSegmenter To TextChunker Renamed the webvtt segmenter to text chunker as there is nothing webvtt specific in the code. Change-Id: I0111c50d545fa168d945b39bc8a78c46c62678be
2018-03-23 22:28:30 +00:00
class TextChunkerTest : public MediaHandlerTestBase {
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
protected:
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
Status Init(double segment_duration) {
return SetUpAndInitializeGraph(
std::make_shared<TextChunker>(segment_duration), kInputs, kOutputs);
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
};
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// Verify that the chunker will use the first sample's start time as the start
// time for the first segment.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1 2 2 3
// 0 0 5 0 5 0
// 0 0 0 0 0
// SAMPLES : [-----A-----]
// SEGMENTS : ^ ^ ^
//
TEST_F(TextChunkerTest, SegmentsStartAtFirstSample) {
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
const int64_t kSegment0Start = 100;
const int64_t kSegment1Start = 200;
const int64_t kSampleAStart = 120;
const int64_t kSampleAEnd = 220;
ASSERT_OK(Init(kSegmentDurationSec));
{
testing::InSequence s;
EXPECT_CALL(*Output(kOutput), OnProcess(IsStreamInfo(_, _, _, _)));
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsTextSample(_, _, kSampleAStart, kSampleAEnd)));
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsSegmentInfo(_, kSegment0Start, kSegmentDurationMs, _, _)));
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsTextSample(_, _, kSampleAStart, kSampleAEnd)));
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsSegmentInfo(_, kSegment1Start, kSegmentDurationMs, _, _)));
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Verify that when a sample elapses a full segment, that it only appears
// in the one segment.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1
// 0 0
// 0
// SAMPLES :[-----A-----]
// SEGMENTS : ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, SampleEndingOnSegmentStart) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment0Start = 0;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleAStart = 0;
const int64_t kSampleAEnd = 100;
Init(kSegmentDurationSec);
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Verify that samples only appear in the correct segments when they only exist
// in one segment.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1 2
// 0 0 5 0
// 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--A--]
// [--B--]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// SEGMENTS : ^ ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, CreatesSegmentsForSamples) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
const int64_t kSampleAEnd = 50;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleBStart = 100;
const int64_t kSampleBEnd = 150;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
// Segment One
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
// Segment Two
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleBStart, kSampleBEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Verify that a segment will get outputted even if there are no samples
// overlapping with it.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1 2 2 3
// 0 0 5 0 5 0
// 0 0 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--A--]
// [--B--]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// SEGMENTS : ^ ^ ^
//
Rename WebVttSegmenter To TextChunker Renamed the webvtt segmenter to text chunker as there is nothing webvtt specific in the code. Change-Id: I0111c50d545fa168d945b39bc8a78c46c62678be
2018-03-23 22:28:30 +00:00
TEST_F(TextChunkerTest, OutputsEmptySegments) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
const int64_t kSegment2Start = 200;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
const int64_t kSampleAEnd = 50;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleBStart = 200;
const int64_t kSampleBEnd = 250;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Output Empty WebVTT Text Segments Have the text webvtt pipeline output empty segments rather than skipping them. Bug: #324 Change-Id: I175cf22b65b241f6bf566aba2440518f3df95277
2018-02-05 19:16:00 +00:00
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
// Segment One
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Output Empty WebVTT Text Segments Have the text webvtt pipeline output empty segments rather than skipping them. Bug: #324 Change-Id: I175cf22b65b241f6bf566aba2440518f3df95277
2018-02-05 19:16:00 +00:00
// Segment Two (empty segment)
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Output Empty WebVTT Text Segments Have the text webvtt pipeline output empty segments rather than skipping them. Bug: #324 Change-Id: I175cf22b65b241f6bf566aba2440518f3df95277
2018-02-05 19:16:00 +00:00
// Segment Three
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment2Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleBStart, kSampleBEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Verify that samples that overlap multiple samples get dispatch in all
// segments.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1
// 0 0 5
// 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--------A--------]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// SEGMENTS : ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, SampleCrossesSegments) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleAEnd = 150;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
// Segment One
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Changed Text Segmenter to output segment info last To better align with the Chunking Handler, the Text Segmenter now outputs the SegmentInfo at the end of the segment rather than the start. Change-Id: If69ab951947d00779b4b63a52c4b6662bbdc4c0d
2018-01-02 21:58:47 +00:00
// Segment Two
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Verify that samples that overlap multiple samples get dispatch in all
// segments, even if different samples elapse different number of segments.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1 2 2 3
// 0 0 5 0 5 0
// 0 0 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--------A--------]
// [--------B--------]
// [-----------------C-----------]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// SEGMENTS : ^ ^ ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, PreservesOrder) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
const int64_t kSegment2Start = 200;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleAEnd = 150;
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleBStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleBEnd = 150;
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleCStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleCEnd = 250;
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const char* kSampleAId = "sample 0";
const char* kSampleBId = "sample 1";
const char* kSampleCId = "sample 2";
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
// Segment One
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleAId, kSampleAStart, kSampleAEnd)));
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleBId, kSampleBStart, kSampleBEnd)));
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleCId, kSampleCStart, kSampleCEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment Two
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleAId, kSampleAStart, kSampleAEnd)));
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleBId, kSampleBStart, kSampleBEnd)));
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleCId, kSampleCStart, kSampleCEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
// Segment Two
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
EXPECT_CALL(
*Output(kOutput),
OnProcess(IsTextSample(_, kSampleCId, kSampleCStart, kSampleCEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment2Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kSampleAId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kSampleBId, kSampleBStart, kSampleBEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kSampleCId, kSampleCStart, kSampleCEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Check that when samples overlap/contain other samples, that they still
// get outputted in the correct segments.
//
// Segment Duration = 50 MS
//
// TIME (ms):0 5 1 1 2 2
// 0 0 5 0 5
// 0 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--------------A--------------]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// [-----B------]
// SEGMENTS : ^ ^ ^ ^ ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, NestedSamples) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.05;
const int64_t kSegmentDurationMs = 50;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
const int64_t kSampleAEnd = 250;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleBStart = 75;
const int64_t kSampleBEnd = 175;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 50;
const int64_t kSegment2Start = 100;
const int64_t kSegment3Start = 150;
const int64_t kSegment4Start = 200;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 0
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 1
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 2
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment2Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 3
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment3Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 4
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment4Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleBStart, kSampleBEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Make sure that a sample that extends multiple segments is dropped when
// it no longer overlaps with a later segment.
//
// Segment Duration = 100 MS
//
// TIME (ms):0 5 1 1 2 2 3
// 0 0 5 0 5 0
// 0 0 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[-----------A-----------]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// [--B--]
// SEGMENTS : ^ ^ ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, SecondSampleStartsAfterMultiSegmentSampleEnds) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.1;
const int64_t kSegmentDurationMs = 100;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
const int64_t kSegment2Start = 200;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleAEnd = 200;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleBStart = 200;
const int64_t kSampleBEnd = 250;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
Init(kSegmentDurationSec);
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
{
testing::InSequence s;
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment One
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment Two
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment Three
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleBStart, kSampleBEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment2Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput), OnFlush(kStreamIndex));
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleBStart, kSampleBEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
}
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// Check that segments will be injected when a cue event comes down the
// pipeline and that the segment duration will get reset after the cues
// are dispatched.
//
// Segment Duration = 300 MS
//
// TIME (ms):0 5 1 1 2 2 3 3 4 5
// 0 0 5 0 5 0 5 5 0
// 0 0 0 0 0 0 0 0
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
// SAMPLES :[--------------A--------------]
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
// CUES : ^ ^
// SEGMENTS : ^ ^ ^
//
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
TEST_F(TextChunkerTest, SampleSpanningMultipleCues) {
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegmentDurationSec = 0.3;
const int64_t kSegmentDurationMs = 300;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Start Segments At First Sample in Text Chunker We always assumed that text stream started at zero in the text chunker. This meant that if the text stream started later than zero (like in a live stream) we would generate a lot of empty segments. Instead the text chunker will assume that segments should be adjusted to align with multiple of segment duration. The text chunker will assume that an earlier component in the pipeline (i.e. text padder) will ensure that the first sample has the time that we want to start segments at (even it needs to add an empty sample). Issue #416 Change-Id: Ie45844354d6e9448787cae896841b5ab31721ed6
2018-06-21 18:31:09 +00:00
const int64_t kSampleAStart = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSampleAEnd = 250;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kC0 = 0.1;
const double kC1 = 0.2;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
const int64_t kSegment0Start = 0;
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const int64_t kSegment1Start = 100;
const int64_t kSegment2Start = 200;
;
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
const double kSegment0StartLength = 100;
const double kSegment1StartLength = 100;
Init(kSegmentDurationSec);
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
{
testing::InSequence s;
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsStreamInfo(kStreamIndex, _, _, _)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 0 and Cue 0
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
OnProcess(IsSegmentInfo(kStreamIndex, kSegment0Start,
kSegment0StartLength, !kSubSegment,
!kEncrypted)));
EXPECT_CALL(*Output(kOutput), OnProcess(IsCueEvent(kStreamIndex, kC0)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 1 and Cue 1
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
EXPECT_CALL(*Output(kOutput),
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
OnProcess(IsSegmentInfo(kStreamIndex, kSegment1Start,
kSegment1StartLength, !kSubSegment,
!kEncrypted)));
EXPECT_CALL(*Output(kOutput), OnProcess(IsCueEvent(kStreamIndex, kC1)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
// Segment 2
EXPECT_CALL(*Output(kOutput),
Add text fragment and setting types. This sets the groundwork for more generic text cues by having a more generic object for the settings and the body. This also changes the TextSample to be immutable and accepts the fields in the constructor instead of using setters. Change-Id: I76b09ce8e8471a49e6bf447e8c187f867728a4bf
2020-08-24 22:23:15 +00:00
OnProcess(IsTextSample(_, kNoId, kSampleAStart, kSampleAEnd)));
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
EXPECT_CALL(*Output(kOutput),
OnProcess(IsSegmentInfo(kStreamIndex, kSegment2Start,
kSegmentDurationMs, !kSubSegment,
!kEncrypted)));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
}
Make Test Util 'GetTextStreamInfo' require Time Scale Make the text stream info factory method in media_handler_test_base require the caller to specify the time scale. Issue: #399 Change-Id: Ibdfb183e0aa3f4ff50edf6b58c4e9b966006c6d2
2018-06-06 18:41:21 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
StreamData::FromCueEvent(kStreamIndex, GetCueEvent(kC0))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->Dispatch(
Remove Time Scale Assumptions From Text Chunker Before, the text chunker would assume that all text streams were in MS, which is not a safe assumption to make. This changes it to take the time scale from StreamInfo and work natively with scaled time units. This required updating the tests. While doing so the tests were rewritten with the goal to make them easier to read. Closes: #399 Change-Id: Ib792ad306f40d749763418cde645337913a6046b
2018-06-06 18:41:21 +00:00
StreamData::FromCueEvent(kStreamIndex, GetCueEvent(kC1))));
Handle CueEvent in TextChunker Updated TextChunker to handle incoming CueEvents. Connecting the text chunker with the cue alignment handler will happen in a later CL. Issue: #362 Change-Id: Ib1fa9f457cf4ec0ce413dadcfa7eed5895ecd628
2018-03-23 01:33:01 +00:00
ASSERT_OK(Input(kInput)->FlushAllDownstreams());
Create Preserve Order Test Create WebVtt test that shows that the current implementation of the webvtt segmenter does not respect the input order of cues. Bug: 72867775 Change-Id: I811b3a93c10650e0cf9290c9c0c1680f562deb30
2018-02-02 22:28:10 +00:00
}
Created WebVtt Segmenter This change creates the webvtt segmenter which will be used for segmented text webvtt for HLS. It takes a stream of text samples and injects segment info messages based on the segment duration. It is possible for samples to extend between segments, if so the sample will appear twice (once in each segment). Change-Id: Iae0134ee61cf269948026086520b6d3f8ce3785b
2017-09-18 15:43:21 +00:00
} // namespace media
} // namespace shaka