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

Use size_t as the type of stream_index 

Change-Id: Ica8ffeccc45c1adf5def6fe9b2edde5708d6b432
This commit is contained in:
Kongqun Yang 2017-03-02 16:10:30 -08:00 committed by KongQun Yang
parent 160700b452
commit 8806f78655
18 changed files with 86 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
packager/media/base/demuxer.cc
View File

@ -30,22 +30,22 @@ const size_t kBufSize = 0x200000; // 2MB
// samples before seeing init_event, something is not right. The number
// set here is arbitrary though.
const size_t kQueuedSamplesLimit = 10000;
const int kInvalidStreamIndex = -1;
const int kBaseVideoOutputStreamIndex = 0x100;
const int kBaseAudioOutputStreamIndex = 0x200;
const size_t kInvalidStreamIndex = static_cast<size_t>(-1);
const size_t kBaseVideoOutputStreamIndex = 0x100;
const size_t kBaseAudioOutputStreamIndex = 0x200;
std::string GetStreamLabel(int stream_index) {
std::string GetStreamLabel(size_t stream_index) {
switch (stream_index) {
case kBaseVideoOutputStreamIndex:
return "video";
case kBaseAudioOutputStreamIndex:
return "audio";
default:
return base::IntToString(stream_index);
return base::SizeTToString(stream_index);
}
}
bool GetStreamIndex(const std::string& stream_label, int* stream_index) {
bool GetStreamIndex(const std::string& stream_label, size_t* stream_index) {
DCHECK(stream_index);
if (stream_label == "video") {
*stream_index = kBaseVideoOutputStreamIndex;
@ -53,7 +53,7 @@ bool GetStreamIndex(const std::string& stream_label, int* stream_index) {
*stream_index = kBaseAudioOutputStreamIndex;
} else {
// Expect stream_label to be a zero based stream id.
if (!base::StringToInt(stream_label, stream_index)) {
if (!base::StringToSizeT(stream_label, stream_index)) {
LOG(ERROR) << "Invalid argument --stream=" << stream_label << "; "
<< "should be 'audio', 'video', or a number";
return false;
@ -106,7 +106,7 @@ Status Demuxer::Run() {
return Status(error::CANCELLED, "Demuxer run cancelled");
if (status.error_code() == error::END_OF_STREAM) {
for (int stream_index : stream_indexes_) {
for (size_t stream_index : stream_indexes_) {
status = FlushDownstream(stream_index);
if (!status.ok())
return status;
@ -122,7 +122,7 @@ void Demuxer::Cancel() {
Status Demuxer::SetHandler(const std::string& stream_label,
std::shared_ptr<MediaHandler> handler) {
int stream_index = kInvalidStreamIndex;
size_t stream_index = kInvalidStreamIndex;
if (!GetStreamIndex(stream_label, &stream_index)) {
return Status(error::INVALID_ARGUMENT,
"Invalid stream: " + stream_label);
@ -132,7 +132,7 @@ Status Demuxer::SetHandler(const std::string& stream_label,
void Demuxer::SetLanguageOverride(const std::string& stream_label,
const std::string& language_override) {
int stream_index = kInvalidStreamIndex;
size_t stream_index = kInvalidStreamIndex;
if (!GetStreamIndex(stream_label, &stream_index))
LOG(WARNING) << "Invalid stream for language override " << stream_label;
language_overrides_[stream_index] = language_override;
@ -222,7 +222,7 @@ void Demuxer::ParserInitEvent(
output_handlers().find(kBaseAudioOutputStreamIndex) !=
output_handlers().end();
for (const std::shared_ptr<StreamInfo>& stream_info : stream_infos) {
int stream_index = base_stream_index;
size_t stream_index = base_stream_index;
if (video_handler_set && stream_info->stream_type() == kStreamVideo) {
stream_index = kBaseVideoOutputStreamIndex;
// Only for the first video stream.

8
packager/media/base/demuxer.h
View File

@ -82,7 +82,7 @@ class Demuxer : public MediaHandler {
return Status(error::INTERNAL_ERROR,
"Demuxer should not be the downstream handler.");
}
bool ValidateOutputStreamIndex(int stream_index) const override {
bool ValidateOutputStreamIndex(size_t stream_index) const override {
// We don't know if the stream is valid or not when setting up the graph.
// Will validate the stream index later when stream info is available.
return true;
@ -128,12 +128,12 @@ class Demuxer : public MediaHandler {
std::deque<QueuedSample> queued_samples_;
std::unique_ptr<MediaParser> parser_;
// TrackId -> StreamIndex map.
std::map<uint32_t, int> track_id_to_stream_index_map_;
std::map<uint32_t, size_t> track_id_to_stream_index_map_;
// The list of stream indexes in the above map (in the same order as the input
// stream info vector).
std::vector<int> stream_indexes_;
std::vector<size_t> stream_indexes_;
// StreamIndex -> language_override map.
std::map<int, std::string> language_overrides_;
std::map<size_t, std::string> language_overrides_;
MediaContainerName container_name_ = CONTAINER_UNKNOWN;
std::unique_ptr<uint8_t[]> buffer_;
std::unique_ptr<KeySource> key_source_;

16
packager/media/base/media_handler.cc
View File

@ -9,10 +9,8 @@
namespace shaka {
namespace media {
Status MediaHandler::SetHandler(int output_stream_index,
Status MediaHandler::SetHandler(size_t output_stream_index,
std::shared_ptr<MediaHandler> handler) {
if (output_stream_index < 0)
return Status(error::INVALID_ARGUMENT, "Invalid output stream index");
if (output_handlers_.find(output_stream_index) != output_handlers_.end()) {
return Status(error::ALREADY_EXISTS,
"The handler at the specified index already exists.");
@ -40,19 +38,19 @@ Status MediaHandler::Initialize() {
return Status::OK;
}
Status MediaHandler::OnFlushRequest(int input_stream_index) {
Status MediaHandler::OnFlushRequest(size_t input_stream_index) {
// The default implementation treats the output stream index to be identical
// to the input stream index, which is true for most handlers.
const int output_stream_index = input_stream_index;
const size_t output_stream_index = input_stream_index;
return FlushDownstream(output_stream_index);
}
bool MediaHandler::ValidateOutputStreamIndex(int stream_index) const {
return stream_index >= 0 && stream_index < num_input_streams_;
bool MediaHandler::ValidateOutputStreamIndex(size_t stream_index) const {
return stream_index < num_input_streams_;
}
Status MediaHandler::Dispatch(std::unique_ptr<StreamData> stream_data) {
int output_stream_index = stream_data->stream_index;
size_t output_stream_index = stream_data->stream_index;
auto handler_it = output_handlers_.find(output_stream_index);
if (handler_it == output_handlers_.end()) {
return Status(error::NOT_FOUND,
@ -62,7 +60,7 @@ Status MediaHandler::Dispatch(std::unique_ptr<StreamData> stream_data) {
return handler_it->second.first->Process(std::move(stream_data));
}
Status MediaHandler::FlushDownstream(int output_stream_index) {
Status MediaHandler::FlushDownstream(size_t output_stream_index) {
auto handler_it = output_handlers_.find(output_stream_index);
if (handler_it == output_handlers_.end()) {
return Status(error::NOT_FOUND,

37
packager/media/base/media_handler.h
View File

@ -41,7 +41,7 @@ struct SegmentInfo {
// TODO(kqyang): Should we use protobuf?
struct StreamData {
int stream_index = -1;
size_t stream_index = -1;
StreamDataType stream_data_type = StreamDataType::kUnknown;
std::shared_ptr<PeriodInfo> period_info;
@ -73,7 +73,7 @@ class MediaHandler {
virtual ~MediaHandler() = default;
/// Connect downstream handler at the specified output stream index.
Status SetHandler(int output_stream_index,
Status SetHandler(size_t output_stream_index,
std::shared_ptr<MediaHandler> handler);
/// Connect downstream handler to the next availble output stream index.
@ -97,20 +97,20 @@ class MediaHandler {
virtual Status Process(std::unique_ptr<StreamData> stream_data) = 0;
/// Event handler for flush request at the specific input stream index.
virtual Status OnFlushRequest(int input_stream_index);
virtual Status OnFlushRequest(size_t input_stream_index);
/// Validate if the stream at the specified index actually exists.
virtual bool ValidateOutputStreamIndex(int stream_index) const;
virtual bool ValidateOutputStreamIndex(size_t stream_index) const;
bool initialized() { return initialized_; }
int num_input_streams() { return num_input_streams_; }
size_t num_input_streams() { return num_input_streams_; }
/// Dispatch the stream data to downstream handlers. Note that
/// stream_data.stream_index should be the output stream index.
Status Dispatch(std::unique_ptr<StreamData> stream_data);
/// Dispatch the period info to downstream handlers.
Status DispatchPeriodInfo(int stream_index,
Status DispatchPeriodInfo(size_t stream_index,
std::shared_ptr<PeriodInfo> period_info) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -120,7 +120,7 @@ class MediaHandler {
}
/// Dispatch the stream info to downstream handlers.
Status DispatchStreamInfo(int stream_index,
Status DispatchStreamInfo(size_t stream_index,
std::shared_ptr<StreamInfo> stream_info) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -131,7 +131,7 @@ class MediaHandler {
/// Dispatch the encryption config to downstream handlers.
Status DispatchEncryptionConfig(
int stream_index,
size_t stream_index,
std::unique_ptr<EncryptionConfig> encryption_config) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -141,7 +141,7 @@ class MediaHandler {
}
/// Dispatch the media sample to downstream handlers.
Status DispatchMediaSample(int stream_index,
Status DispatchMediaSample(size_t stream_index,
std::shared_ptr<MediaSample> media_sample) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -151,7 +151,7 @@ class MediaHandler {
}
/// Dispatch the media event to downstream handlers.
Status DispatchMediaEvent(int stream_index,
Status DispatchMediaEvent(size_t stream_index,
std::shared_ptr<MediaEvent> media_event) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -161,7 +161,7 @@ class MediaHandler {
}
/// Dispatch the segment info to downstream handlers.
Status DispatchSegmentInfo(int stream_index,
Status DispatchSegmentInfo(size_t stream_index,
std::shared_ptr<SegmentInfo> segment_info) {
std::unique_ptr<StreamData> stream_data(new StreamData);
stream_data->stream_index = stream_index;
@ -171,11 +171,11 @@ class MediaHandler {
}
/// Flush the downstream connected at the specified output stream index.
Status FlushDownstream(int output_stream_index);
Status FlushDownstream(size_t output_stream_index);
int num_input_streams() const { return num_input_streams_; }
int next_output_stream_index() const { return next_output_stream_index_; }
const std::map<int, std::pair<std::shared_ptr<MediaHandler>, int>>&
size_t num_input_streams() const { return num_input_streams_; }
size_t next_output_stream_index() const { return next_output_stream_index_; }
const std::map<size_t, std::pair<std::shared_ptr<MediaHandler>, size_t>>&
output_handlers() {
return output_handlers_;
}
@ -186,12 +186,13 @@ class MediaHandler {
bool initialized_ = false;
// Number of input streams.
int num_input_streams_ = 0;
size_t num_input_streams_ = 0;
// The next available output stream index, used by AddHandler.
int next_output_stream_index_ = 0;
size_t next_output_stream_index_ = 0;
// output stream index -> {output handler, output handler input stream index}
// map.
std::map<int, std::pair<std::shared_ptr<MediaHandler>, int>> output_handlers_;
std::map<size_t, std::pair<std::shared_ptr<MediaHandler>, size_t>>
output_handlers_;
};
} // namespace media

4
packager/media/base/media_handler_test_base.cc
View File

@ -73,8 +73,8 @@ class FakeMediaHandler : public MediaHandler {
stream_data_vector_.push_back(std::move(stream_data));
return Status::OK;
}
Status OnFlushRequest(int input_stream_index) override { return Status::OK; }
bool ValidateOutputStreamIndex(int stream_index) const override {
Status OnFlushRequest(size_t input_stream_index) override { return Status::OK; }
bool ValidateOutputStreamIndex(size_t stream_index) const override {
return true;
}

6
packager/media/base/muxer.h
View File

@ -97,7 +97,7 @@ class Muxer : public MediaHandler {
/// @{
Status InitializeInternal() override { return Status::OK; }
Status Process(std::unique_ptr<StreamData> stream_data) override;
Status OnFlushRequest(int input_stream_index) override { return Finalize(); }
Status OnFlushRequest(size_t input_stream_index) override { return Finalize(); }
/// @}
const MuxerOptions& options() const { return options_; }
@ -124,11 +124,11 @@ class Muxer : public MediaHandler {
virtual Status Finalize() = 0;
// Add a new sample.
virtual Status AddSample(int stream_id,
virtual Status AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) = 0;
// Finalize the segment or subsegment.
virtual Status FinalizeSegment(int stream_id,
virtual Status FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) = 0;
MuxerOptions options_;

14
packager/media/chunking/chunking_handler.cc
View File

@ -50,7 +50,7 @@ Status ChunkingHandler::Process(std::unique_ptr<StreamData> stream_data) {
// The video stream is treated as the main stream. If there is only one
// stream, it is the main stream.
const bool is_main_stream =
main_stream_index_ == -1 &&
main_stream_index_ == kInvalidStreamIndex &&
(stream_data->stream_info->stream_type() == kStreamVideo ||
num_input_streams() == 1);
if (is_main_stream) {
@ -70,7 +70,7 @@ Status ChunkingHandler::Process(std::unique_ptr<StreamData> stream_data) {
VLOG(3) << "Drop existing segment info.";
return Status::OK;
case StreamDataType::kMediaSample: {
const int stream_index = stream_data->stream_index;
const size_t stream_index = stream_data->stream_index;
DCHECK_NE(time_scales_[stream_index], 0u)
<< "kStreamInfo should arrive before kMediaSample";
if (stream_index != main_stream_index_) {
@ -111,7 +111,7 @@ Status ChunkingHandler::Process(std::unique_ptr<StreamData> stream_data) {
return Dispatch(std::move(stream_data));
}
Status ChunkingHandler::OnFlushRequest(int input_stream_index) {
Status ChunkingHandler::OnFlushRequest(size_t input_stream_index) {
if (segment_info_[input_stream_index]) {
Status status;
if (input_stream_index != main_stream_index_) {
@ -185,7 +185,7 @@ Status ChunkingHandler::DispatchNonMainSamples(int64_t timestamp_threshold) {
while (status.ok() && !non_main_samples_.empty()) {
DCHECK_EQ(non_main_samples_.front()->stream_data_type,
StreamDataType::kMediaSample);
const int stream_index = non_main_samples_.front()->stream_index;
const size_t stream_index = non_main_samples_.front()->stream_index;
const MediaSample* sample = non_main_samples_.front()->media_sample.get();
// If the portion of the sample before |timestamp_threshold| is bigger than
// the other portion, we consider it part of the current segment.
@ -225,8 +225,7 @@ Status ChunkingHandler::DispatchNonMainSamples(int64_t timestamp_threshold) {
Status ChunkingHandler::DispatchSegmentInfoForAllStreams() {
Status status;
for (int i = 0; i < static_cast<int>(segment_info_.size()) && status.ok();
++i) {
for (size_t i = 0; i < segment_info_.size() && status.ok(); ++i) {
if (segment_info_[i] && segment_info_[i]->start_timestamp != -1) {
segment_info_[i]->duration =
last_sample_end_timestamps_[i] - segment_info_[i]->start_timestamp;
@ -240,8 +239,7 @@ Status ChunkingHandler::DispatchSegmentInfoForAllStreams() {
Status ChunkingHandler::DispatchSubsegmentInfoForAllStreams() {
Status status;
for (int i = 0; i < static_cast<int>(subsegment_info_.size()) && status.ok();
++i) {
for (size_t i = 0; i < subsegment_info_.size() && status.ok(); ++i) {
if (subsegment_info_[i] && subsegment_info_[i]->start_timestamp != -1) {
subsegment_info_[i]->duration =
last_sample_end_timestamps_[i] - subsegment_info_[i]->start_timestamp;

5
packager/media/chunking/chunking_handler.h
View File

@ -68,7 +68,7 @@ class ChunkingHandler : public MediaHandler {
/// @{
Status InitializeInternal() override;
Status Process(std::unique_ptr<StreamData> stream_data) override;
Status OnFlushRequest(int input_stream_index) override;
Status OnFlushRequest(size_t input_stream_index) override;
/// @}
private:
@ -94,7 +94,8 @@ class ChunkingHandler : public MediaHandler {
// The video stream is the main stream; if there is only one stream, it is the
// main stream. The chunking is based on the main stream.
int main_stream_index_ = -1;
const size_t kInvalidStreamIndex = static_cast<size_t>(-1);
size_t main_stream_index_ = kInvalidStreamIndex;
// Segment and subsegment duration in main stream's time scale.
int64_t segment_duration_ = 0;
int64_t subsegment_duration_ = 0;

4
packager/media/chunking/chunking_handler_unittest.cc
View File

@ -18,8 +18,8 @@ using ::testing::IsEmpty;
namespace shaka {
namespace media {
namespace {
const int kStreamIndex0 = 0;
const int kStreamIndex1 = 1;
const size_t kStreamIndex0 = 0;
const size_t kStreamIndex1 = 1;
const uint32_t kTimeScale0 = 800;
const uint32_t kTimeScale1 = 1000;
const int64_t kDuration0 = 200;

4
packager/media/crypto/encryption_handler_unittest.cc
View File

@ -104,7 +104,7 @@ TEST_F(EncryptionHandlerTest, OnlyOneInput) {
namespace {
const int kStreamIndex = 0;
const size_t kStreamIndex = 0;
const bool kEncrypted = true;
const uint32_t kTimeScale = 1000;
const uint32_t kMaxSdPixels = 100u;
@ -335,7 +335,7 @@ TEST_P(EncryptionHandlerEncryptionTest, Encrypt) {
DoAll(SetArgPointee<1>(GetMockEncryptionKey()), Return(Status::OK)));
ASSERT_OK(Process(std::move(stream_data)));
ASSERT_EQ(2u, GetOutputStreamDataVector().size());
ASSERT_EQ(0, GetOutputStreamDataVector().back()->stream_index);
ASSERT_EQ(0u, GetOutputStreamDataVector().back()->stream_index);
ASSERT_EQ(StreamDataType::kMediaSample,
GetOutputStreamDataVector().back()->stream_data_type);

9
packager/media/formats/mp2t/ts_muxer.cc
View File

@ -34,14 +34,15 @@ Status TsMuxer::Finalize() {
return segmenter_->Finalize();
}
Status TsMuxer::AddSample(int stream_id, std::shared_ptr<MediaSample> sample) {
DCHECK_EQ(stream_id, 0);
Status TsMuxer::AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) {
DCHECK_EQ(stream_id, 0u);
return segmenter_->AddSample(sample);
}
Status TsMuxer::FinalizeSegment(int stream_id,
Status TsMuxer::FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) {
DCHECK_EQ(stream_id, 0);
DCHECK_EQ(stream_id, 0u);
return segment_info->is_subsegment
? Status::OK
: segmenter_->FinalizeSegment(segment_info->start_timestamp,

5
packager/media/formats/mp2t/ts_muxer.h
View File

@ -26,8 +26,9 @@ class TsMuxer : public Muxer {
// Muxer implementation.
Status InitializeMuxer() override;
Status Finalize() override;
Status AddSample(int stream_id, std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(int stream_id,
Status AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> sample) override;
void FireOnMediaStartEvent();

5
packager/media/formats/mp4/mp4_muxer.cc
View File

@ -161,12 +161,13 @@ Status MP4Muxer::Finalize() {
return Status::OK;
}
Status MP4Muxer::AddSample(int stream_id, std::shared_ptr<MediaSample> sample) {
Status MP4Muxer::AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) {
DCHECK(segmenter_);
return segmenter_->AddSample(stream_id, sample);
}
Status MP4Muxer::FinalizeSegment(int stream_id,
Status MP4Muxer::FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) {
DCHECK(segmenter_);
VLOG(3) << "Finalize " << (segment_info->is_subsegment ? "sub" : "")

5
packager/media/formats/mp4/mp4_muxer.h
View File

@ -37,8 +37,9 @@ class MP4Muxer : public Muxer {
// Muxer implementation overrides.
Status InitializeMuxer() override;
Status Finalize() override;
Status AddSample(int stream_id, std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(int stream_id,
Status AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) override;
// Generate Audio/Video Track box.

8
packager/media/formats/mp4/segmenter.cc
View File

@ -308,7 +308,7 @@ Status Segmenter::Finalize() {
return DoFinalize();
}
Status Segmenter::AddSample(int stream_id,
Status Segmenter::AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) {
// Set default sample duration if it has not been set yet.
if (moov_->extends.tracks[stream_id].default_sample_duration == 0) {
@ -316,7 +316,7 @@ Status Segmenter::AddSample(int stream_id,
sample->duration();
}
DCHECK_LT(stream_id, static_cast<int>(fragmenters_.size()));
DCHECK_LT(stream_id, fragmenters_.size());
Fragmenter* fragmenter = fragmenters_[stream_id].get();
if (fragmenter->fragment_finalized()) {
return Status(error::FRAGMENT_FINALIZED,
@ -333,8 +333,8 @@ Status Segmenter::AddSample(int stream_id,
return Status::OK;
}
Status Segmenter::FinalizeSegment(int stream_id, bool is_subsegment) {
DCHECK_LT(stream_id, static_cast<int>(fragmenters_.size()));
Status Segmenter::FinalizeSegment(size_t stream_id, bool is_subsegment) {
DCHECK_LT(stream_id, fragmenters_.size());
Fragmenter* fragmenter = fragmenters_[stream_id].get();
DCHECK(fragmenter);
fragmenter->FinalizeFragment();

4
packager/media/formats/mp4/segmenter.h
View File

@ -88,13 +88,13 @@ class Segmenter {
/// @param stream_id is the zero-based stream index.
/// @param sample points to the sample to be added.
/// @return OK on success, an error status otherwise.
Status AddSample(int stream_id, std::shared_ptr<MediaSample> sample);
Status AddSample(size_t stream_id, std::shared_ptr<MediaSample> sample);
/// Finalize the segment / subsegment.
/// @param stream_id is the zero-based stream index.
/// @param is_subsegment indicates if it is a subsegment (fragment).
/// @return OK on success, an error status otherwise.
Status FinalizeSegment(int stream_id, bool is_subsegment);
Status FinalizeSegment(size_t stream_id, bool is_subsegment);
/// @return true if there is an initialization range, while setting @a offset
/// and @a size; or false if initialization range does not apply.

8
packager/media/formats/webm/webm_muxer.cc
View File

@ -72,17 +72,17 @@ Status WebMMuxer::Finalize() {
return Status::OK;
}
Status WebMMuxer::AddSample(int stream_id,
Status WebMMuxer::AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) {
DCHECK(segmenter_);
DCHECK_EQ(stream_id, 0);
DCHECK_EQ(stream_id, 0u);
return segmenter_->AddSample(sample);
}
Status WebMMuxer::FinalizeSegment(int stream_id,
Status WebMMuxer::FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) {
DCHECK(segmenter_);
DCHECK_EQ(stream_id, 0);
DCHECK_EQ(stream_id, 0u);
return segmenter_->FinalizeSegment(segment_info->start_timestamp,
segment_info->duration,
segment_info->is_subsegment);

5
packager/media/formats/webm/webm_muxer.h
View File

@ -26,8 +26,9 @@ class WebMMuxer : public Muxer {
// Muxer implementation overrides.
Status InitializeMuxer() override;
Status Finalize() override;
Status AddSample(int stream_id, std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(int stream_id,
Status AddSample(size_t stream_id,
std::shared_ptr<MediaSample> sample) override;
Status FinalizeSegment(size_t stream_id,
std::shared_ptr<SegmentInfo> segment_info) override;
void FireOnMediaStartEvent();