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/cue_alignment_handler_unitt...

616 lines
22 KiB
C++
Raw Normal View History

Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
// Copyright 2018 Google Inc. All rights reserved.
//
// 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
#include "packager/media/chunking/chunking_handler.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "packager/media/base/media_handler_test_base.h"
#include "packager/media/chunking/cue_alignment_handler.h"
#include "packager/media/public/ad_cue_generator_params.h"
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
#include "packager/status_macros.h"
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
#include "packager/status_test_util.h"
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::_;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
using ::testing::ElementsAre;
using ::testing::IsEmpty;
namespace shaka {
namespace media {
namespace {
const size_t kOneInput = 1;
const size_t kOneOutput = 1;
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
const size_t kThreeInputs = 3;
const size_t kThreeOutputs = 3;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
const bool kKeyFrame = true;
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
const uint32_t kMsTimeScale = 1000;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
const size_t kStreamIndex = 0;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
} // namespace
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
class CueAlignmentHandlerTest : public MediaHandlerTestBase {
protected:
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
std::unique_ptr<SyncPointQueue> CreateSyncPoints(
std::initializer_list<double> cues) {
AdCueGeneratorParams params;
for (double cue_time : cues) {
Cuepoint cue;
cue.start_time_in_seconds = cue_time;
params.cue_points.push_back(cue);
}
return std::unique_ptr<SyncPointQueue>(new SyncPointQueue(params));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
Status DispatchAudioInfo(size_t input_index) {
auto info = GetAudioStreamInfo(kMsTimeScale);
auto data = StreamData::FromStreamInfo(kStreamIndex, std::move(info));
return Input(input_index)->Dispatch(std::move(data));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
Status DispatchTextInfo(size_t input_index) {
auto info = GetTextStreamInfo(kMsTimeScale);
auto data = StreamData::FromStreamInfo(kStreamIndex, std::move(info));
return Input(input_index)->Dispatch(std::move(data));
}
Status DispatchVideoInfo(size_t input_index) {
auto info = GetVideoStreamInfo(kMsTimeScale);
auto data = StreamData::FromStreamInfo(kStreamIndex, std::move(info));
return Input(input_index)->Dispatch(std::move(data));
}
Status DispatchMediaSample(size_t input_index,
int64_t start_time,
int64_t duration,
bool keyframe) {
auto sample = GetMediaSample(start_time, duration, keyframe);
auto data = StreamData::FromMediaSample(kStreamIndex, std::move(sample));
return Input(input_index)->Dispatch(std::move(data));
}
Status DispatchTextSample(size_t input_index,
int64_t start_time,
int64_t end_time) {
const char* kNoId = "";
const char* kNoPayload = "";
auto sample = GetTextSample(kNoId, start_time, end_time, kNoPayload);
auto data = StreamData::FromTextSample(kStreamIndex, std::move(sample));
return Input(input_index)->Dispatch(std::move(data));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
}
Status FlushAll(std::initializer_list<size_t> inputs) {
for (auto& input : inputs) {
RETURN_IF_ERROR(Input(input)->FlushAllDownstreams());
}
return Status::OK;
}
};
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
TEST_F(CueAlignmentHandlerTest, VideoInputWithNoCues) {
const size_t kVideoStream = 0;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
const int64_t kSample1Start = kSample0Start + kSampleDuration;
const int64_t kSample2Start = kSample1Start + kSampleDuration;
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points = CreateSyncPoints({});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchVideoInfo(kVideoStream));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample1Start, kSampleDuration,
!kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kVideoStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, AudioInputWithNoCues) {
const size_t kAudioStream = 0;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
const int64_t kSample1Start = kSample0Start + kSampleDuration;
const int64_t kSample2Start = kSample1Start + kSampleDuration;
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points = CreateSyncPoints({});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchAudioInfo(kAudioStream));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample1Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kAudioStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, TextInputWithNoCues) {
const size_t kTextStream = 0;
const int64_t kSampleDuration = 1000;
Change Text Sample to Use int64_t Changed Text Sample to use int64_t so that it will use the same type for time as Media Sample. Change-Id: I4cfbfdc60c37bb511517993976cd1a459bdf6667
2018-03-26 18:04:09 +00:00
const int64_t kSample0Start = 0;
const int64_t kSample0End = kSample0Start + kSampleDuration;
const int64_t kSample1Start = kSample0End;
const int64_t kSample1End = kSample1Start + kSampleDuration;
const int64_t kSample2Start = kSample1End;
const int64_t kSample2End = kSample2Start + kSampleDuration;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points = CreateSyncPoints({});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample0Start, kSample0End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample1Start, kSample1End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample2Start, kSample2End)));
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
EXPECT_CALL(*Output(kTextStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextInfo(kTextStream));
ASSERT_OK(DispatchTextSample(kTextStream, kSample0Start, kSample0End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample1Start, kSample1End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample2Start, kSample2End));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kTextStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, TextAudioVideoInputWithNoCues) {
const size_t kTextStream = 0;
const size_t kAudioStream = 1;
const size_t kVideoStream = 2;
Change Text Sample to Use int64_t Changed Text Sample to use int64_t so that it will use the same type for time as Media Sample. Change-Id: I4cfbfdc60c37bb511517993976cd1a459bdf6667
2018-03-26 18:04:09 +00:00
const int64_t kSampleDuration = 1000;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
Change Text Sample to Use int64_t Changed Text Sample to use int64_t so that it will use the same type for time as Media Sample. Change-Id: I4cfbfdc60c37bb511517993976cd1a459bdf6667
2018-03-26 18:04:09 +00:00
const int64_t kSample0Start = 0;
const int64_t kSample0End = kSample0Start + kSampleDuration;
const int64_t kSample1Start = kSample0Start + kSampleDuration;
const int64_t kSample1End = kSample1Start + kSampleDuration;
const int64_t kSample2Start = kSample1Start + kSampleDuration;
const int64_t kSample2End = kSample2Start + kSampleDuration;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points = CreateSyncPoints({});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
ASSERT_OK(SetUpAndInitializeGraph(handler, kThreeInputs, kThreeOutputs));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample0Start, kSample0End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample1Start, kSample1End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample2Start, kSample2End)));
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
EXPECT_CALL(*Output(kTextStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Stream Info
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextInfo(kTextStream));
ASSERT_OK(DispatchAudioInfo(kAudioStream));
ASSERT_OK(DispatchVideoInfo(kVideoStream));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 0
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample0Start, kSample0End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample0Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 1
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample1Start, kSample1End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample1Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample1Start, kSampleDuration,
!kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 2
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample2Start, kSample2End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample2Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kTextStream, kAudioStream, kVideoStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, VideoInputWithCues) {
const size_t kVideoStream = 0;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
const int64_t kSample1Start = kSample0Start + kSampleDuration;
const int64_t kSample2Start = kSample1Start + kSampleDuration;
const double kSample2StartInSeconds =
static_cast<double>(kSample2Start) / kMsTimeScale;
// Put the cue between two key frames.
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points =
CreateSyncPoints({static_cast<double>(kSample1Start) / kMsTimeScale});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample2StartInSeconds)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchVideoInfo(kVideoStream));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample1Start, kSampleDuration,
!kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kVideoStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, AudioInputWithCues) {
const size_t kAudioStream = 0;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
const int64_t kSample1Start = kSample0Start + kSampleDuration;
const int64_t kSample2Start = kSample1Start + kSampleDuration;
const double kSample1StartInSeconds =
static_cast<double>(kSample1Start) / kMsTimeScale;
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points =
CreateSyncPoints({static_cast<double>(kSample1Start) / kMsTimeScale});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample1StartInSeconds)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchAudioInfo(kAudioStream));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample1Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kAudioStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, TextInputWithCues) {
const size_t kTextStream = 0;
const int64_t kSampleDuration = 1000;
Change Text Sample to Use int64_t Changed Text Sample to use int64_t so that it will use the same type for time as Media Sample. Change-Id: I4cfbfdc60c37bb511517993976cd1a459bdf6667
2018-03-26 18:04:09 +00:00
const int64_t kSample0Start = 0;
const int64_t kSample0End = kSample0Start + kSampleDuration;
const int64_t kSample1Start = kSample0End;
const int64_t kSample1End = kSample1Start + kSampleDuration;
const int64_t kSample2Start = kSample1End;
const int64_t kSample2End = kSample2Start + kSampleDuration;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
const double kSample1StartInSeconds =
static_cast<double>(kSample1Start) / kMsTimeScale;
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points =
CreateSyncPoints({static_cast<double>(kSample1Start) / kMsTimeScale});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample0Start, kSample0End)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample1StartInSeconds)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample1Start, kSample1End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample2Start, kSample2End)));
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
EXPECT_CALL(*Output(kTextStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextInfo(kTextStream));
ASSERT_OK(DispatchTextSample(kTextStream, kSample0Start, kSample0End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample1Start, kSample1End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample2Start, kSample2End));
Fix Cue Insertion at Text Stream End Problem : Text samples have variable length and therefore act more like continuous samples whereas audio and video act more like discrete samples. Since we use sample start time, a cue event could be inserted after the start time of the last text sample and never get inserted as there are no more samples. Change : After all streams have requested flushing, we make sure to collect all remaining cue events from the sync point queue and insert them into each stream. Issue #362 Change-Id: Id8f136f7ef53531f7a7f412613eac352324e0130
2018-05-14 20:46:03 +00:00
ASSERT_OK(FlushAll({kTextStream}));
}
TEST_F(CueAlignmentHandlerTest, TextInputWithCueAfterLastStart) {
const size_t kTextStream = 0;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
const int64_t kSample0End = kSample0Start + kSampleDuration;
const int64_t kSample1Start = kSample0End;
const int64_t kSample1End = kSample1Start + kSampleDuration;
const int64_t kSample2Start = kSample1End;
const int64_t kSample2End = kSample2Start + kSampleDuration;
Ignore extra Ad cues at the end of the stream They will result in empty DASH representations, which is not spec compliant. For text, if the cue is before the max end time, it will still be dispatched as the text samples intercepted by the cue can be split into two at the cue point. Bug: 111359775. Change-Id: I55c2025c4e9d64c88e6a685c0cf3024a0cc4a6d8
2018-07-20 17:31:26 +00:00
// Put the cue 1 between the start and end of the last sample.
const double kCue1TimeInSeconds =
static_cast<double>(kSample2Start + kSample2End) / 2 / kMsTimeScale;
Fix Cue Insertion at Text Stream End Problem : Text samples have variable length and therefore act more like continuous samples whereas audio and video act more like discrete samples. Since we use sample start time, a cue event could be inserted after the start time of the last text sample and never get inserted as there are no more samples. Change : After all streams have requested flushing, we make sure to collect all remaining cue events from the sync point queue and insert them into each stream. Issue #362 Change-Id: Id8f136f7ef53531f7a7f412613eac352324e0130
2018-05-14 20:46:03 +00:00
Ignore extra Ad cues at the end of the stream They will result in empty DASH representations, which is not spec compliant. For text, if the cue is before the max end time, it will still be dispatched as the text samples intercepted by the cue can be split into two at the cue point. Bug: 111359775. Change-Id: I55c2025c4e9d64c88e6a685c0cf3024a0cc4a6d8
2018-07-20 17:31:26 +00:00
// Put the cue 2 after the end of the last sample.
const double kCue2TimeInSeconds =
static_cast<double>(kSample2End) / kMsTimeScale;
auto sync_points = CreateSyncPoints({kCue1TimeInSeconds, kCue2TimeInSeconds});
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
Add Missing ASSERT_OK Calls in Cue Alignment Tests The SetUpAndInitialize function returns a status. We were not asserting that it return an OK status. This change adds the missing ASSERT_OK calls. Change-Id: I044f60c0450d46fc0f6495319b1ed7ef8ab6e794
2018-05-22 21:24:50 +00:00
ASSERT_OK(SetUpAndInitializeGraph(handler, kOneInput, kOneOutput));
Fix Cue Insertion at Text Stream End Problem : Text samples have variable length and therefore act more like continuous samples whereas audio and video act more like discrete samples. Since we use sample start time, a cue event could be inserted after the start time of the last text sample and never get inserted as there are no more samples. Change : After all streams have requested flushing, we make sure to collect all remaining cue events from the sync point queue and insert them into each stream. Issue #362 Change-Id: Id8f136f7ef53531f7a7f412613eac352324e0130
2018-05-14 20:46:03 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample0Start, kSample0End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample1Start, kSample1End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample2Start, kSample2End)));
Ignore extra Ad cues at the end of the stream They will result in empty DASH representations, which is not spec compliant. For text, if the cue is before the max end time, it will still be dispatched as the text samples intercepted by the cue can be split into two at the cue point. Bug: 111359775. Change-Id: I55c2025c4e9d64c88e6a685c0cf3024a0cc4a6d8
2018-07-20 17:31:26 +00:00
// Cue before the sample end is processed.
Fix Cue Insertion at Text Stream End Problem : Text samples have variable length and therefore act more like continuous samples whereas audio and video act more like discrete samples. Since we use sample start time, a cue event could be inserted after the start time of the last text sample and never get inserted as there are no more samples. Change : After all streams have requested flushing, we make sure to collect all remaining cue events from the sync point queue and insert them into each stream. Issue #362 Change-Id: Id8f136f7ef53531f7a7f412613eac352324e0130
2018-05-14 20:46:03 +00:00
EXPECT_CALL(*Output(kTextStream),
Ignore extra Ad cues at the end of the stream They will result in empty DASH representations, which is not spec compliant. For text, if the cue is before the max end time, it will still be dispatched as the text samples intercepted by the cue can be split into two at the cue point. Bug: 111359775. Change-Id: I55c2025c4e9d64c88e6a685c0cf3024a0cc4a6d8
2018-07-20 17:31:26 +00:00
OnProcess(IsCueEvent(_, kCue1TimeInSeconds)));
// Cue after the samples is ignored.
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
EXPECT_CALL(*Output(kTextStream), OnFlush(_));
Fix Cue Insertion at Text Stream End Problem : Text samples have variable length and therefore act more like continuous samples whereas audio and video act more like discrete samples. Since we use sample start time, a cue event could be inserted after the start time of the last text sample and never get inserted as there are no more samples. Change : After all streams have requested flushing, we make sure to collect all remaining cue events from the sync point queue and insert them into each stream. Issue #362 Change-Id: Id8f136f7ef53531f7a7f412613eac352324e0130
2018-05-14 20:46:03 +00:00
}
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextInfo(kTextStream));
ASSERT_OK(DispatchTextSample(kTextStream, kSample0Start, kSample0End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample1Start, kSample1End));
ASSERT_OK(DispatchTextSample(kTextStream, kSample2Start, kSample2End));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kTextStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
TEST_F(CueAlignmentHandlerTest, TextAudioVideoInputWithCues) {
const size_t kTextStream = 0;
const size_t kAudioStream = 1;
const size_t kVideoStream = 2;
const int64_t kSampleDuration = 1000;
const int64_t kSample0Start = 0;
Change Text Sample to Use int64_t Changed Text Sample to use int64_t so that it will use the same type for time as Media Sample. Change-Id: I4cfbfdc60c37bb511517993976cd1a459bdf6667
2018-03-26 18:04:09 +00:00
const int64_t kSample0End = kSample0Start + kSampleDuration;
const int64_t kSample1Start = kSample0End;
const int64_t kSample1End = kSample1Start + kSampleDuration;
const int64_t kSample2Start = kSample1End;
const int64_t kSample2End = kSample2Start + kSampleDuration;
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
const double kSample2StartInSeconds =
static_cast<double>(kSample2Start) / kMsTimeScale;
// Put the cue between two key frames.
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
auto sync_points =
CreateSyncPoints({static_cast<double>(kSample1Start) / kMsTimeScale});
auto handler = std::make_shared<CueAlignmentHandler>(sync_points.get());
ASSERT_OK(SetUpAndInitializeGraph(handler, kThreeInputs, kThreeOutputs));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
{
testing::InSequence s;
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample0Start, kSample0End)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(_, _, kSample1Start, kSample1End)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kTextStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample2StartInSeconds)));
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(kTextStream),
OnProcess(IsTextSample(_, _, kSample2Start, kSample2End)));
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
EXPECT_CALL(*Output(kTextStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kAudioStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample2StartInSeconds)));
EXPECT_CALL(
*Output(kAudioStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsStreamInfo(_, kMsTimeScale, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample0Start, kSampleDuration, _, _)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample1Start, kSampleDuration, _, _)));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
EXPECT_CALL(*Output(kVideoStream),
Reduce What We Check in Cue Alignment Tests Reduce which variables we check in the cue alignment tests by replacing the less important variables with "_". Change-Id: Id8770b5f2045ad5c8ac6eee54d6a291d933a4b6f
2018-06-19 17:35:00 +00:00
OnProcess(IsCueEvent(_, kSample2StartInSeconds)));
EXPECT_CALL(
*Output(kVideoStream),
OnProcess(IsMediaSample(_, kSample2Start, kSampleDuration, _, _)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(_));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Stream Info
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextInfo(kTextStream));
ASSERT_OK(DispatchAudioInfo(kAudioStream));
ASSERT_OK(DispatchVideoInfo(kVideoStream));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 0
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample0Start, kSample0End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample0Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample0Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 1
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample1Start, kSample1End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample1Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample1Start, kSampleDuration,
!kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
// Dispatch Sample 2
Merge Create and Dispatch in Cue Alignment Tests Originally the create and dispatch of stream data in the cue alignment tests were separate to improve readability. The idea was to separate building each stream and dispatching the streams muxed together would make it easier to understand the streams. However, coming back to the code, this did not hold up as it took just as long to understand the code. So merging the two together allows for the code to be more concise. Change-Id: I77f6bb67e7fb0ca7af0553c3baf07082770da74c
2018-06-19 20:23:39 +00:00
ASSERT_OK(DispatchTextSample(kTextStream, kSample2Start, kSample2End));
ASSERT_OK(DispatchMediaSample(kAudioStream, kSample2Start, kSampleDuration,
kKeyFrame));
ASSERT_OK(DispatchMediaSample(kVideoStream, kSample2Start, kSampleDuration,
kKeyFrame));
Update Cue Alignment Tests To Interweave Sample Data Problem: Sending samples to the cue alignmenet handler did not reflect what was more likely to happen. In our tests we would send all the samples for one stream then all the samples for another stream. This created some special cases that would either not happen in reality or miss cases that would likely happen in reality. Changes: Changes all tests to dispatch samples in an interlaced pattern that better reflects muxed content. Change-Id: I985092154b62eb12d95499663d195ca6c103bc19
2018-05-01 21:40:01 +00:00
ASSERT_OK(FlushAll({kTextStream, kAudioStream, kVideoStream}));
Implements SyncPointQueue and CueAlignmentHandler SyncPointQueue manages all cue points and returns aligned cue points to the callers (CueAlignmentHandlers). CueAlignmentHandler is responsible for aligning cues from different streams. It uses SyncPointQueue internally to align / synchronize the cue points. Issue: #355 Change-Id: I281fecb46a3ca7172d71e7495bdd07b8efdeb283
2018-03-15 23:04:01 +00:00
}
// TODO(kqyang): Add more tests, in particular, multi-thread tests.
} // namespace media
} // namespace shaka