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

291 lines
12 KiB
C++
Raw Normal View History

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
// Copyright 2017 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"
Move status.h under packager/ Change-Id: I4a7f34c575c1c8b9a9a275f3889cf8641cfdd471
2017-06-29 22:23:53 +00:00
#include "packager/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
using ::testing::ElementsAre;
using ::testing::IsEmpty;
namespace shaka {
namespace media {
namespace {
Use size_t as the type of stream_index Change-Id: Ica8ffeccc45c1adf5def6fe9b2edde5708d6b432
2017-03-03 00:10:30 +00:00
const size_t kStreamIndex0 = 0;
const size_t kStreamIndex1 = 1;
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 uint32_t kTimeScale0 = 800;
const uint32_t kTimeScale1 = 1000;
const int64_t kDuration0 = 200;
const int64_t kDuration1 = 300;
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(
kStreamIndex0, 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(),
ElementsAre(IsStreamInfo(kStreamIndex0, kTimeScale0, !kEncrypted)));
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(
kStreamIndex0,
GetMediaSample(i * kDuration1, kDuration1, 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(),
ElementsAre(IsSegmentInfo(kStreamIndex0, 0, kDuration1 * 3,
!kIsSubsegment, !kEncrypted),
IsMediaSample(kStreamIndex0, i * kDuration1,
kDuration1, !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(),
ElementsAre(IsMediaSample(kStreamIndex0, i * kDuration1,
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
kDuration1, !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();
Rename FlushStream to OnFlushRequest; add FlushOutput Change-Id: I2b37030b0c35aa34e9c72e43825f157924034227
2017-02-22 20:14:26 +00:00
ASSERT_OK(OnFlushRequest(kStreamIndex0));
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(),
ElementsAre(IsSegmentInfo(kStreamIndex0, kDuration1 * 3, kDuration1 * 2,
!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(
kStreamIndex0, 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(
kStreamIndex0,
GetMediaSample(i * kDuration1, kDuration1, 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(
IsStreamInfo(kStreamIndex0, kTimeScale0, !kEncrypted),
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
IsMediaSample(kStreamIndex0, 0, kDuration1, !kEncrypted),
IsMediaSample(kStreamIndex0, kDuration1, kDuration1, !kEncrypted),
IsSegmentInfo(kStreamIndex0, 0, kDuration1 * 2, kIsSubsegment,
!kEncrypted),
IsMediaSample(kStreamIndex0, 2 * kDuration1, kDuration1, !kEncrypted),
IsSegmentInfo(kStreamIndex0, 0, kDuration1 * 3, !kIsSubsegment,
!kEncrypted),
IsMediaSample(kStreamIndex0, 3 * kDuration1, kDuration1, !kEncrypted),
IsMediaSample(kStreamIndex0, 4 * kDuration1, kDuration1,
!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(
kStreamIndex0, 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(
kStreamIndex0,
GetMediaSample(
kVideoStartTimestamp + i * kDuration1,
kDuration1,
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(
IsStreamInfo(kStreamIndex0, kTimeScale1, !kEncrypted),
// The first samples @ kStartTimestamp is discarded - not key frame.
IsMediaSample(kStreamIndex0, kVideoStartTimestamp + kDuration1,
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
kDuration1, !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
IsMediaSample(kStreamIndex0, kVideoStartTimestamp + kDuration1 * 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
kDuration1, !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.
IsSegmentInfo(kStreamIndex0, kVideoStartTimestamp + kDuration1,
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
kDuration1 * 2, !kIsSubsegment, !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
IsMediaSample(kStreamIndex0, kVideoStartTimestamp + kDuration1 * 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
kDuration1, !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
IsMediaSample(kStreamIndex0, kVideoStartTimestamp + kDuration1 * 4,
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
kDuration1, !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 subsegment has duration kDuration1 * 2 since it can only
// terminate before key frame.
IsSegmentInfo(kStreamIndex0, kVideoStartTimestamp + kDuration1 * 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
kDuration1 * 2, kIsSubsegment, !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
IsMediaSample(kStreamIndex0, kVideoStartTimestamp + kDuration1 * 5,
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
kDuration1, !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, AudioAndVideo) {
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(2, 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(
kStreamIndex0, GetAudioStreamInfo(kTimeScale0))));
ASSERT_OK(Process(StreamData::FromStreamInfo(
kStreamIndex1, 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
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(IsStreamInfo(kStreamIndex0, kTimeScale0, !kEncrypted),
IsStreamInfo(kStreamIndex1, kTimeScale1, !kEncrypted)));
ClearOutputStreamDataVector();
// Equivalent to 12345 in video timescale.
const int64_t kAudioStartTimestamp = 9876;
const int64_t kVideoStartTimestamp = 12345;
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(
kStreamIndex0,
GetMediaSample(
kAudioStartTimestamp + kDuration0 * i,
kDuration0,
true))));
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
// 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(
kStreamIndex1,
GetMediaSample(
kVideoStartTimestamp + kDuration1 * i,
kDuration1,
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(
// The first samples @ kStartTimestamp is discarded - not key frame.
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0,
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
kDuration0, !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
IsMediaSample(kStreamIndex1, kVideoStartTimestamp + kDuration1,
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
kDuration1, !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
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 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
kDuration0, !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
IsMediaSample(kStreamIndex1, kVideoStartTimestamp + kDuration1 * 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
kDuration1, !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
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 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
kDuration0, !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 audio segment is terminated together with video stream.
IsSegmentInfo(kStreamIndex0, kAudioStartTimestamp + kDuration0,
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
kDuration0 * 3, !kIsSubsegment, !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.
IsSegmentInfo(kStreamIndex1, kVideoStartTimestamp + kDuration1,
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
kDuration1 * 2, !kIsSubsegment, !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
IsMediaSample(kStreamIndex1, kVideoStartTimestamp + kDuration1 * 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
kDuration1, !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
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 4,
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
kDuration0, !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
IsMediaSample(kStreamIndex1, kVideoStartTimestamp + kDuration1 * 4,
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
kDuration1, !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();
// The side comments below show the equivalent timestamp in video timescale.
// The audio and video are made ~aligned.
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(
kStreamIndex0,
GetMediaSample(
kAudioStartTimestamp + kDuration0 * 5,
kDuration0,
true)))); // 13595
ASSERT_OK(Process(StreamData::FromMediaSample(
kStreamIndex1,
GetMediaSample(
kVideoStartTimestamp + kDuration1 * 5,
kDuration1,
true)))); // 13845
ASSERT_OK(Process(StreamData::FromMediaSample(
kStreamIndex0,
GetMediaSample(
kAudioStartTimestamp + kDuration0 * 6,
kDuration0,
true)))); // 13845
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
// This expectation are separated from the expectation above because
// ElementsAre supports at most 10 elements.
EXPECT_THAT(
GetOutputStreamDataVector(),
ElementsAre(
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 5,
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
kDuration0, !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
// Audio is terminated along with video below.
IsSegmentInfo(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 4,
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
kDuration0 * 2, kIsSubsegment, !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 subsegment has duration kDuration1 * 2 since it can only
// terminate before key frame.
IsSegmentInfo(kStreamIndex1, kVideoStartTimestamp + kDuration1 * 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
kDuration1 * 2, kIsSubsegment, !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
IsMediaSample(kStreamIndex1, kVideoStartTimestamp + kDuration1 * 5,
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
kDuration1, !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();
Rename FlushStream to OnFlushRequest; add FlushOutput Change-Id: I2b37030b0c35aa34e9c72e43825f157924034227
2017-02-22 20:14:26 +00:00
ASSERT_OK(OnFlushRequest(kStreamIndex0));
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(
IsMediaSample(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 6,
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
kDuration0, !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
IsSegmentInfo(kStreamIndex0, kAudioStartTimestamp + kDuration0 * 4,
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
kDuration0 * 3, !kIsSubsegment, !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();
Rename FlushStream to OnFlushRequest; add FlushOutput Change-Id: I2b37030b0c35aa34e9c72e43825f157924034227
2017-02-22 20:14:26 +00:00
ASSERT_OK(OnFlushRequest(kStreamIndex1));
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(),
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
ElementsAre(IsSegmentInfo(
kStreamIndex1, kVideoStartTimestamp + kDuration1 * 3,
kDuration1 * 3, !kIsSubsegment, !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
// Flush again will do nothing.
ClearOutputStreamDataVector();
Rename FlushStream to OnFlushRequest; add FlushOutput Change-Id: I2b37030b0c35aa34e9c72e43825f157924034227
2017-02-22 20:14:26 +00:00
ASSERT_OK(OnFlushRequest(kStreamIndex0));
ASSERT_OK(OnFlushRequest(kStreamIndex1));
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(), IsEmpty());
}
} // namespace media
} // namespace shaka