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/chunking_handler_unittest.cc

255 lines
10 KiB
C++
Raw Normal View History

chore: Mass-update copyright headers (#1086) Closes #1076
2022-08-26 15:44:59 +00:00
// Copyright 2017 Google LLC. All rights reserved.
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#include "packager/media/chunking/chunking_handler.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "packager/media/base/media_handler_test_base.h"
feat: port media/chunking to CMake (#1223) Port media/chunking to CMake Related to #1047
2023-07-05 22:18:36 +00:00
#include "packager/status/status_test_util.h"
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
Updated StreamData Matchers to Use Matchers Updated all the stream data matcher we use in our unit tests to allow us to use matchers in them. We are now able to use "_" to ignore specific parameters. With this we were able to replace the different version of matchers for each stream data type with a single instance for each type. Includes updates to printing strings to the listener. Strings now go through a "pretty" function to help make it easier to read them in the output. Change-Id: I146351b54fccd63ab9ec936877e6c6b30f9aa9fc
2018-05-25 17:41:02 +00:00
using ::testing::_;
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
using ::testing::ElementsAre;
using ::testing::IsEmpty;
namespace shaka {
namespace media {
namespace {
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
const size_t kStreamIndex = 0;
cleanup: Convert all time parameters to signed This converts all time parameters to signed, finishing a cleanup that was started in 2018 in b4256bf0. This changes the type of: - timestamps - PTS specifically - timestamp offsets - timescales - durations This excludes: - MP4 box definitions - DTS specifically This is meant to address signed/unsigned conversion issues on arm64 that caused some test cases to fail. Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
2021-08-04 18:56:44 +00:00
const int32_t kTimeScale0 = 800;
const int32_t kTimeScale1 = 1000;
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
const int64_t kDuration = 300;
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
const bool kKeyFrame = true;
const bool kIsSubsegment = true;
const bool kEncrypted = true;
} // namespace
Separate MediaHandlerTestBase From FakeMediaHandler To allow more tests to use the MediaHandlerTestBase and get access to the helpful creation methods, this change moves the use of FakeMediaHandler and setting up the graph to a sub class. Change-Id: I90dd151e3c96d8fbe4bd02a1d6b11e66a279d95b
2017-09-14 16:23:29 +00:00
class ChunkingHandlerTest : public MediaHandlerGraphTestBase {
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
public:
void SetUpChunkingHandler(int num_inputs,
Consolidate ChunkingParams and ChunkingOptions Change-Id: Ibbb85981d2b424432b61ca693e28334ef00d475e
2017-07-27 17:23:27 +00:00
const ChunkingParams& chunking_params) {
chunking_handler_.reset(new ChunkingHandler(chunking_params));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
SetUpGraph(num_inputs, num_inputs, chunking_handler_);
ASSERT_OK(chunking_handler_->Initialize());
}
Status Process(std::unique_ptr<StreamData> stream_data) {
return chunking_handler_->Process(std::move(stream_data));
}
Rename FlushStream to OnFlushRequest; add FlushOutput Change-Id: I2b37030b0c35aa34e9c72e43825f157924034227
2017-02-22 20:14:26 +00:00
Status OnFlushRequest(int stream_index) {
return chunking_handler_->OnFlushRequest(stream_index);
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
}
protected:
std::shared_ptr<ChunkingHandler> chunking_handler_;
};
TEST_F(ChunkingHandlerTest, AudioNoSubsegmentsThenFlush) {
Consolidate ChunkingParams and ChunkingOptions Change-Id: Ibbb85981d2b424432b61ca693e28334ef00d475e
2017-07-27 17:23:27 +00:00
ChunkingParams chunking_params;
chunking_params.segment_duration_in_seconds = 1;
SetUpChunkingHandler(1, chunking_params);
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromStreamInfo(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetAudioStreamInfo(kTimeScale0))));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
EXPECT_THAT(
GetOutputStreamDataVector(),
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
ElementsAre(IsStreamInfo(kStreamIndex, kTimeScale0, !kEncrypted, _)));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
for (int i = 0; i < 5; ++i) {
ClearOutputStreamDataVector();
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromMediaSample(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetMediaSample(i * kDuration, kDuration, kKeyFrame))));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
// One output stream_data except when i == 3, which also has SegmentInfo.
if (i == 3) {
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
EXPECT_THAT(GetOutputStreamDataVector(),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
ElementsAre(IsSegmentInfo(kStreamIndex, 0, kDuration * 3,
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
!kIsSubsegment, !kEncrypted),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, i * kDuration,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _)));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
} else {
EXPECT_THAT(GetOutputStreamDataVector(),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
ElementsAre(IsMediaSample(kStreamIndex, i * kDuration,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _)));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
}
}
ClearOutputStreamDataVector();
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
ASSERT_OK(OnFlushRequest(kStreamIndex));
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
EXPECT_THAT(
GetOutputStreamDataVector(),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
ElementsAre(IsSegmentInfo(kStreamIndex, kDuration * 3, kDuration * 2,
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
!kIsSubsegment, !kEncrypted)));
Integrate ChunkingHandler Also moved MediaHandler output validation to Initialize instead. This CL also addresses #122 with consistent chunking. Change-Id: I60c0da6d1b33421d7828bcb827d18899e71884ce
2017-02-24 01:17:47 +00:00
}
TEST_F(ChunkingHandlerTest, AudioWithSubsegments) {
Consolidate ChunkingParams and ChunkingOptions Change-Id: Ibbb85981d2b424432b61ca693e28334ef00d475e
2017-07-27 17:23:27 +00:00
ChunkingParams chunking_params;
chunking_params.segment_duration_in_seconds = 1;
chunking_params.subsegment_duration_in_seconds = 0.5;
SetUpChunkingHandler(1, chunking_params);
Integrate ChunkingHandler Also moved MediaHandler output validation to Initialize instead. This CL also addresses #122 with consistent chunking. Change-Id: I60c0da6d1b33421d7828bcb827d18899e71884ce
2017-02-24 01:17:47 +00:00
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromStreamInfo(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetAudioStreamInfo(kTimeScale0))));
Integrate ChunkingHandler Also moved MediaHandler output validation to Initialize instead. This CL also addresses #122 with consistent chunking. Change-Id: I60c0da6d1b33421d7828bcb827d18899e71884ce
2017-02-24 01:17:47 +00:00
for (int i = 0; i < 5; ++i) {
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromMediaSample(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetMediaSample(i * kDuration, kDuration, kKeyFrame))));
Integrate ChunkingHandler Also moved MediaHandler output validation to Initialize instead. This CL also addresses #122 with consistent chunking. Change-Id: I60c0da6d1b33421d7828bcb827d18899e71884ce
2017-02-24 01:17:47 +00:00
}
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(
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
IsStreamInfo(kStreamIndex, kTimeScale0, !kEncrypted, _),
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
IsMediaSample(kStreamIndex, 0, kDuration, !kEncrypted, _),
IsMediaSample(kStreamIndex, kDuration, kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsSegmentInfo(kStreamIndex, 0, kDuration * 2, kIsSubsegment,
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
!kEncrypted),
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
IsMediaSample(kStreamIndex, 2 * kDuration, kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsSegmentInfo(kStreamIndex, 0, kDuration * 3, !kIsSubsegment,
Update EncryptionHandler to support key rotation and SampleAes This CL also removes EncryptionConfig stream data type and merges it into StreamInfo/SegmentInfo instead. Change-Id: Idb70ce503e61d3c951225cc78b6b15c084e16dcd
2017-03-11 02:48:04 +00:00
!kEncrypted),
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
IsMediaSample(kStreamIndex, 3 * kDuration, kDuration, !kEncrypted, _),
IsMediaSample(kStreamIndex, 4 * kDuration, kDuration, !kEncrypted,
_)));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
}
TEST_F(ChunkingHandlerTest, VideoAndSubsegmentAndNonzeroStart) {
Consolidate ChunkingParams and ChunkingOptions Change-Id: Ibbb85981d2b424432b61ca693e28334ef00d475e
2017-07-27 17:23:27 +00:00
ChunkingParams chunking_params;
chunking_params.segment_duration_in_seconds = 1;
chunking_params.subsegment_duration_in_seconds = 0.3;
SetUpChunkingHandler(1, chunking_params);
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromStreamInfo(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetVideoStreamInfo(kTimeScale1))));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
const int64_t kVideoStartTimestamp = 12345;
for (int i = 0; i < 6; ++i) {
// Alternate key frame.
const bool is_key_frame = (i % 2) == 1;
Made StreamData Have Const Pointers In prep for changes to Trick Play, we want to make all messages copy on write so that if the same message is sent to multiple handlers, it is not possible for one handler to change the data another handler is using. Change-Id: I554166ca11c532412e4dfced5603972ca24dc2bb
2017-09-12 17:24:24 +00:00
ASSERT_OK(Process(StreamData::FromMediaSample(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetMediaSample(kVideoStartTimestamp + i * kDuration,
kDuration, is_key_frame))));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
}
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(
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
IsStreamInfo(kStreamIndex, kTimeScale1, !kEncrypted, _),
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
// The first samples @ kStartTimestamp is discarded - not key frame.
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 2,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
// The next segment boundary 13245 / 1000 != 12645 / 1000.
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsSegmentInfo(kStreamIndex, kVideoStartTimestamp + kDuration,
kDuration * 2, !kIsSubsegment, !kEncrypted),
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 3,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 4,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
// The subsegment has duration kDuration * 2 since it can only
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
// terminate before key frame.
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsSegmentInfo(kStreamIndex, kVideoStartTimestamp + kDuration * 3,
kDuration * 2, kIsSubsegment, !kEncrypted),
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 5,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _)));
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
}
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
TEST_F(ChunkingHandlerTest, CueEvent) {
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
ChunkingParams chunking_params;
chunking_params.segment_duration_in_seconds = 1;
chunking_params.subsegment_duration_in_seconds = 0.5;
SetUpChunkingHandler(1, chunking_params);
ASSERT_OK(Process(StreamData::FromStreamInfo(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetVideoStreamInfo(kTimeScale1))));
Generate full segment after cue point Also added RETURN_IF_ERROR status macro. Change-Id: I04643b6252ea5623128f9a16fa744a255c91be17
2018-03-21 18:03:54 +00:00
ClearOutputStreamDataVector();
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
const int64_t kVideoStartTimestamp = 12345;
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
const double kCueTimeInSeconds =
static_cast<double>(kVideoStartTimestamp + kDuration) / kTimeScale1;
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
auto cue_event = std::make_shared<CueEvent>();
cue_event->time_in_seconds = kCueTimeInSeconds;
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
Generate full segment after cue point Also added RETURN_IF_ERROR status macro. Change-Id: I04643b6252ea5623128f9a16fa744a255c91be17
2018-03-21 18:03:54 +00:00
for (int i = 0; i < 6; ++i) {
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
const bool is_key_frame = true;
ASSERT_OK(Process(StreamData::FromMediaSample(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
kStreamIndex, GetMediaSample(kVideoStartTimestamp + i * kDuration,
kDuration, is_key_frame))));
if (i == 0) {
ASSERT_OK(Process(StreamData::FromCueEvent(kStreamIndex, cue_event)));
}
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
}
Change CueEvent to use time in seconds Change-Id: I03527db76905f25f0a142940f5fcf73e2a92d42f
2018-03-15 23:01:47 +00:00
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp, kDuration,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
!kEncrypted, _),
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
// A new segment is created due to the existance of Cue.
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsSegmentInfo(kStreamIndex, kVideoStartTimestamp, kDuration,
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
!kIsSubsegment, !kEncrypted),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsCueEvent(kStreamIndex, kCueTimeInSeconds),
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 1,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Integrate CueAlignmentHandler Also changed ChunkingHandler to be one-one handler. Issue: #355 Change-Id: Ie98a96bcc0ddded347699c9f333f604826976d11
2018-03-20 17:12:18 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 2,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Generate full segment after cue point Also added RETURN_IF_ERROR status macro. Change-Id: I04643b6252ea5623128f9a16fa744a255c91be17
2018-03-21 18:03:54 +00:00
IsSegmentInfo(kStreamIndex, kVideoStartTimestamp + kDuration,
kDuration * 2, kIsSubsegment, !kEncrypted),
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 3,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Generate full segment after cue point Also added RETURN_IF_ERROR status macro. Change-Id: I04643b6252ea5623128f9a16fa744a255c91be17
2018-03-21 18:03:54 +00:00
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 4,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _),
Generate full segment after cue point Also added RETURN_IF_ERROR status macro. Change-Id: I04643b6252ea5623128f9a16fa744a255c91be17
2018-03-21 18:03:54 +00:00
IsSegmentInfo(kStreamIndex, kVideoStartTimestamp + kDuration,
kDuration * 4, !kIsSubsegment, !kEncrypted),
IsMediaSample(kStreamIndex, kVideoStartTimestamp + kDuration * 5,
Add is_key_frame in IsMediaSample Matcher Added the key frame field to the IsMediaSample mather. All tests that do not care about a sample being a keyframe (or not) have been updated to use "_". Change-Id: I44180687c58c260b6856e683d647f532227b14d5
2018-06-14 23:39:59 +00:00
kDuration, !kEncrypted, _)));
Propage CueEvent to MpdNotifier/HlsNotifier Change-Id: I9828af11a28300d20cc8742251bbe1b4ebfdbad1
2018-01-03 00:10:33 +00:00
}
Low latency DASH support (#979) # LL-DASH Support These changes add support for LL-DASH streaming. **NOTE:** LL-HLS support is still in progress, but it's coming. :) ## Testing `./chunking_unittest --gtest_filter="ChunkingHandlerTest.LowLatencyDash"` `./media_event_unittest --gtest_filter="MpdNotifyMuxerListenerTest.LowLatencyDash"` `./mpd_unittest --gtest_filter="PeriodTest.LowLatencyDashMpdGetXml"` `./mpd_unittest --gtest_filter="SimpleMpdNotifierTest.NotifyAvailabilityTimeOffset"` `./mpd_unittest --gtest_filter="SimpleMpdNotifierTest.NotifySegmentDuration"` `./mpd_unittest --gtest_filter="LowLatencySegmentTest.LowLatencySegmentTemplate"` Note, packager_test must be run from the main project directory `./out/Release/packager_test --gtest_filter="PackagerTest.LowLatencyDashEnabledAndUtcTimingNotSet"` `./out/Release/packager_test --gtest_filter="PackagerTest.LowLatencyDashEnabledAndUtcTimingNotSet"`
2021-08-25 15:38:05 +00:00
TEST_F(ChunkingHandlerTest, LowLatencyDash) {
ChunkingParams chunking_params;
chunking_params.low_latency_dash_mode = true;
chunking_params.segment_duration_in_seconds = 1;
SetUpChunkingHandler(1, chunking_params);
// Each completed segment will contain 2 chunks
const int64_t kChunkDurationInMs = 500;
const int64_t kSegmentDurationInMs = 1000;
ASSERT_OK(Process(StreamData::FromStreamInfo(
kStreamIndex, GetVideoStreamInfo(kTimeScale1))));
for (int i = 0; i < 4; ++i) {
ASSERT_OK(Process(StreamData::FromMediaSample(
kStreamIndex, GetMediaSample(i * kChunkDurationInMs, kChunkDurationInMs,
kKeyFrame))));
}
// NOTE: Each MediaSample will create a chunk, dispatching SegmentInfo
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(
IsStreamInfo(kStreamIndex, kTimeScale1, !kEncrypted, _),
// Chunk 1 for segment 1
IsMediaSample(kStreamIndex, 0, kChunkDurationInMs, !kEncrypted, _),
IsSegmentInfo(kStreamIndex, 0, kChunkDurationInMs, kIsSubsegment,
!kEncrypted),
// Chunk 2 for segment 1
IsMediaSample(kStreamIndex, kChunkDurationInMs, kChunkDurationInMs,
!kEncrypted, _),
IsSegmentInfo(kStreamIndex, 0, 2 * kChunkDurationInMs, !kIsSubsegment,
!kEncrypted),
// Chunk 1 for segment 2
IsMediaSample(kStreamIndex, kSegmentDurationInMs, kChunkDurationInMs,
!kEncrypted, _),
IsSegmentInfo(kStreamIndex, kSegmentDurationInMs, kChunkDurationInMs,
kIsSubsegment, !kEncrypted),
// Chunk 2 for segment 2
IsMediaSample(kStreamIndex, kSegmentDurationInMs + kChunkDurationInMs,
kChunkDurationInMs, !kEncrypted, _)));
}
Implement ChunkingHandler This handler is a multi-in multi-out handler. If more than one input is provided, there should be one and only one video stream; also, all inputs should come from the same thread and are synchronized. There can be multiple chunking handler running in different threads or even different processes, we use the "consistent chunking algorithm" to make sure the chunks in different streams are aligned without explicit communcating with each other - which is not efficient and often difficult. Consistent Chunking Algorithm: 1. Find the consistent chunkable boundary Let the timestamps for video frames be (t1, t2, t3, ...). Then a consistent chunkable boundary is simply the first chunkable boundary after (tk / N) != (tk-1 / N), where '/' denotes integer division, and N is the intended chunk duration. 2. Chunk only at the consistent chunkable boundary This algorithm will make sure the chunks from different video streams are aligned if they have aligned GoPs. However, this algorithm will only work for video streams. To be able to chunk non video streams at similar positions as video streams, ChunkingHandler is designed to accept one video input and multiple non video inputs, the non video inputs are chunked when the video input is chunked. If the inputs are synchronized - which is true if the inputs come from the same demuxer, the video and non video chunks are aligned. Change-Id: Id3bad51ab14f311efdb8713b6cd36d36cf9e4639
2017-02-07 18:58:47 +00:00
} // namespace media
} // namespace shaka