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

Move and rename webvtt fragmenter to webvtt sample converter 

- The class should be used to generate samples from the demuxer.

Change-Id: If7f245e5809de8773c0b1cf08673ae62dfeffe09
This commit is contained in:
Rintaro Kuroiwa 2017-02-13 14:25:34 -08:00
parent 593f513c83
commit 5c07ff6b1c
9 changed files with 196 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packager/media/formats/mp4/mp4.gyp
View File

@ -46,15 +46,12 @@
'sync_sample_iterator.h',
'track_run_iterator.cc',
'track_run_iterator.h',
'webvtt_fragmenter.cc',
'webvtt_fragmenter.h',
],
'dependencies': [
'../../../third_party/boringssl/boringssl.gyp:boringssl',
'../../base/media_base.gyp:media_base',
'../../codecs/codecs.gyp:codecs',
'../../event/media_event.gyp:media_event',
'../../formats/webvtt/webvtt.gyp:webvtt',
],
},
{
@ -69,7 +66,6 @@
'mp4_media_parser_unittest.cc',
'sync_sample_iterator_unittest.cc',
'track_run_iterator_unittest.cc',
'webvtt_fragmenter_unittest.cc',
],
'dependencies': [
'../../../testing/gtest.gyp:gtest',

60
packager/media/formats/webvtt/cue.cc Normal file
View File

@ -0,0 +1,60 @@
#include "packager/media/formats/webvtt/cue.h"
#include "packager/base/strings/string_util.h"
namespace shaka {
namespace media {
Cue::Cue() : start_time(0), duration(0) {}
Cue::~Cue() {}
// Mapping:
// comment --> side data (and side data only sample)
// settings --> side data
// start_time --> pts
std::shared_ptr<MediaSample> CueToMediaSample(const Cue& cue) {
const bool kKeyFrame = true;
if (!cue.comment.empty()) {
const std::string comment = base::JoinString(cue.comment, "\n");
return MediaSample::FromMetadata(
reinterpret_cast<const uint8_t*>(comment.data()), comment.size());
}
const std::string payload = base::JoinString(cue.payload, "\n");
std::shared_ptr<MediaSample> media_sample = MediaSample::CopyFrom(
reinterpret_cast<const uint8_t*>(payload.data()), payload.size(),
reinterpret_cast<const uint8_t*>(cue.settings.data()),
cue.settings.size(), !kKeyFrame);
media_sample->set_config_id(cue.identifier);
media_sample->set_pts(cue.start_time);
media_sample->set_duration(cue.duration);
return media_sample;
}
// TODO(rkuroiwa): Cue gets converted to MediaSample in WebVttMediaParser and
// then back to Cue in the muxer. Consider making MediaSample a protobuf or make
// Cue a protobuf and (ab)use MediaSample::data() to store serialized Cue.
Cue MediaSampleToCue(const MediaSample& sample) {
Cue cue;
if (sample.data_size() == 0) {
std::string comment(sample.side_data(),
sample.side_data() + sample.side_data_size());
cue.comment.push_back(comment);
return cue;
}
std::string payload(sample.data(), sample.data() + sample.data_size());
cue.payload.push_back(payload);
cue.identifier.assign(sample.config_id());
cue.start_time = sample.pts();
cue.duration = sample.duration();
if (sample.side_data_size() != 0) {
cue.settings.assign(sample.side_data(),
sample.side_data() + sample.side_data_size());
}
return cue;
}
} // namespace media
} // namespace shaka

38
packager/media/formats/webvtt/cue.h Normal file
View File

@ -0,0 +1,38 @@
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "packager/media/base/media_sample.h"
namespace shaka {
namespace media {
// If comment is not empty, then this is metadata and other fields must
// be empty.
// Data that can be multiline are vector of strings.
struct Cue {
Cue();
~Cue();
std::string identifier;
uint64_t start_time;
uint64_t duration;
std::string settings;
std::vector<std::string> payload;
std::vector<std::string> comment;
};
/// Convert Cue to MediaSample.
/// @param cue data.
/// @return @a cue converted to a MediaSample.
std::shared_ptr<MediaSample> CueToMediaSample(const Cue& cue);
/// Convert MediaSample to Cue.
/// @param sample to be converted.
/// @return @a sample converted to Cue.
Cue MediaSampleToCue(const MediaSample& sample);
} // namespace media
} // namespace shaka

6
packager/media/formats/webvtt/webvtt.gyp
View File

@ -13,12 +13,17 @@
'target_name': 'webvtt',
'type': '<(component)',
'sources': [
'cue.cc',
'cue.h',
'webvtt_media_parser.cc',
'webvtt_media_parser.h',
'webvtt_sample_converter.cc',
'webvtt_sample_converter.h',
],
'dependencies': [
'../../../base/base.gyp:base',
'../../base/media_base.gyp:media_base',
'../../formats/mp4/mp4.gyp:mp4',
],
},
{
@ -26,6 +31,7 @@
'type': '<(gtest_target_type)',
'sources': [
'webvtt_media_parser_unittest.cc',
'webvtt_sample_converter_unittest.cc',
],
'dependencies': [
'../../../testing/gmock.gyp:gmock',

51
packager/media/formats/webvtt/webvtt_media_parser.cc
View File

@ -186,57 +186,6 @@ bool ParseTimingAndSettingsLine(const std::string& line,
} // namespace
Cue::Cue() : start_time(0), duration(0) {}
Cue::~Cue() {}
// Mapping:
// comment --> side data (and side data only sample)
// settings --> side data
// start_time --> pts
std::shared_ptr<MediaSample> CueToMediaSample(const Cue& cue) {
const bool kKeyFrame = true;
if (!cue.comment.empty()) {
const std::string comment = base::JoinString(cue.comment, "\n");
return MediaSample::FromMetadata(
reinterpret_cast<const uint8_t*>(comment.data()), comment.size());
}
const std::string payload = base::JoinString(cue.payload, "\n");
std::shared_ptr<MediaSample> media_sample = MediaSample::CopyFrom(
reinterpret_cast<const uint8_t*>(payload.data()), payload.size(),
reinterpret_cast<const uint8_t*>(cue.settings.data()),
cue.settings.size(), !kKeyFrame);
media_sample->set_config_id(cue.identifier);
media_sample->set_pts(cue.start_time);
media_sample->set_duration(cue.duration);
return media_sample;
}
// TODO(rkuroiwa): Cue gets converted to MediaSample in WebVttMediaParser and
// then back to Cue in the muxer. Consider making MediaSample a protobuf or make
// Cue a protobuf and (ab)use MediaSample::data() to store serialized Cue.
Cue MediaSampleToCue(const MediaSample& sample) {
Cue cue;
if (sample.data_size() == 0) {
std::string comment(sample.side_data(),
sample.side_data() + sample.side_data_size());
cue.comment.push_back(comment);
return cue;
}
std::string payload(sample.data(), sample.data() + sample.data_size());
cue.payload.push_back(payload);
cue.identifier.assign(sample.config_id());
cue.start_time = sample.pts();
cue.duration = sample.duration();
if (sample.side_data_size() != 0) {
cue.settings.assign(sample.side_data(),
sample.side_data() + sample.side_data_size());
}
return cue;
}
WebVttMediaParser::WebVttMediaParser() : state_(kHeader) {}
WebVttMediaParser::~WebVttMediaParser() {}

26
packager/media/formats/webvtt/webvtt_media_parser.h
View File

@ -13,35 +13,11 @@
#include "packager/base/compiler_specific.h"
#include "packager/media/base/media_parser.h"
#include "packager/media/formats/webvtt/cue.h"
namespace shaka {
namespace media {
// If comment is not empty, then this is metadata and other fields must
// be empty.
// Data that can be multiline are vector of strings.
struct Cue {
Cue();
~Cue();
std::string identifier;
uint64_t start_time;
uint64_t duration;
std::string settings;
std::vector<std::string> payload;
std::vector<std::string> comment;
};
/// Convert Cue to MediaSample.
/// @param cue data.
/// @return @a cue converted to a MediaSample.
std::shared_ptr<MediaSample> CueToMediaSample(const Cue& cue);
/// Convert MediaSample to Cue.
/// @param sample to be converted.
/// @return @a sample converted to Cue.
Cue MediaSampleToCue(const MediaSample& sample);
// WebVTT parser.
// The input may not be encrypted so decryption_key_source is ignored.
class WebVttMediaParser : public MediaParser {

34
packager/media/formats/mp4/webvtt_fragmenter.cc → packager/media/formats/webvtt/webvtt_sample_converter.cc
View File

@ -4,7 +4,7 @@
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#include "packager/media/formats/mp4/webvtt_fragmenter.h"
#include "packager/media/formats/webvtt/webvtt_sample_converter.h"
#include <algorithm>
#include <string>
@ -18,14 +18,13 @@
namespace shaka {
namespace media {
namespace mp4 {
namespace {
std::shared_ptr<MediaSample> CreateEmptyCueSample(uint64_t start_time,
uint64_t end_time) {
DCHECK_GT(end_time, start_time);
VTTEmptyCueBox empty_cue_box;
mp4::VTTEmptyCueBox empty_cue_box;
std::vector<uint8_t> serialized;
AppendBoxToVector(&empty_cue_box, &serialized);
@ -37,8 +36,8 @@ std::shared_ptr<MediaSample> CreateEmptyCueSample(uint64_t start_time,
return empty_cue_sample;
}
VTTCueBox CueBoxFromCue(const Cue& cue) {
VTTCueBox cue_box;
mp4::VTTCueBox CueBoxFromCue(const Cue& cue) {
mp4::VTTCueBox cue_box;
if (!cue.identifier.empty()) {
cue_box.cue_id.cue_id = cue.identifier;
}
@ -77,7 +76,7 @@ std::shared_ptr<MediaSample> CreateVTTCueBoxesSample(
BufferWriter writer;
for (const Cue* cue : cues) {
VTTCueBox cue_box = CueBoxFromCue(*cue);
mp4::VTTCueBox cue_box = CueBoxFromCue(*cue);
// If there is internal timing, i.e. WebVTT cue timestamp, then
// cue_current_time should be populated
// "which gives the VTT timestamp associated with the start time of sample."
@ -115,7 +114,7 @@ uint64_t GetMinimumPastSweepLine(uint64_t cue_start_time,
} // namespace
void AppendBoxToVector(Box* box, std::vector<uint8_t>* output_vector) {
void AppendBoxToVector(mp4::Box* box, std::vector<uint8_t>* output_vector) {
BufferWriter writer;
box->Write(&writer);
output_vector->insert(output_vector->end(),
@ -123,15 +122,15 @@ void AppendBoxToVector(Box* box, std::vector<uint8_t>* output_vector) {
writer.Buffer() + writer.Size());
}
WebVttFragmenter::WebVttFragmenter() : next_cue_start_time_(0u) {}
WebVttFragmenter::~WebVttFragmenter() {}
WebVttSampleConverter::WebVttSampleConverter() : next_cue_start_time_(0u) {}
WebVttSampleConverter::~WebVttSampleConverter() {}
// Note that this |sample| is either a cue or a comment. It does not have any
// info on whether the next cue is overlapping or not.
void WebVttFragmenter::PushSample(std::shared_ptr<MediaSample> sample) {
void WebVttSampleConverter::PushSample(std::shared_ptr<MediaSample> sample) {
if (sample->data_size() == 0u) {
// A comment. Put it in the buffer and skip.
VTTAdditionalTextBox comment;
mp4::VTTAdditionalTextBox comment;
comment.cue_additional_text.assign(
sample->side_data(), sample->side_data() + sample->side_data_size());
additional_texts_.push_back(comment);
@ -164,7 +163,7 @@ void WebVttFragmenter::PushSample(std::shared_ptr<MediaSample> sample) {
cues_.erase(cues_.begin(), erase_last_iterator);
}
void WebVttFragmenter::Flush() {
void WebVttSampleConverter::Flush() {
if (cues_.empty())
return;
if (cues_.size() == 1) {
@ -185,11 +184,11 @@ void WebVttFragmenter::Flush() {
cues_.clear();
}
size_t WebVttFragmenter::ReadySamplesSize() {
size_t WebVttSampleConverter::ReadySamplesSize() {
return ready_samples_.size();
}
std::shared_ptr<MediaSample> WebVttFragmenter::PopSample() {
std::shared_ptr<MediaSample> WebVttSampleConverter::PopSample() {
CHECK(!ready_samples_.empty());
std::shared_ptr<MediaSample> ret = ready_samples_.front();
ready_samples_.pop_front();
@ -208,7 +207,7 @@ std::shared_ptr<MediaSample> WebVttFragmenter::PopSample() {
// Change algorithm to create A,B,C samples right away.
// Note that this requires change to the caller on which cues
// to remove.
bool WebVttFragmenter::HandleAllCuesButLatest() {
bool WebVttSampleConverter::HandleAllCuesButLatest() {
DCHECK_GE(cues_.size(), 2u);
const Cue& latest_cue = cues_.back();
@ -246,7 +245,7 @@ bool WebVttFragmenter::HandleAllCuesButLatest() {
return processed_cues;
}
bool WebVttFragmenter::HandleAllCues() {
bool WebVttSampleConverter::HandleAllCues() {
uint64_t latest_time = 0u;
for (const Cue& cue : cues_) {
if (cue.start_time + cue.duration > latest_time)
@ -259,7 +258,7 @@ bool WebVttFragmenter::HandleAllCues() {
return processed;
}
bool WebVttFragmenter::SweepCues(uint64_t sweep_line,
bool WebVttSampleConverter::SweepCues(uint64_t sweep_line,
uint64_t sweep_stop_time) {
bool processed_cues = false;
// This is a sweep line algorithm. For every iteration, it determines active
@ -308,6 +307,5 @@ bool WebVttFragmenter::SweepCues(uint64_t sweep_line,
return processed_cues;
}
} // namespace mp4
} // namespace media
} // namespace shaka

30
packager/media/formats/mp4/webvtt_fragmenter.h → packager/media/formats/webvtt/webvtt_sample_converter.h
View File

@ -4,24 +4,24 @@
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
#ifndef PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_
#define PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_
#ifndef PACKAGER_MEDIA_FORMATS_WEBVTT_WEBVTT_SAMPLE_CONVERTER_H_
#define PACKAGER_MEDIA_FORMATS_WEBVTT_WEBVTT_SAMPLE_CONVERTER_H_
#include <stdint.h>
#include <list>
#include "packager/media/base/status.h"
#include "packager/media/formats/mp4/box.h"
#include "packager/media/formats/mp4/box_definitions.h"
#include "packager/media/formats/webvtt/webvtt_media_parser.h"
#include "packager/media/formats/webvtt/cue.h"
namespace shaka {
namespace media {
namespace mp4 {
/// Appends box to vector.
/// @param box is the box to be serialized.
/// @param output_vector is where the data is appended.
void AppendBoxToVector(Box* box, std::vector<uint8_t>* output_vector);
void AppendBoxToVector(mp4::Box* box, std::vector<uint8_t>* output_vector);
/// According to the spec, when cues overlap, samples must be created.\n
/// The example below has 2 WebVTT cues:\n
@ -51,15 +51,10 @@ void AppendBoxToVector(Box* box, std::vector<uint8_t>* output_vector);
///\n
/// This class buffers the samples that are passed to AddSample() and creates
/// more samples as necessary.
// TODO(rkuroiwa): Rename this to WebVttSampleConverter, and put this in
// webvtt parser.
// For now, the output (from PopSample()) should still be in ISO-BMFF box form;
// and also to signal that, should have different types for TextStreamInfo. e.g.
// TextStreamInfo::type() returns kIsoBmffStreamText.
class WebVttFragmenter {
class WebVttSampleConverter {
public:
WebVttFragmenter();
~WebVttFragmenter();
WebVttSampleConverter();
~WebVttSampleConverter();
/// Add a sample.
/// @param sample is the sample to be added. It should contain one VTT cue.
@ -104,7 +99,7 @@ class WebVttFragmenter {
std::list<Cue> cues_;
// For comment samples.
std::list<VTTAdditionalTextBox> additional_texts_;
std::list<mp4::VTTAdditionalTextBox> additional_texts_;
// Samples that are ready to be processed.
std::list<std::shared_ptr<MediaSample>> ready_samples_;
@ -114,11 +109,10 @@ class WebVttFragmenter {
// or an empty cue (gap) has to be added.
uint64_t next_cue_start_time_;
DISALLOW_COPY_AND_ASSIGN(WebVttFragmenter);
DISALLOW_COPY_AND_ASSIGN(WebVttSampleConverter);
};
} // namespace shaka
} // namespace media
} // namespace edash_packager
} // namespace shaka
#endif // PACKAGER_MEDIA_FORMATS_MP4_FRAGMENTER_H_
#endif // PACKAGER_MEDIA_FORMATS_WEBVTT_WEBVTT_SAMPLE_CONVERTER_H_

122
packager/media/formats/mp4/webvtt_fragmenter_unittest.cc → packager/media/formats/webvtt/webvtt_sample_converter_unittest.cc
View File

@ -1,4 +1,4 @@
#include "packager/media/formats/mp4/webvtt_fragmenter.h"
#include "packager/media/formats/webvtt/webvtt_sample_converter.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
@ -32,7 +32,7 @@ MATCHER_P3(MatchesStartTimeEndTimeAndData, start_time, end_time, data, "") {
class WebVttFragmenterTest : public ::testing::Test {
protected:
WebVttFragmenter webvtt_fragmenter_;
WebVttSampleConverter webvtt_sample_converter_;
};
// Verify that AppednBoxToVector works.
@ -89,7 +89,7 @@ TEST_F(WebVttFragmenterTest, NoOverlapContiguous) {
sample1->set_dts(0);
sample1->set_duration(2000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -98,22 +98,22 @@ TEST_F(WebVttFragmenterTest, NoOverlapContiguous) {
sample2->set_dts(2000);
sample2->set_duration(1000);
webvtt_fragmenter_.PushSample(sample2);
webvtt_fragmenter_.Flush();
EXPECT_EQ(2u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.PushSample(sample2);
webvtt_sample_converter_.Flush();
EXPECT_EQ(2u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_cue_data;
first_cue_data.cue_payload.cue_text = kCueMessage1;
std::vector<uint8_t> expected;
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 2000, expected));
VTTCueBox second_cue_data;
second_cue_data.cue_payload.cue_text = kCueMessage2;
expected.clear();
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2000, 3000, expected));
}
@ -126,7 +126,7 @@ TEST_F(WebVttFragmenterTest, Gap) {
sample1->set_dts(0);
sample1->set_duration(1000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -135,30 +135,30 @@ TEST_F(WebVttFragmenterTest, Gap) {
sample2->set_dts(2000);
sample2->set_duration(1000);
webvtt_fragmenter_.PushSample(sample2);
EXPECT_EQ(2u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.PushSample(sample2);
EXPECT_EQ(2u, webvtt_sample_converter_.ReadySamplesSize());
webvtt_fragmenter_.Flush();
EXPECT_EQ(3u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.Flush();
EXPECT_EQ(3u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_cue_data;
first_cue_data.cue_payload.cue_text = kCueMessage1;
std::vector<uint8_t> expected;
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 1000, expected));
VTTEmptyCueBox empty_cue;
expected.clear();
AppendBoxToVector(&empty_cue, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1000, 2000, expected));
VTTCueBox second_cue_data;
second_cue_data.cue_payload.cue_text = kCueMessage2;
expected.clear();
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2000, 3000, expected));
}
@ -172,7 +172,7 @@ TEST_F(WebVttFragmenterTest, OverlappingCuesSequential) {
sample1->set_dts(0);
sample1->set_duration(2000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -180,7 +180,7 @@ TEST_F(WebVttFragmenterTest, OverlappingCuesSequential) {
sample2->set_pts(1000);
sample2->set_dts(1000);
sample2->set_duration(2000);
webvtt_fragmenter_.PushSample(sample2);
webvtt_sample_converter_.PushSample(sample2);
std::shared_ptr<MediaSample> sample3 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage3),
@ -188,18 +188,18 @@ TEST_F(WebVttFragmenterTest, OverlappingCuesSequential) {
sample3->set_pts(1500);
sample3->set_dts(1500);
sample3->set_duration(4000);
webvtt_fragmenter_.PushSample(sample3);
webvtt_sample_converter_.PushSample(sample3);
webvtt_fragmenter_.Flush();
webvtt_sample_converter_.Flush();
// There should be 5 samples for [0,1000], [1000,1500], [1500,2000],
// [2000,3000], and [3000, 5500].
EXPECT_EQ(5u, webvtt_fragmenter_.ReadySamplesSize());
EXPECT_EQ(5u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_cue_data;
first_cue_data.cue_payload.cue_text = kCueMessage1;
std::vector<uint8_t> expected;
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 1000, expected));
VTTCueBox second_cue_data;
@ -207,7 +207,7 @@ TEST_F(WebVttFragmenterTest, OverlappingCuesSequential) {
expected.clear();
AppendBoxToVector(&first_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1000, 1500, expected));
VTTCueBox third_cue_data;
@ -216,18 +216,18 @@ TEST_F(WebVttFragmenterTest, OverlappingCuesSequential) {
AppendBoxToVector(&first_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
AppendBoxToVector(&third_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1500, 2000, expected));
expected.clear();
AppendBoxToVector(&second_cue_data, &expected);
AppendBoxToVector(&third_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2000, 3000, expected));
expected.clear();
AppendBoxToVector(&third_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(3000, 5500, expected));
}
@ -239,7 +239,7 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
sample1->set_dts(0);
sample1->set_duration(10000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -247,7 +247,7 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
sample2->set_pts(1000);
sample2->set_dts(1000);
sample2->set_duration(5000);
webvtt_fragmenter_.PushSample(sample2);
webvtt_sample_converter_.PushSample(sample2);
std::shared_ptr<MediaSample> sample3 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage3),
@ -255,7 +255,7 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
sample3->set_pts(2000);
sample3->set_dts(2000);
sample3->set_duration(1000);
webvtt_fragmenter_.PushSample(sample3);
webvtt_sample_converter_.PushSample(sample3);
std::shared_ptr<MediaSample> sample4 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage4),
@ -263,18 +263,18 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
sample4->set_pts(8000);
sample4->set_dts(8000);
sample4->set_duration(1000);
webvtt_fragmenter_.PushSample(sample4);
webvtt_fragmenter_.Flush();
webvtt_sample_converter_.PushSample(sample4);
webvtt_sample_converter_.Flush();
// There should be 7 samples for [0,1000], [1000,2000], [2000,3000],
// [3000,6000], [6000, 8000], [8000, 9000], [9000, 10000].
EXPECT_EQ(7u, webvtt_fragmenter_.ReadySamplesSize());
EXPECT_EQ(7u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_long_cue_data;
first_long_cue_data.cue_payload.cue_text = kCueMessage1;
std::vector<uint8_t> expected;
AppendBoxToVector(&first_long_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 1000, expected));
VTTCueBox second_cue_data;
@ -282,7 +282,7 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
expected.clear();
AppendBoxToVector(&first_long_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1000, 2000, expected));
VTTCueBox third_cue_data;
@ -291,18 +291,18 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
AppendBoxToVector(&first_long_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
AppendBoxToVector(&third_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2000, 3000, expected));
expected.clear();
AppendBoxToVector(&first_long_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(3000, 6000, expected));
expected.clear();
AppendBoxToVector(&first_long_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(6000, 8000, expected));
VTTCueBox fourth_cue_data;
@ -310,12 +310,12 @@ TEST_F(WebVttFragmenterTest, OverlappingLongCue) {
expected.clear();
AppendBoxToVector(&first_long_cue_data, &expected);
AppendBoxToVector(&fourth_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(8000, 9000, expected));
expected.clear();
AppendBoxToVector(&first_long_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(9000, 10000, expected));
}
@ -326,16 +326,16 @@ TEST_F(WebVttFragmenterTest, GapAtBeginning) {
sample1->set_pts(1200);
sample1->set_dts(1200);
sample1->set_duration(2000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
webvtt_fragmenter_.Flush();
EXPECT_EQ(1u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.Flush();
EXPECT_EQ(1u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox cue_data;
cue_data.cue_payload.cue_text = kCueMessage1;
std::vector<uint8_t> expected;
AppendBoxToVector(&cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1200, 3200, expected));
}
@ -348,7 +348,7 @@ TEST_F(WebVttFragmenterTest, SameStartTime) {
sample1->set_dts(0);
sample1->set_duration(2000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -357,9 +357,9 @@ TEST_F(WebVttFragmenterTest, SameStartTime) {
sample2->set_dts(0);
sample2->set_duration(1500);
webvtt_fragmenter_.PushSample(sample2);
webvtt_fragmenter_.Flush();
EXPECT_EQ(2u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.PushSample(sample2);
webvtt_sample_converter_.Flush();
EXPECT_EQ(2u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_cue_data;
first_cue_data.cue_payload.cue_text = kCueMessage1;
@ -369,12 +369,12 @@ TEST_F(WebVttFragmenterTest, SameStartTime) {
std::vector<uint8_t> expected;
AppendBoxToVector(&first_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 1500, expected));
expected.clear();
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1500, 2000, expected));
}
@ -387,7 +387,7 @@ TEST_F(WebVttFragmenterTest, MoreCases) {
sample1->set_dts(0);
sample1->set_duration(2000);
webvtt_fragmenter_.PushSample(sample1);
webvtt_sample_converter_.PushSample(sample1);
std::shared_ptr<MediaSample> sample2 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage2),
@ -396,7 +396,7 @@ TEST_F(WebVttFragmenterTest, MoreCases) {
sample2->set_dts(100);
sample2->set_duration(100);
webvtt_fragmenter_.PushSample(sample2);
webvtt_sample_converter_.PushSample(sample2);
std::shared_ptr<MediaSample> sample3 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage3),
@ -404,7 +404,7 @@ TEST_F(WebVttFragmenterTest, MoreCases) {
sample3->set_pts(1500);
sample3->set_dts(1500);
sample3->set_duration(1000);
webvtt_fragmenter_.PushSample(sample3);
webvtt_sample_converter_.PushSample(sample3);
std::shared_ptr<MediaSample> sample4 =
MediaSample::CopyFrom(reinterpret_cast<const uint8_t*>(kCueMessage4),
@ -412,10 +412,10 @@ TEST_F(WebVttFragmenterTest, MoreCases) {
sample4->set_pts(1500);
sample4->set_dts(1500);
sample4->set_duration(800);
webvtt_fragmenter_.PushSample(sample4);
webvtt_sample_converter_.PushSample(sample4);
webvtt_fragmenter_.Flush();
EXPECT_EQ(6u, webvtt_fragmenter_.ReadySamplesSize());
webvtt_sample_converter_.Flush();
EXPECT_EQ(6u, webvtt_sample_converter_.ReadySamplesSize());
VTTCueBox first_cue_data;
first_cue_data.cue_payload.cue_text = kCueMessage1;
@ -428,36 +428,36 @@ TEST_F(WebVttFragmenterTest, MoreCases) {
std::vector<uint8_t> expected;
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(0, 100, expected));
expected.clear();
AppendBoxToVector(&first_cue_data, &expected);
AppendBoxToVector(&second_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(100, 200, expected));
expected.clear();
AppendBoxToVector(&first_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(200, 1500, expected));
expected.clear();
AppendBoxToVector(&first_cue_data, &expected);
AppendBoxToVector(&third_cue_data, &expected);
AppendBoxToVector(&fourth_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(1500, 2000, expected));
expected.clear();
AppendBoxToVector(&third_cue_data, &expected);
AppendBoxToVector(&fourth_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2000, 2300, expected));
expected.clear();
AppendBoxToVector(&third_cue_data, &expected);
EXPECT_THAT(webvtt_fragmenter_.PopSample(),
EXPECT_THAT(webvtt_sample_converter_.PopSample(),
MatchesStartTimeEndTimeAndData(2300, 2500, expected));
}