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

695 lines
27 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"
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;
const uint64_t kMsTimeScale = 1000;
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
Set Text Time Scale In Tests Problem: The time scale for text was being set to zero in our tests because it was never needed. Change: This changes it to use MS as that is what's most common and requires the least amount of changes. Change-Id: Ia046ac1994b4cede079d2f801275c7f058d5bdd3
2018-05-01 21:44:58 +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),
OnProcess(IsTextSample(kNoId, kSample0Start, kSample0End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample1Start, kSample1End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample2Start, kSample2End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), 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 = GetTextStreamInfo();
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),
Set Text Time Scale In Tests Problem: The time scale for text was being set to zero in our tests because it was never needed. Change: This changes it to use MS as that is what's most common and requires the least amount of changes. Change-Id: Ia046ac1994b4cede079d2f801275c7f058d5bdd3
2018-05-01 21:44:58 +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),
OnProcess(IsTextSample(kNoId, kSample0Start, kSample0End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample1Start, kSample1End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample2Start, kSample2End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
{
testing::InSequence s;
EXPECT_CALL(*Output(kAudioStream),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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
auto text_stream_info = GetTextStreamInfo();
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
Set Text Time Scale In Tests Problem: The time scale for text was being set to zero in our tests because it was never needed. Change: This changes it to use MS as that is what's most common and requires the least amount of changes. Change-Id: Ia046ac1994b4cede079d2f801275c7f058d5bdd3
2018-05-01 21:44:58 +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),
OnProcess(IsTextSample(kNoId, kSample0Start, kSample0End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsCueEvent(kParent, kSample1StartInSeconds)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample1Start, kSample1End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample2Start, kSample2End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream), 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 = GetTextStreamInfo();
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample0Start, kSample0End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample1Start, kSample1End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsTextSample(kNoId, kSample2Start, kSample2End,
kNoSettings, kNoPayload)));
EXPECT_CALL(*Output(kTextStream),
OnProcess(IsCueEvent(kParent, kCueTimeInSeconds)));
EXPECT_CALL(*Output(kTextStream), OnFlush(kParent));
}
auto stream_info = GetTextStreamInfo();
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),
Set Text Time Scale In Tests Problem: The time scale for text was being set to zero in our tests because it was never needed. Change: This changes it to use MS as that is what's most common and requires the least amount of changes. Change-Id: Ia046ac1994b4cede079d2f801275c7f058d5bdd3
2018-05-01 21:44:58 +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),
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
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),
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
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),
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
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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),
OnProcess(IsStreamInfo(kParent, kMsTimeScale, !kEncrypted)));
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
auto text_stream_info = GetTextStreamInfo();
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