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

696 lines
28 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;
const size_t kThreeInput = 3;
const size_t kThreeOutput = 3;
const bool kEncrypted = true;
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
const char* kNoId = "";
const char* kNoSettings = "";
const char* kNoPayload = "";
const size_t kChild = 0;
const size_t kParent = 0;
} // 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:
Status DispatchStreamInfo(size_t stream,
std::shared_ptr<const StreamInfo> info) {
return Input(stream)->Dispatch(
StreamData::FromStreamInfo(kChild, std::move(info)));
}
Status DispatchMediaSample(size_t stream,
std::shared_ptr<const MediaSample> sample) {
return Input(stream)->Dispatch(
StreamData::FromMediaSample(kChild, std::move(sample)));
}
Status DispatchTextSample(size_t stream,
std::shared_ptr<const TextSample> sample) {
return Input(stream)->Dispatch(
StreamData::FromTextSample(kChild, std::move(sample)));
}
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;
AdCueGeneratorParams params;
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(kParent));
}
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
auto stream_info = GetVideoStreamInfo(kMsTimeScale);
auto sample_0 = GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto sample_1 = GetMediaSample(kSample1Start, kSampleDuration, !kKeyFrame);
auto sample_2 = GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
DispatchStreamInfo(kVideoStream, std::move(stream_info));
DispatchMediaSample(kVideoStream, std::move(sample_0));
DispatchMediaSample(kVideoStream, std::move(sample_1));
DispatchMediaSample(kVideoStream, std::move(sample_2));
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;
AdCueGeneratorParams params;
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(kParent));
}
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
auto stream_info = GetAudioStreamInfo(kMsTimeScale);
auto sample_0 = GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto sample_1 = GetMediaSample(kSample1Start, kSampleDuration, kKeyFrame);
auto sample_2 = GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
ASSERT_OK(DispatchStreamInfo(kAudioStream, std::move(stream_info)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_0)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_1)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_2)));
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
AdCueGeneratorParams params;
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, kSample2Start, kSample2End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
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
auto stream_info = GetTextStreamInfo(kMsTimeScale);
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
auto sample_0 = GetTextSample(kNoId, kSample0Start, kSample0End, kNoPayload);
auto sample_1 = GetTextSample(kNoId, kSample1Start, kSample1End, kNoPayload);
auto sample_2 = GetTextSample(kNoId, kSample2Start, kSample2End, kNoPayload);
ASSERT_OK(DispatchStreamInfo(kTextStream, std::move(stream_info)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_0)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_1)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_2)));
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
AdCueGeneratorParams params;
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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, kThreeInput, kThreeOutput));
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, kSample2Start, kSample2End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(kParent));
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(kParent));
}
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
// Text samples
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
auto text_stream_info = GetTextStreamInfo(kMsTimeScale);
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
auto text_sample_0 =
GetTextSample(kNoId, kSample0Start, kSample0End, kNoPayload);
auto text_sample_1 =
GetTextSample(kNoId, kSample1Start, kSample1End, kNoPayload);
auto text_sample_2 =
GetTextSample(kNoId, kSample2Start, kSample2End, kNoPayload);
// Audio samples
auto audio_stream_info = GetAudioStreamInfo(kMsTimeScale);
auto audio_sample_0 =
GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto audio_sample_1 =
GetMediaSample(kSample1Start, kSampleDuration, kKeyFrame);
auto audio_sample_2 =
GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
// Video samples
auto video_stream_info = GetVideoStreamInfo(kMsTimeScale);
auto video_sample_0 =
GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto video_sample_1 =
GetMediaSample(kSample1Start, kSampleDuration, !kKeyFrame);
auto video_sample_2 =
GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
// Dispatch Stream Info
ASSERT_OK(DispatchStreamInfo(kTextStream, std::move(text_stream_info)));
ASSERT_OK(DispatchStreamInfo(kAudioStream, std::move(audio_stream_info)));
ASSERT_OK(DispatchStreamInfo(kVideoStream, std::move(video_stream_info)));
// Dispatch Sample 0
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_0)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_0)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_0)));
// Dispatch Sample 1
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_1)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_1)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_1)));
// Dispatch Sample 2
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_2)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_2)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_2)));
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.
Cuepoint cue;
cue.start_time_in_seconds = static_cast<double>(kSample1Start) / kMsTimeScale;
AdCueGeneratorParams params;
params.cue_points.push_back(cue);
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsCueEvent(kParent, kSample2StartInSeconds)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(kParent));
}
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
auto stream_info = GetVideoStreamInfo(kMsTimeScale);
auto sample_0 = GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto sample_1 = GetMediaSample(kSample1Start, kSampleDuration, !kKeyFrame);
auto sample_2 = GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
ASSERT_OK(DispatchStreamInfo(kVideoStream, std::move(stream_info)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(sample_0)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(sample_1)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(sample_2)));
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;
Cuepoint cue;
cue.start_time_in_seconds = static_cast<double>(kSample1Start) / kMsTimeScale;
AdCueGeneratorParams params;
params.cue_points.push_back(cue);
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsCueEvent(kParent, kSample1StartInSeconds)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(kParent));
}
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
auto stream_info = GetAudioStreamInfo(kMsTimeScale);
auto sample_0 = GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto sample_1 = GetMediaSample(kSample1Start, kSampleDuration, kKeyFrame);
auto sample_2 = GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
ASSERT_OK(DispatchStreamInfo(kAudioStream, std::move(stream_info)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_0)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_1)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(sample_2)));
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;
Cuepoint cue;
cue.start_time_in_seconds = static_cast<double>(kSample1Start) / kMsTimeScale;
AdCueGeneratorParams params;
params.cue_points.push_back(cue);
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsCueEvent(kParent, kSample1StartInSeconds)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, kSample2Start, kSample2End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
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
auto stream_info = GetTextStreamInfo(kMsTimeScale);
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
auto sample_0 = GetTextSample(kNoId, kSample0Start, kSample0End, kNoPayload);
auto sample_1 = GetTextSample(kNoId, kSample1Start, kSample1End, kNoPayload);
auto sample_2 = GetTextSample(kNoId, kSample2Start, kSample2End, kNoPayload);
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(DispatchStreamInfo(kTextStream, std::move(stream_info)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_0)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_1)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_2)));
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;
const double kCueTimeInSeconds =
static_cast<double>(kSample2Start + kSample2End) / kMsTimeScale;
// Put the cue between the start and end of the last sample.
Cuepoint cue;
cue.start_time_in_seconds = kCueTimeInSeconds;
AdCueGeneratorParams params;
params.cue_points.push_back(cue);
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
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
OnProcess(IsTextSample(_, kNoId, kSample0Start, kSample0End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, kSample1Start, kSample1End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsCueEvent(kParent, kCueTimeInSeconds)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
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
auto stream_info = GetTextStreamInfo(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
auto sample_0 = GetTextSample(kNoId, kSample0Start, kSample0End, kNoPayload);
auto sample_1 = GetTextSample(kNoId, kSample1Start, kSample1End, kNoPayload);
auto sample_2 = GetTextSample(kNoId, kSample2Start, kSample2End, kNoPayload);
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(DispatchStreamInfo(kTextStream, std::move(stream_info)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_0)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_1)));
ASSERT_OK(DispatchTextSample(kTextStream, std::move(sample_2)));
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.
Cuepoint cue;
cue.start_time_in_seconds = static_cast<double>(kSample1Start) / kMsTimeScale;
AdCueGeneratorParams params;
params.cue_points.push_back(cue);
SyncPointQueue sync_points(params);
std::shared_ptr<MediaHandler> handler =
std::make_shared<CueAlignmentHandler>(&sync_points);
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, kThreeInput, kThreeOutput));
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),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, 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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsCueEvent(kParent, kSample2StartInSeconds)));
EXPECT_CALL(*Output(kTextStream),
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
OnProcess(IsTextSample(_, kNoId, kSample2Start, kSample2End,
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
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsCueEvent(kParent, kSample2StartInSeconds)));
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kAudioStream), OnFlush(kParent));
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kVideoStream),
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
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted, _)));
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),
OnProcess(IsMediaSample(kParent, kSample0Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample1Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsCueEvent(kParent, kSample2StartInSeconds)));
EXPECT_CALL(*Output(kVideoStream),
OnProcess(IsMediaSample(kParent, kSample2Start, kSampleDuration,
!kEncrypted)));
EXPECT_CALL(*Output(kVideoStream), OnFlush(kParent));
}
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
// Text samples
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
auto text_stream_info = GetTextStreamInfo(kMsTimeScale);
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
auto text_sample_0 =
GetTextSample(kNoId, kSample0Start, kSample0End, kNoPayload);
auto text_sample_1 =
GetTextSample(kNoId, kSample1Start, kSample1End, kNoPayload);
auto text_sample_2 =
GetTextSample(kNoId, kSample2Start, kSample2End, kNoPayload);
// Audio samples
auto audio_stream_info = GetAudioStreamInfo(kMsTimeScale);
auto audio_sample_0 =
GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto audio_sample_1 =
GetMediaSample(kSample1Start, kSampleDuration, kKeyFrame);
auto audio_sample_2 =
GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
// Video samples
auto video_stream_info = GetVideoStreamInfo(kMsTimeScale);
auto video_sample_0 =
GetMediaSample(kSample0Start, kSampleDuration, kKeyFrame);
auto video_sample_1 =
GetMediaSample(kSample1Start, kSampleDuration, !kKeyFrame);
auto video_sample_2 =
GetMediaSample(kSample2Start, kSampleDuration, kKeyFrame);
// Dispatch Stream Info
ASSERT_OK(DispatchStreamInfo(kTextStream, std::move(text_stream_info)));
ASSERT_OK(DispatchStreamInfo(kAudioStream, std::move(audio_stream_info)));
ASSERT_OK(DispatchStreamInfo(kVideoStream, std::move(video_stream_info)));
// Dispatch Sample 0
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_0)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_0)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_0)));
// Dispatch Sample 1
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_1)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_1)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_1)));
// Dispatch Sample 2
ASSERT_OK(DispatchTextSample(kTextStream, std::move(text_sample_2)));
ASSERT_OK(DispatchMediaSample(kAudioStream, std::move(audio_sample_2)));
ASSERT_OK(DispatchMediaSample(kVideoStream, std::move(video_sample_2)));
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