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

Rename XxxConfiguration to XxxConfigurationRecord 

These are really configuration records.

Change-Id: I0d081c2e14f19bcdf8eb52dc094a1e7c096b5f98
This commit is contained in:
Kongqun Yang 2016-05-25 10:33:53 -07:00
parent 68aa1397b0
commit 6d281c6676
24 changed files with 177 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
packager/media/filters/avc_decoder_configuration.cc → packager/media/filters/avc_decoder_configuration_record.cc
View File

@ -4,7 +4,7 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/base/strings/string_number_conversions.h" #include "packager/base/strings/string_number_conversions.h"
#include "packager/base/strings/string_util.h" #include "packager/base/strings/string_util.h"
@ -15,15 +15,15 @@
namespace shaka { namespace shaka {
namespace media { namespace media {
AVCDecoderConfiguration::AVCDecoderConfiguration() AVCDecoderConfigurationRecord::AVCDecoderConfigurationRecord()
: version_(0), : version_(0),
profile_indication_(0), profile_indication_(0),
profile_compatibility_(0), profile_compatibility_(0),
avc_level_(0) {} avc_level_(0) {}
AVCDecoderConfiguration::~AVCDecoderConfiguration() {} AVCDecoderConfigurationRecord::~AVCDecoderConfigurationRecord() {}
bool AVCDecoderConfiguration::ParseInternal() { bool AVCDecoderConfigurationRecord::ParseInternal() {
// See ISO 14496-15 sec 5.3.3.1.2 // See ISO 14496-15 sec 5.3.3.1.2
BufferReader reader(data(), data_size()); BufferReader reader(data(), data_size());
@ -88,12 +88,12 @@ bool AVCDecoderConfiguration::ParseInternal() {
return true; return true;
} }
std::string AVCDecoderConfiguration::GetCodecString() const { std::string AVCDecoderConfigurationRecord::GetCodecString() const {
return GetCodecString(profile_indication_, profile_compatibility_, return GetCodecString(profile_indication_, profile_compatibility_,
avc_level_); avc_level_);
} }
std::string AVCDecoderConfiguration::GetCodecString( std::string AVCDecoderConfigurationRecord::GetCodecString(
uint8_t profile_indication, uint8_t profile_indication,
uint8_t profile_compatibility, uint8_t profile_compatibility,
uint8_t avc_level) { uint8_t avc_level) {

18
packager/media/filters/avc_decoder_configuration.h → packager/media/filters/avc_decoder_configuration_record.h
View File

@ -4,24 +4,24 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#ifndef MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_H_ #ifndef MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_RECORD_H_
#define MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_H_ #define MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_RECORD_H_
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
#include <vector> #include <vector>
#include "packager/base/macros.h" #include "packager/base/macros.h"
#include "packager/media/filters/decoder_configuration.h" #include "packager/media/filters/decoder_configuration_record.h"
namespace shaka { namespace shaka {
namespace media { namespace media {
/// Class for parsing AVC decoder configuration. /// Class for parsing AVC decoder configuration record.
class AVCDecoderConfiguration : public DecoderConfiguration { class AVCDecoderConfigurationRecord : public DecoderConfigurationRecord {
public: public:
AVCDecoderConfiguration(); AVCDecoderConfigurationRecord();
~AVCDecoderConfiguration() override; ~AVCDecoderConfigurationRecord() override;
/// @return The codec string. /// @return The codec string.
std::string GetCodecString() const; std::string GetCodecString() const;
@ -55,10 +55,10 @@ class AVCDecoderConfiguration : public DecoderConfiguration {
uint32_t pixel_width_; uint32_t pixel_width_;
uint32_t pixel_height_; uint32_t pixel_height_;
DISALLOW_COPY_AND_ASSIGN(AVCDecoderConfiguration); DISALLOW_COPY_AND_ASSIGN(AVCDecoderConfigurationRecord);
}; };
} // namespace media } // namespace media
} // namespace shaka } // namespace shaka
#endif // MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_H_ #endif // MEDIA_FILTERS_AVC_DECODER_CONFIGURATION_RECORD_H_

18
packager/media/filters/avc_decoder_configuration_unittest.cc → packager/media/filters/avc_decoder_configuration_record_unittest.cc
View File

@ -4,21 +4,21 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include <gtest/gtest.h> #include <gtest/gtest.h>
namespace shaka { namespace shaka {
namespace media { namespace media {
TEST(AVCDecoderConfigurationTest, Success) { TEST(AVCDecoderConfigurationRecordTest, Success) {
const uint8_t kAvcDecoderConfigurationData[] = { const uint8_t kAvcDecoderConfigurationData[] = {
0x01, 0x64, 0x00, 0x1E, 0xFF, 0xE1, 0x00, 0x1D, 0x67, 0x64, 0x00, 0x1E, 0x01, 0x64, 0x00, 0x1E, 0xFF, 0xE1, 0x00, 0x1D, 0x67, 0x64, 0x00, 0x1E,
0xAC, 0xD9, 0x40, 0xB4, 0x2F, 0xF9, 0x7F, 0xF0, 0x00, 0x80, 0x00, 0x91, 0xAC, 0xD9, 0x40, 0xB4, 0x2F, 0xF9, 0x7F, 0xF0, 0x00, 0x80, 0x00, 0x91,
0x00, 0x00, 0x03, 0x03, 0xE9, 0x00, 0x00, 0xEA, 0x60, 0x0F, 0x16, 0x2D, 0x00, 0x00, 0x03, 0x03, 0xE9, 0x00, 0x00, 0xEA, 0x60, 0x0F, 0x16, 0x2D,
0x96, 0x01, 0x00, 0x06, 0x68, 0xEB, 0xE3, 0xCB, 0x22, 0xC0}; 0x96, 0x01, 0x00, 0x06, 0x68, 0xEB, 0xE3, 0xCB, 0x22, 0xC0};
AVCDecoderConfiguration avc_config; AVCDecoderConfigurationRecord avc_config;
ASSERT_TRUE(avc_config.Parse(kAvcDecoderConfigurationData, ASSERT_TRUE(avc_config.Parse(kAvcDecoderConfigurationData,
arraysize(kAvcDecoderConfigurationData))); arraysize(kAvcDecoderConfigurationData)));
@ -35,29 +35,29 @@ TEST(AVCDecoderConfigurationTest, Success) {
EXPECT_EQ("avc1.64001e", avc_config.GetCodecString()); EXPECT_EQ("avc1.64001e", avc_config.GetCodecString());
} }
TEST(AVCDecoderConfigurationTest, FailsOnInvalidNaluLengthSize) { TEST(AVCDecoderConfigurationRecordTest, FailsOnInvalidNaluLengthSize) {
const uint8_t kAvcDecoderConfigurationData[] = { const uint8_t kAvcDecoderConfigurationData[] = {
0x01, 0x64, 0x00, 0x1E, 0xFE, 0xE1, 0x00, 0x1D, 0x67, 0x64, 0x00, 0x1E, 0x01, 0x64, 0x00, 0x1E, 0xFE, 0xE1, 0x00, 0x1D, 0x67, 0x64, 0x00, 0x1E,
0xAC, 0xD9, 0x40, 0xB4, 0x2F, 0xF9, 0x7F, 0xF0, 0x00, 0x80, 0x00, 0x91, 0xAC, 0xD9, 0x40, 0xB4, 0x2F, 0xF9, 0x7F, 0xF0, 0x00, 0x80, 0x00, 0x91,
0x00, 0x00, 0x03, 0x03, 0xE9, 0x00, 0x00, 0xEA, 0x60, 0x0F, 0x16, 0x2D, 0x00, 0x00, 0x03, 0x03, 0xE9, 0x00, 0x00, 0xEA, 0x60, 0x0F, 0x16, 0x2D,
0x96, 0x01, 0x00, 0x06, 0x68, 0xEB, 0xE3, 0xCB, 0x22, 0xC0}; 0x96, 0x01, 0x00, 0x06, 0x68, 0xEB, 0xE3, 0xCB, 0x22, 0xC0};
AVCDecoderConfiguration avc_config; AVCDecoderConfigurationRecord avc_config;
ASSERT_FALSE(avc_config.Parse(kAvcDecoderConfigurationData, ASSERT_FALSE(avc_config.Parse(kAvcDecoderConfigurationData,
arraysize(kAvcDecoderConfigurationData))); arraysize(kAvcDecoderConfigurationData)));
} }
TEST(AVCDecoderConfigurationTest, FailOnInsufficientData) { TEST(AVCDecoderConfigurationRecordTest, FailOnInsufficientData) {
const uint8_t kAvcDecoderConfigurationData[] = {0x01, 0x64, 0x00, 0x1E}; const uint8_t kAvcDecoderConfigurationData[] = {0x01, 0x64, 0x00, 0x1E};
AVCDecoderConfiguration avc_config; AVCDecoderConfigurationRecord avc_config;
ASSERT_FALSE(avc_config.Parse(kAvcDecoderConfigurationData, ASSERT_FALSE(avc_config.Parse(kAvcDecoderConfigurationData,
arraysize(kAvcDecoderConfigurationData))); arraysize(kAvcDecoderConfigurationData)));
} }
TEST(AVCDecoderConfigurationTest, GetCodecString) { TEST(AVCDecoderConfigurationRecordTest, GetCodecString) {
EXPECT_EQ("avc1.123456", EXPECT_EQ("avc1.123456",
AVCDecoderConfiguration::GetCodecString(0x12, 0x34, 0x56)); AVCDecoderConfigurationRecord::GetCodecString(0x12, 0x34, 0x56));
} }
} // namespace media } // namespace media

11
packager/media/filters/decoder_configuration.cc → packager/media/filters/decoder_configuration_record.cc
View File

@ -4,21 +4,22 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/decoder_configuration.h" #include "packager/media/filters/decoder_configuration_record.h"
namespace shaka { namespace shaka {
namespace media { namespace media {
DecoderConfiguration::DecoderConfiguration() : nalu_length_size_(0) {} DecoderConfigurationRecord::DecoderConfigurationRecord()
DecoderConfiguration::~DecoderConfiguration() {} : nalu_length_size_(0) {}
DecoderConfigurationRecord::~DecoderConfigurationRecord() {}
bool DecoderConfiguration::Parse(const uint8_t* data, size_t data_size) { bool DecoderConfigurationRecord::Parse(const uint8_t* data, size_t data_size) {
data_.assign(data, data + data_size); data_.assign(data, data + data_size);
nalu_.clear(); nalu_.clear();
return ParseInternal(); return ParseInternal();
} }
void DecoderConfiguration::AddNalu(const Nalu& nalu) { void DecoderConfigurationRecord::AddNalu(const Nalu& nalu) {
nalu_.push_back(nalu); nalu_.push_back(nalu);
} }

20
packager/media/filters/decoder_configuration.h → packager/media/filters/decoder_configuration_record.h
View File

@ -4,8 +4,8 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#ifndef MEDIA_FILTERS_DECODER_CONFIGURATION_H_ #ifndef MEDIA_FILTERS_DECODER_CONFIGURATION_RECORD_H_
#define MEDIA_FILTERS_DECODER_CONFIGURATION_H_ #define MEDIA_FILTERS_DECODER_CONFIGURATION_RECORD_H_
#include <vector> #include <vector>
@ -16,19 +16,19 @@
namespace shaka { namespace shaka {
namespace media { namespace media {
// Defines a base class for decoder configurations. // Defines a base class for decoder configuration record.
class DecoderConfiguration { class DecoderConfigurationRecord {
public: public:
virtual ~DecoderConfiguration(); virtual ~DecoderConfigurationRecord();
/// Parses input to extract decoder configuration data. This will make and /// Parses input to extract decoder configuration record. This will make and
/// store a copy of the data for Nalu access. /// store a copy of the data for Nalu access.
/// @return false if there are parsing errors. /// @return false if there are parsing errors.
bool Parse(const std::vector<uint8_t>& data) { bool Parse(const std::vector<uint8_t>& data) {
return Parse(data.data(), data.size()); return Parse(data.data(), data.size());
} }
/// Parses input to extract decoder configuration data. This will make and /// Parses input to extract decoder configuration record. This will make and
/// store a copy of the data for Nalu access. /// store a copy of the data for Nalu access.
/// @return false if there are parsing errors. /// @return false if there are parsing errors.
bool Parse(const uint8_t* data, size_t data_size); bool Parse(const uint8_t* data, size_t data_size);
@ -44,7 +44,7 @@ class DecoderConfiguration {
const Nalu& nalu(size_t i) const { return nalu_[i]; } const Nalu& nalu(size_t i) const { return nalu_[i]; }
protected: protected:
DecoderConfiguration(); DecoderConfigurationRecord();
/// Adds the given Nalu to the configuration. /// Adds the given Nalu to the configuration.
void AddNalu(const Nalu& nalu); void AddNalu(const Nalu& nalu);
@ -71,10 +71,10 @@ class DecoderConfiguration {
std::vector<Nalu> nalu_; std::vector<Nalu> nalu_;
uint8_t nalu_length_size_; uint8_t nalu_length_size_;
DISALLOW_COPY_AND_ASSIGN(DecoderConfiguration); DISALLOW_COPY_AND_ASSIGN(DecoderConfigurationRecord);
}; };
} // namespace media } // namespace media
} // namespace shaka } // namespace shaka
#endif // MEDIA_FILTERS_DECODER_CONFIGURATION_H_ #endif // MEDIA_FILTERS_DECODER_CONFIGURATION_RECORD_H_

22
packager/media/filters/filters.gyp
View File

@ -13,10 +13,10 @@
'target_name': 'filters', 'target_name': 'filters',
'type': '<(component)', 'type': '<(component)',
'sources': [ 'sources': [
'avc_decoder_configuration.cc', 'avc_decoder_configuration_record.cc',
'avc_decoder_configuration.h', 'avc_decoder_configuration_record.h',
'decoder_configuration.cc', 'decoder_configuration_record.cc',
'decoder_configuration.h', 'decoder_configuration_record.h',
'ec3_audio_util.cc', 'ec3_audio_util.cc',
'ec3_audio_util.h', 'ec3_audio_util.h',
'h264_byte_to_unit_stream_converter.cc', 'h264_byte_to_unit_stream_converter.cc',
@ -31,14 +31,14 @@
'h26x_bit_reader.h', 'h26x_bit_reader.h',
'h26x_byte_to_unit_stream_converter.cc', 'h26x_byte_to_unit_stream_converter.cc',
'h26x_byte_to_unit_stream_converter.h', 'h26x_byte_to_unit_stream_converter.h',
'hevc_decoder_configuration.cc', 'hevc_decoder_configuration_record.cc',
'hevc_decoder_configuration.h', 'hevc_decoder_configuration_record.h',
'nal_unit_to_byte_stream_converter.cc', 'nal_unit_to_byte_stream_converter.cc',
'nal_unit_to_byte_stream_converter.h', 'nal_unit_to_byte_stream_converter.h',
'nalu_reader.cc', 'nalu_reader.cc',
'nalu_reader.h', 'nalu_reader.h',
'vp_codec_configuration.cc', 'vp_codec_configuration_record.cc',
'vp_codec_configuration.h', 'vp_codec_configuration_record.h',
'vp8_parser.cc', 'vp8_parser.cc',
'vp8_parser.h', 'vp8_parser.h',
'vp9_parser.cc', 'vp9_parser.cc',
@ -53,17 +53,17 @@
'target_name': 'filters_unittest', 'target_name': 'filters_unittest',
'type': '<(gtest_target_type)', 'type': '<(gtest_target_type)',
'sources': [ 'sources': [
'avc_decoder_configuration_unittest.cc', 'avc_decoder_configuration_record_unittest.cc',
'ec3_audio_util_unittest.cc', 'ec3_audio_util_unittest.cc',
'h264_byte_to_unit_stream_converter_unittest.cc', 'h264_byte_to_unit_stream_converter_unittest.cc',
'h264_parser_unittest.cc', 'h264_parser_unittest.cc',
'h265_byte_to_unit_stream_converter_unittest.cc', 'h265_byte_to_unit_stream_converter_unittest.cc',
'h265_parser_unittest.cc', 'h265_parser_unittest.cc',
'h26x_bit_reader_unittest.cc', 'h26x_bit_reader_unittest.cc',
'hevc_decoder_configuration_unittest.cc', 'hevc_decoder_configuration_record_unittest.cc',
'nal_unit_to_byte_stream_converter_unittest.cc', 'nal_unit_to_byte_stream_converter_unittest.cc',
'nalu_reader_unittest.cc', 'nalu_reader_unittest.cc',
'vp_codec_configuration_unittest.cc', 'vp_codec_configuration_record_unittest.cc',
'vp8_parser_unittest.cc', 'vp8_parser_unittest.cc',
'vp9_parser_unittest.cc', 'vp9_parser_unittest.cc',
], ],

14
packager/media/filters/h265_byte_to_unit_stream_converter_unittest.cc
View File

@ -9,7 +9,7 @@
#include "packager/base/strings/string_number_conversions.h" #include "packager/base/strings/string_number_conversions.h"
#include "packager/media/filters/h265_byte_to_unit_stream_converter.h" #include "packager/media/filters/h265_byte_to_unit_stream_converter.h"
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
#include "packager/media/test/test_data_util.h" #include "packager/media/test/test_data_util.h"
namespace { namespace {
@ -47,13 +47,13 @@ TEST(H265ByteToUnitStreamConverter, ConversionSuccess) {
EXPECT_EQ(expected_decoder_config, decoder_config); EXPECT_EQ(expected_decoder_config, decoder_config);
// Double-check that it can be parsed. // Double-check that it can be parsed.
HEVCDecoderConfiguration conf; HEVCDecoderConfigurationRecord config;
ASSERT_TRUE(conf.Parse(decoder_config)); ASSERT_TRUE(config.Parse(decoder_config));
// The order is SPS, PPS, VPS. // The order is SPS, PPS, VPS.
ASSERT_EQ(3u, conf.nalu_count()); ASSERT_EQ(3u, config.nalu_count());
EXPECT_EQ(Nalu::H265_SPS, conf.nalu(0).type()); EXPECT_EQ(Nalu::H265_SPS, config.nalu(0).type());
EXPECT_EQ(Nalu::H265_PPS, conf.nalu(1).type()); EXPECT_EQ(Nalu::H265_PPS, config.nalu(1).type());
EXPECT_EQ(Nalu::H265_VPS, conf.nalu(2).type()); EXPECT_EQ(Nalu::H265_VPS, config.nalu(2).type());
} }
TEST(H265ByteToUnitStreamConverter, ConversionFailure) { TEST(H265ByteToUnitStreamConverter, ConversionFailure) {

11
packager/media/filters/hevc_decoder_configuration.cc → packager/media/filters/hevc_decoder_configuration_record.cc
View File

@ -4,7 +4,7 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
#include "packager/base/strings/string_number_conversions.h" #include "packager/base/strings/string_number_conversions.h"
#include "packager/base/strings/string_util.h" #include "packager/base/strings/string_util.h"
@ -73,7 +73,7 @@ std::string CodecAsString(VideoCodec codec) {
} // namespace } // namespace
HEVCDecoderConfiguration::HEVCDecoderConfiguration() HEVCDecoderConfigurationRecord::HEVCDecoderConfigurationRecord()
: version_(0), : version_(0),
general_profile_space_(0), general_profile_space_(0),
general_tier_flag_(false), general_tier_flag_(false),
@ -81,9 +81,9 @@ HEVCDecoderConfiguration::HEVCDecoderConfiguration()
general_profile_compatibility_flags_(0), general_profile_compatibility_flags_(0),
general_level_idc_(0) {} general_level_idc_(0) {}
HEVCDecoderConfiguration::~HEVCDecoderConfiguration() {} HEVCDecoderConfigurationRecord::~HEVCDecoderConfigurationRecord() {}
bool HEVCDecoderConfiguration::ParseInternal() { bool HEVCDecoderConfigurationRecord::ParseInternal() {
BufferReader reader(data(), data_size()); BufferReader reader(data(), data_size());
uint8_t profile_indication = 0; uint8_t profile_indication = 0;
@ -132,7 +132,8 @@ bool HEVCDecoderConfiguration::ParseInternal() {
return true; return true;
} }
std::string HEVCDecoderConfiguration::GetCodecString(VideoCodec codec) const { std::string HEVCDecoderConfigurationRecord::GetCodecString(
VideoCodec codec) const {
// ISO/IEC 14496-15:2014 Annex E. // ISO/IEC 14496-15:2014 Annex E.
std::vector<std::string> fields; std::vector<std::string> fields;
fields.push_back(CodecAsString(codec)); fields.push_back(CodecAsString(codec));

18
packager/media/filters/hevc_decoder_configuration.h → packager/media/filters/hevc_decoder_configuration_record.h
View File

@ -4,8 +4,8 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#ifndef MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_H_ #ifndef MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_RECORD_H_
#define MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_H_ #define MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_RECORD_H_
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
@ -13,16 +13,16 @@
#include "packager/base/macros.h" #include "packager/base/macros.h"
#include "packager/media/base/video_stream_info.h" #include "packager/media/base/video_stream_info.h"
#include "packager/media/filters/decoder_configuration.h" #include "packager/media/filters/decoder_configuration_record.h"
namespace shaka { namespace shaka {
namespace media { namespace media {
/// Class for parsing HEVC decoder configuration. /// Class for parsing HEVC decoder configuration record.
class HEVCDecoderConfiguration : public DecoderConfiguration { class HEVCDecoderConfigurationRecord : public DecoderConfigurationRecord {
public: public:
HEVCDecoderConfiguration(); HEVCDecoderConfigurationRecord();
~HEVCDecoderConfiguration() override; ~HEVCDecoderConfigurationRecord() override;
/// @return The codec string. /// @return The codec string.
std::string GetCodecString(VideoCodec codec) const; std::string GetCodecString(VideoCodec codec) const;
@ -38,10 +38,10 @@ class HEVCDecoderConfiguration : public DecoderConfiguration {
std::vector<uint8_t> general_constraint_indicator_flags_; std::vector<uint8_t> general_constraint_indicator_flags_;
uint8_t general_level_idc_; uint8_t general_level_idc_;
DISALLOW_COPY_AND_ASSIGN(HEVCDecoderConfiguration); DISALLOW_COPY_AND_ASSIGN(HEVCDecoderConfigurationRecord);
}; };
} // namespace media } // namespace media
} // namespace shaka } // namespace shaka
#endif // MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_H_ #endif // MEDIA_FILTERS_HEVC_DECODER_CONFIGURATION_RECORD_H_

10
packager/media/filters/hevc_decoder_configuration_unittest.cc → packager/media/filters/hevc_decoder_configuration_record_unittest.cc
View File

@ -4,14 +4,14 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
#include <gtest/gtest.h> #include <gtest/gtest.h>
namespace shaka { namespace shaka {
namespace media { namespace media {
TEST(HEVCDecoderConfigurationTest, Success) { TEST(HEVCDecoderConfigurationRecordTest, Success) {
const uint8_t kHevcDecoderConfigurationData[] = { const uint8_t kHevcDecoderConfigurationData[] = {
0x01, // Version 0x01, // Version
0x02, // profile_indication 0x02, // profile_indication
@ -39,7 +39,7 @@ TEST(HEVCDecoderConfigurationTest, Success) {
0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
}; };
HEVCDecoderConfiguration hevc_config; HEVCDecoderConfigurationRecord hevc_config;
ASSERT_TRUE(hevc_config.Parse(kHevcDecoderConfigurationData, ASSERT_TRUE(hevc_config.Parse(kHevcDecoderConfigurationData,
arraysize(kHevcDecoderConfigurationData))); arraysize(kHevcDecoderConfigurationData)));
@ -53,10 +53,10 @@ TEST(HEVCDecoderConfigurationTest, Success) {
EXPECT_EQ(0x40, hevc_config.nalu(0).data()[0]); EXPECT_EQ(0x40, hevc_config.nalu(0).data()[0]);
} }
TEST(HEVCDecoderConfigurationTest, FailOnInsufficientData) { TEST(HEVCDecoderConfigurationRecordTest, FailOnInsufficientData) {
const uint8_t kHevcDecoderConfigurationData[] = {0x01, 0x02, 0x20, 0x00}; const uint8_t kHevcDecoderConfigurationData[] = {0x01, 0x02, 0x20, 0x00};
HEVCDecoderConfiguration hevc_config; HEVCDecoderConfigurationRecord hevc_config;
ASSERT_FALSE(hevc_config.Parse(kHevcDecoderConfigurationData, ASSERT_FALSE(hevc_config.Parse(kHevcDecoderConfigurationData,
arraysize(kHevcDecoderConfigurationData))); arraysize(kHevcDecoderConfigurationData)));
} }

4
packager/media/filters/nal_unit_to_byte_stream_converter.cc
View File

@ -13,7 +13,7 @@
#include "packager/media/base/buffer_reader.h" #include "packager/media/base/buffer_reader.h"
#include "packager/media/base/buffer_writer.h" #include "packager/media/base/buffer_writer.h"
#include "packager/media/base/macros.h" #include "packager/media/base/macros.h"
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/media/filters/nalu_reader.h" #include "packager/media/filters/nalu_reader.h"
namespace shaka { namespace shaka {
@ -99,7 +99,7 @@ bool NalUnitToByteStreamConverter::Initialize(
return false; return false;
} }
AVCDecoderConfiguration decoder_config; AVCDecoderConfigurationRecord decoder_config;
if (!decoder_config.Parse(std::vector<uint8_t>( if (!decoder_config.Parse(std::vector<uint8_t>(
decoder_configuration_data, decoder_configuration_data,
decoder_configuration_data + decoder_configuration_data_size))) { decoder_configuration_data + decoder_configuration_data_size))) {

4
packager/media/filters/vp8_parser.cc
View File

@ -153,11 +153,11 @@ bool VP8Parser::Parse(const uint8_t* data,
// http://tools.ietf.org/html/rfc6386 Section 2. // http://tools.ietf.org/html/rfc6386 Section 2.
writable_codec_config()->set_bit_depth(8); writable_codec_config()->set_bit_depth(8);
writable_codec_config()->set_chroma_subsampling( writable_codec_config()->set_chroma_subsampling(
VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA); VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA);
// VP8 uses YCrCb color space defined in ITU-R_BT.601. // VP8 uses YCrCb color space defined in ITU-R_BT.601.
// http://tools.ietf.org/html/rfc6386 Section 9.2. // http://tools.ietf.org/html/rfc6386 Section 9.2.
writable_codec_config()->set_color_space( writable_codec_config()->set_color_space(
VPCodecConfiguration::COLOR_SPACE_BT_601); VPCodecConfigurationRecord::COLOR_SPACE_BT_601);
VPxFrameInfo vpx_frame; VPxFrameInfo vpx_frame;
vpx_frame.frame_size = data_size; vpx_frame.frame_size = data_size;

47
packager/media/filters/vp9_parser.cc
View File

@ -140,7 +140,7 @@ bool ParseIfSuperframeIndex(const uint8_t* data,
return true; return true;
} }
bool ReadProfile(BitReader* reader, VPCodecConfiguration* codec_config) { bool ReadProfile(BitReader* reader, VPCodecConfigurationRecord* codec_config) {
uint8_t bit[2]; uint8_t bit[2];
RCHECK(reader->ReadBits(1, &bit[0])); RCHECK(reader->ReadBits(1, &bit[0]));
RCHECK(reader->ReadBits(1, &bit[1])); RCHECK(reader->ReadBits(1, &bit[1]));
@ -160,54 +160,55 @@ bool ReadSyncCode(BitReader* reader) {
return sync_code == VP9_SYNC_CODE; return sync_code == VP9_SYNC_CODE;
} }
VPCodecConfiguration::ColorSpace GetColorSpace(uint8_t color_space) { VPCodecConfigurationRecord::ColorSpace GetColorSpace(uint8_t color_space) {
switch (color_space) { switch (color_space) {
case VPX_COLOR_SPACE_UNKNOWN: case VPX_COLOR_SPACE_UNKNOWN:
return VPCodecConfiguration::COLOR_SPACE_UNSPECIFIED; return VPCodecConfigurationRecord::COLOR_SPACE_UNSPECIFIED;
case VPX_COLOR_SPACE_BT_601: case VPX_COLOR_SPACE_BT_601:
return VPCodecConfiguration::COLOR_SPACE_BT_601; return VPCodecConfigurationRecord::COLOR_SPACE_BT_601;
case VPX_COLOR_SPACE_BT_709: case VPX_COLOR_SPACE_BT_709:
return VPCodecConfiguration::COLOR_SPACE_BT_709; return VPCodecConfigurationRecord::COLOR_SPACE_BT_709;
case VPX_COLOR_SPACE_SMPTE_170: case VPX_COLOR_SPACE_SMPTE_170:
return VPCodecConfiguration::COLOR_SPACE_SMPTE_170; return VPCodecConfigurationRecord::COLOR_SPACE_SMPTE_170;
case VPX_COLOR_SPACE_SMPTE_240: case VPX_COLOR_SPACE_SMPTE_240:
return VPCodecConfiguration::COLOR_SPACE_SMPTE_240; return VPCodecConfigurationRecord::COLOR_SPACE_SMPTE_240;
case VPX_COLOR_SPACE_BT_2020: case VPX_COLOR_SPACE_BT_2020:
// VP9 does not specify if it is in the form of “constant luminance” or // VP9 does not specify if it is in the form of “constant luminance” or
// “non-constant luminance”. As such, application should rely on the // “non-constant luminance”. As such, application should rely on the
// signaling outside of VP9 bitstream. If there is no such signaling, // signaling outside of VP9 bitstream. If there is no such signaling,
// application may assume non-constant luminance for BT.2020. // application may assume non-constant luminance for BT.2020.
return VPCodecConfiguration::COLOR_SPACE_BT_2020_NON_CONSTANT_LUMINANCE; return VPCodecConfigurationRecord::
COLOR_SPACE_BT_2020_NON_CONSTANT_LUMINANCE;
case VPX_COLOR_SPACE_SRGB: case VPX_COLOR_SPACE_SRGB:
return VPCodecConfiguration::COLOR_SPACE_SRGB; return VPCodecConfigurationRecord::COLOR_SPACE_SRGB;
default: default:
LOG(WARNING) << "Unknown color space: " << static_cast<int>(color_space); LOG(WARNING) << "Unknown color space: " << static_cast<int>(color_space);
return VPCodecConfiguration::COLOR_SPACE_UNSPECIFIED; return VPCodecConfigurationRecord::COLOR_SPACE_UNSPECIFIED;
} }
} }
VPCodecConfiguration::ChromaSubsampling GetChromaSubsampling( VPCodecConfigurationRecord::ChromaSubsampling GetChromaSubsampling(
uint8_t subsampling) { uint8_t subsampling) {
switch (subsampling) { switch (subsampling) {
case 0: case 0:
return VPCodecConfiguration::CHROMA_444; return VPCodecConfigurationRecord::CHROMA_444;
case 1: case 1:
return VPCodecConfiguration::CHROMA_440; return VPCodecConfigurationRecord::CHROMA_440;
case 2: case 2:
return VPCodecConfiguration::CHROMA_422; return VPCodecConfigurationRecord::CHROMA_422;
case 3: case 3:
// VP9 assumes that chrome samples are collocated with luma samples if // VP9 assumes that chrome samples are collocated with luma samples if
// there is no explicit signaling outside of VP9 bitstream. // there is no explicit signaling outside of VP9 bitstream.
return VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA; return VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA;
default: default:
LOG(WARNING) << "Unexpected chroma subsampling value: " LOG(WARNING) << "Unexpected chroma subsampling value: "
<< static_cast<int>(subsampling); << static_cast<int>(subsampling);
return VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA; return VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA;
} }
} }
bool ReadBitDepthAndColorSpace(BitReader* reader, bool ReadBitDepthAndColorSpace(BitReader* reader,
VPCodecConfiguration* codec_config) { VPCodecConfigurationRecord* codec_config) {
uint8_t bit_depth = 8; uint8_t bit_depth = 8;
if (codec_config->profile() >= 2) { if (codec_config->profile() >= 2) {
bool use_vpx_bits_12; bool use_vpx_bits_12;
@ -221,7 +222,7 @@ bool ReadBitDepthAndColorSpace(BitReader* reader,
codec_config->set_color_space(GetColorSpace(color_space)); codec_config->set_color_space(GetColorSpace(color_space));
bool yuv_full_range = false; bool yuv_full_range = false;
auto chroma_subsampling = VPCodecConfiguration::CHROMA_444; auto chroma_subsampling = VPCodecConfigurationRecord::CHROMA_444;
if (color_space != VPX_COLOR_SPACE_SRGB) { if (color_space != VPX_COLOR_SPACE_SRGB) {
RCHECK(reader->ReadBits(1, &yuv_full_range)); RCHECK(reader->ReadBits(1, &yuv_full_range));
@ -230,7 +231,7 @@ bool ReadBitDepthAndColorSpace(BitReader* reader,
RCHECK(reader->ReadBits(2, &subsampling)); RCHECK(reader->ReadBits(2, &subsampling));
chroma_subsampling = GetChromaSubsampling(subsampling); chroma_subsampling = GetChromaSubsampling(subsampling);
if (chroma_subsampling == if (chroma_subsampling ==
VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA) { VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA) {
LOG(ERROR) << "4:2:0 color not supported in profile " LOG(ERROR) << "4:2:0 color not supported in profile "
<< codec_config->profile(); << codec_config->profile();
return false; return false;
@ -241,11 +242,11 @@ bool ReadBitDepthAndColorSpace(BitReader* reader,
RCHECK(!reserved); RCHECK(!reserved);
} else { } else {
chroma_subsampling = chroma_subsampling =
VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA; VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA;
} }
} else { } else {
// Assume 4:4:4 for colorspace SRGB. // Assume 4:4:4 for colorspace SRGB.
chroma_subsampling = VPCodecConfiguration::CHROMA_444; chroma_subsampling = VPCodecConfigurationRecord::CHROMA_444;
if (codec_config->profile() & 1) { if (codec_config->profile() & 1) {
bool reserved; bool reserved;
RCHECK(reader->ReadBits(1, &reserved)); RCHECK(reader->ReadBits(1, &reserved));
@ -474,7 +475,7 @@ bool VP9Parser::Parse(const uint8_t* data,
// profile 0. VP9 specifies that the default color format should be // profile 0. VP9 specifies that the default color format should be
// YUV 4:2:0 in this case (normative). // YUV 4:2:0 in this case (normative).
writable_codec_config()->set_chroma_subsampling( writable_codec_config()->set_chroma_subsampling(
VPCodecConfiguration::CHROMA_420_COLLOCATED_WITH_LUMA); VPCodecConfigurationRecord::CHROMA_420_COLLOCATED_WITH_LUMA);
writable_codec_config()->set_bit_depth(8); writable_codec_config()->set_bit_depth(8);
} }
@ -537,7 +538,7 @@ bool VP9Parser::IsKeyframe(const uint8_t* data, size_t data_size) {
RCHECK(reader.ReadBits(2, &frame_marker)); RCHECK(reader.ReadBits(2, &frame_marker));
RCHECK(frame_marker == VP9_FRAME_MARKER); RCHECK(frame_marker == VP9_FRAME_MARKER);
VPCodecConfiguration codec_config; VPCodecConfigurationRecord codec_config;
RCHECK(ReadProfile(&reader, &codec_config)); RCHECK(ReadProfile(&reader, &codec_config));
bool show_existing_frame; bool show_existing_frame;

14
packager/media/filters/vp_codec_configuration.cc → packager/media/filters/vp_codec_configuration_record.cc
View File

@ -4,7 +4,7 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/vp_codec_configuration.h" #include "packager/media/filters/vp_codec_configuration_record.h"
#include "packager/base/strings/string_number_conversions.h" #include "packager/base/strings/string_number_conversions.h"
#include "packager/base/strings/string_util.h" #include "packager/base/strings/string_util.h"
@ -33,7 +33,7 @@ std::string VPCodecAsString(VideoCodec codec) {
} // namespace } // namespace
VPCodecConfiguration::VPCodecConfiguration() VPCodecConfigurationRecord::VPCodecConfigurationRecord()
: profile_(0), : profile_(0),
level_(0), level_(0),
bit_depth_(0), bit_depth_(0),
@ -42,7 +42,7 @@ VPCodecConfiguration::VPCodecConfiguration()
transfer_function_(0), transfer_function_(0),
video_full_range_flag_(false) {} video_full_range_flag_(false) {}
VPCodecConfiguration::VPCodecConfiguration( VPCodecConfigurationRecord::VPCodecConfigurationRecord(
uint8_t profile, uint8_t profile,
uint8_t level, uint8_t level,
uint8_t bit_depth, uint8_t bit_depth,
@ -60,9 +60,9 @@ VPCodecConfiguration::VPCodecConfiguration(
video_full_range_flag_(video_full_range_flag), video_full_range_flag_(video_full_range_flag),
codec_initialization_data_(codec_initialization_data) {} codec_initialization_data_(codec_initialization_data) {}
VPCodecConfiguration::~VPCodecConfiguration(){}; VPCodecConfigurationRecord::~VPCodecConfigurationRecord(){};
bool VPCodecConfiguration::Parse(const std::vector<uint8_t>& data) { bool VPCodecConfigurationRecord::Parse(const std::vector<uint8_t>& data) {
BitReader reader(data.data(), data.size()); BitReader reader(data.data(), data.size());
RCHECK(reader.ReadBits(8, &profile_)); RCHECK(reader.ReadBits(8, &profile_));
RCHECK(reader.ReadBits(8, &level_)); RCHECK(reader.ReadBits(8, &level_));
@ -81,7 +81,7 @@ bool VPCodecConfiguration::Parse(const std::vector<uint8_t>& data) {
return true; return true;
} }
void VPCodecConfiguration::Write(std::vector<uint8_t>* data) const { void VPCodecConfigurationRecord::Write(std::vector<uint8_t>* data) const {
BufferWriter writer; BufferWriter writer;
writer.AppendInt(profile_); writer.AppendInt(profile_);
writer.AppendInt(level_); writer.AppendInt(level_);
@ -96,7 +96,7 @@ void VPCodecConfiguration::Write(std::vector<uint8_t>* data) const {
writer.SwapBuffer(data); writer.SwapBuffer(data);
} }
std::string VPCodecConfiguration::GetCodecString(VideoCodec codec) const { std::string VPCodecConfigurationRecord::GetCodecString(VideoCodec codec) const {
const std::string fields[] = { const std::string fields[] = {
base::IntToString(profile_), base::IntToString(profile_),
base::IntToString(level_), base::IntToString(level_),

35
packager/media/filters/vp_codec_configuration.h → packager/media/filters/vp_codec_configuration_record.h
View File

@ -4,8 +4,8 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#ifndef MEDIA_FILTERS_VP_CODEC_CONFIGURATION_H_ #ifndef MEDIA_FILTERS_VP_CODEC_CONFIGURATION_RECORD_H_
#define MEDIA_FILTERS_VP_CODEC_CONFIGURATION_H_ #define MEDIA_FILTERS_VP_CODEC_CONFIGURATION_RECORD_H_
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>
@ -17,8 +17,8 @@
namespace shaka { namespace shaka {
namespace media { namespace media {
/// Class for parsing or writing VP codec configuration data. /// Class for parsing or writing VP codec configuration record.
class VPCodecConfiguration { class VPCodecConfigurationRecord {
public: public:
enum ColorSpace { enum ColorSpace {
COLOR_SPACE_UNSPECIFIED = 0, COLOR_SPACE_UNSPECIFIED = 0,
@ -39,23 +39,24 @@ class VPCodecConfiguration {
CHROMA_440 = 4, CHROMA_440 = 4,
}; };
VPCodecConfiguration(); VPCodecConfigurationRecord();
VPCodecConfiguration(uint8_t profile, VPCodecConfigurationRecord(
uint8_t level, uint8_t profile,
uint8_t bit_depth, uint8_t level,
uint8_t color_space, uint8_t bit_depth,
uint8_t chroma_subsampling, uint8_t color_space,
uint8_t transfer_function, uint8_t chroma_subsampling,
bool video_full_range_flag, uint8_t transfer_function,
const std::vector<uint8_t>& codec_initialization_data); bool video_full_range_flag,
~VPCodecConfiguration(); const std::vector<uint8_t>& codec_initialization_data);
~VPCodecConfigurationRecord();
/// Parses input to extract VP codec configuration data. /// Parses input to extract VP codec configuration record.
/// @return false if there is parsing errors. /// @return false if there is parsing errors.
bool Parse(const std::vector<uint8_t>& data); bool Parse(const std::vector<uint8_t>& data);
/// @param data should not be null. /// @param data should not be null.
/// Writes VP codec configuration data to buffer. /// Writes VP codec configuration record to buffer.
void Write(std::vector<uint8_t>* data) const; void Write(std::vector<uint8_t>* data) const;
/// @return The codec string. /// @return The codec string.
@ -101,4 +102,4 @@ class VPCodecConfiguration {
} // namespace media } // namespace media
} // namespace shaka } // namespace shaka
#endif // MEDIA_FILTERS_VP_CODEC_CONFIGURATION_H_ #endif // MEDIA_FILTERS_VP_CODEC_CONFIGURATION_RECORD_H_

16
packager/media/filters/vp_codec_configuration_unittest.cc → packager/media/filters/vp_codec_configuration_record_unittest.cc
View File

@ -4,19 +4,19 @@
// license that can be found in the LICENSE file or at // license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd // https://developers.google.com/open-source/licenses/bsd
#include "packager/media/filters/vp_codec_configuration.h" #include "packager/media/filters/vp_codec_configuration_record.h"
#include <gtest/gtest.h> #include <gtest/gtest.h>
namespace shaka { namespace shaka {
namespace media { namespace media {
TEST(VPCodecConfigurationTest, Parse) { TEST(VPCodecConfigurationRecordTest, Parse) {
const uint8_t kVpCodecConfigurationData[] = { const uint8_t kVpCodecConfigurationData[] = {
0x01, 0x00, 0xA2, 0x14, 0x00, 0x01, 0x00, 0x01, 0x00, 0xA2, 0x14, 0x00, 0x01, 0x00,
}; };
VPCodecConfiguration vp_config; VPCodecConfigurationRecord vp_config;
ASSERT_TRUE(vp_config.Parse(std::vector<uint8_t>( ASSERT_TRUE(vp_config.Parse(std::vector<uint8_t>(
kVpCodecConfigurationData, kVpCodecConfigurationData,
kVpCodecConfigurationData + arraysize(kVpCodecConfigurationData)))); kVpCodecConfigurationData + arraysize(kVpCodecConfigurationData))));
@ -32,23 +32,23 @@ TEST(VPCodecConfigurationTest, Parse) {
EXPECT_EQ("vp09.01.00.10.02.01.02.00", vp_config.GetCodecString(kCodecVP9)); EXPECT_EQ("vp09.01.00.10.02.01.02.00", vp_config.GetCodecString(kCodecVP9));
} }
TEST(VPCodecConfigurationTest, ParseWithInsufficientData) { TEST(VPCodecConfigurationRecordTest, ParseWithInsufficientData) {
const uint8_t kVpCodecConfigurationData[] = { const uint8_t kVpCodecConfigurationData[] = {
0x01, 0x00, 0xA2, 0x14, 0x01, 0x00, 0xA2, 0x14,
}; };
VPCodecConfiguration vp_config; VPCodecConfigurationRecord vp_config;
ASSERT_FALSE(vp_config.Parse(std::vector<uint8_t>( ASSERT_FALSE(vp_config.Parse(std::vector<uint8_t>(
kVpCodecConfigurationData, kVpCodecConfigurationData,
kVpCodecConfigurationData + arraysize(kVpCodecConfigurationData)))); kVpCodecConfigurationData + arraysize(kVpCodecConfigurationData))));
} }
TEST(VPCodecConfigurationTest, Write) { TEST(VPCodecConfigurationRecordTest, Write) {
const uint8_t kExpectedVpCodecConfigurationData[] = { const uint8_t kExpectedVpCodecConfigurationData[] = {
0x02, 0x01, 0x80, 0x21, 0x00, 0x00, 0x02, 0x01, 0x80, 0x21, 0x00, 0x00,
}; };
VPCodecConfiguration vp_config(0x02, 0x01, 0x08, 0x00, 0x02, 0x00, true, VPCodecConfigurationRecord vp_config(0x02, 0x01, 0x08, 0x00, 0x02, 0x00, true,
std::vector<uint8_t>()); std::vector<uint8_t>());
std::vector<uint8_t> data; std::vector<uint8_t> data;
vp_config.Write(&data); vp_config.Write(&data);

10
packager/media/filters/vpx_parser.h
View File

@ -11,7 +11,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "packager/base/macros.h" #include "packager/base/macros.h"
#include "packager/media/filters/vp_codec_configuration.h" #include "packager/media/filters/vp_codec_configuration_record.h"
namespace shaka { namespace shaka {
namespace media { namespace media {
@ -41,13 +41,15 @@ class VPxParser {
/// @return VPx codec configuration extracted. Note that it is only valid /// @return VPx codec configuration extracted. Note that it is only valid
/// after parsing a keyframe or intra frame successfully. /// after parsing a keyframe or intra frame successfully.
const VPCodecConfiguration& codec_config() const { return codec_config_; } const VPCodecConfigurationRecord& codec_config() const {
return codec_config_;
}
protected: protected:
VPCodecConfiguration* writable_codec_config() { return &codec_config_; } VPCodecConfigurationRecord* writable_codec_config() { return &codec_config_; }
private: private:
VPCodecConfiguration codec_config_; VPCodecConfigurationRecord codec_config_;
DISALLOW_COPY_AND_ASSIGN(VPxParser); DISALLOW_COPY_AND_ASSIGN(VPxParser);
}; };

29
packager/media/formats/mp2t/es_parser_h264.cc
View File

@ -10,7 +10,7 @@
#include "packager/media/base/media_sample.h" #include "packager/media/base/media_sample.h"
#include "packager/media/base/timestamp.h" #include "packager/media/base/timestamp.h"
#include "packager/media/base/video_stream_info.h" #include "packager/media/base/video_stream_info.h"
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/media/filters/h264_byte_to_unit_stream_converter.h" #include "packager/media/filters/h264_byte_to_unit_stream_converter.h"
#include "packager/media/filters/h264_parser.h" #include "packager/media/filters/h264_parser.h"
#include "packager/media/formats/mp2t/mp2t_common.h" #include "packager/media/formats/mp2t/mp2t_common.h"
@ -143,25 +143,14 @@ bool EsParserH264::UpdateVideoDecoderConfig(int pps_id) {
return false; return false;
} }
last_video_decoder_config_ = scoped_refptr<StreamInfo>( last_video_decoder_config_ = scoped_refptr<StreamInfo>(new VideoStreamInfo(
new VideoStreamInfo( pid(), kMpeg2Timescale, kInfiniteDuration, kCodecH264,
pid(), AVCDecoderConfigurationRecord::GetCodecString(decoder_config_record[1],
kMpeg2Timescale, decoder_config_record[2],
kInfiniteDuration, decoder_config_record[3]),
kCodecH264, std::string(), coded_width, coded_height, pixel_width, pixel_height, 0,
AVCDecoderConfiguration::GetCodecString(decoder_config_record[1], H264ByteToUnitStreamConverter::kUnitStreamNaluLengthSize,
decoder_config_record[2], decoder_config_record.data(), decoder_config_record.size(), false));
decoder_config_record[3]),
std::string(),
coded_width,
coded_height,
pixel_width,
pixel_height,
0,
H264ByteToUnitStreamConverter::kUnitStreamNaluLengthSize,
decoder_config_record.data(),
decoder_config_record.size(),
false));
DVLOG(1) << "Profile IDC: " << sps->profile_idc; DVLOG(1) << "Profile IDC: " << sps->profile_idc;
DVLOG(1) << "Level IDC: " << sps->level_idc; DVLOG(1) << "Level IDC: " << sps->level_idc;
DVLOG(1) << "log2_max_frame_num_minus4: " << sps->log2_max_frame_num_minus4; DVLOG(1) << "log2_max_frame_num_minus4: " << sps->log2_max_frame_num_minus4;

4
packager/media/formats/mp2t/es_parser_h265.cc
View File

@ -13,7 +13,7 @@
#include "packager/media/base/offset_byte_queue.h" #include "packager/media/base/offset_byte_queue.h"
#include "packager/media/base/timestamp.h" #include "packager/media/base/timestamp.h"
#include "packager/media/base/video_stream_info.h" #include "packager/media/base/video_stream_info.h"
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
#include "packager/media/filters/h265_byte_to_unit_stream_converter.h" #include "packager/media/filters/h265_byte_to_unit_stream_converter.h"
#include "packager/media/filters/h265_parser.h" #include "packager/media/filters/h265_parser.h"
#include "packager/media/formats/mp2t/mp2t_common.h" #include "packager/media/formats/mp2t/mp2t_common.h"
@ -117,7 +117,7 @@ bool EsParserH265::UpdateVideoDecoderConfig(int pps_id) {
} }
std::vector<uint8_t> decoder_config_record; std::vector<uint8_t> decoder_config_record;
HEVCDecoderConfiguration decoder_config; HEVCDecoderConfigurationRecord decoder_config;
if (!stream_converter()->GetDecoderConfigurationRecord( if (!stream_converter()->GetDecoderConfigurationRecord(
&decoder_config_record) || &decoder_config_record) ||
!decoder_config.Parse(decoder_config_record)) { !decoder_config.Parse(decoder_config_record)) {

12
packager/media/formats/mp4/mp4_media_parser.cc
View File

@ -21,9 +21,9 @@
#include "packager/media/base/video_stream_info.h" #include "packager/media/base/video_stream_info.h"
#include "packager/media/file/file.h" #include "packager/media/file/file.h"
#include "packager/media/file/file_closer.h" #include "packager/media/file/file_closer.h"
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
#include "packager/media/filters/vp_codec_configuration.h" #include "packager/media/filters/vp_codec_configuration_record.h"
#include "packager/media/formats/mp4/box_definitions.h" #include "packager/media/formats/mp4/box_definitions.h"
#include "packager/media/formats/mp4/box_reader.h" #include "packager/media/formats/mp4/box_reader.h"
#include "packager/media/formats/mp4/es_descriptor.h" #include "packager/media/formats/mp4/es_descriptor.h"
@ -511,7 +511,7 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
const VideoCodec video_codec = FourCCToVideoCodec(actual_format); const VideoCodec video_codec = FourCCToVideoCodec(actual_format);
switch (actual_format) { switch (actual_format) {
case FOURCC_avc1: { case FOURCC_avc1: {
AVCDecoderConfiguration avc_config; AVCDecoderConfigurationRecord avc_config;
if (!avc_config.Parse(entry.codec_configuration.data)) { if (!avc_config.Parse(entry.codec_configuration.data)) {
LOG(ERROR) << "Failed to parse avcc."; LOG(ERROR) << "Failed to parse avcc.";
return false; return false;
@ -548,7 +548,7 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
} }
case FOURCC_hev1: case FOURCC_hev1:
case FOURCC_hvc1: { case FOURCC_hvc1: {
HEVCDecoderConfiguration hevc_config; HEVCDecoderConfigurationRecord hevc_config;
if (!hevc_config.Parse(entry.codec_configuration.data)) { if (!hevc_config.Parse(entry.codec_configuration.data)) {
LOG(ERROR) << "Failed to parse hevc."; LOG(ERROR) << "Failed to parse hevc.";
return false; return false;
@ -560,7 +560,7 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
case FOURCC_vp08: case FOURCC_vp08:
case FOURCC_vp09: case FOURCC_vp09:
case FOURCC_vp10: { case FOURCC_vp10: {
VPCodecConfiguration vp_config; VPCodecConfigurationRecord vp_config;
if (!vp_config.Parse(entry.codec_configuration.data)) { if (!vp_config.Parse(entry.codec_configuration.data)) {
LOG(ERROR) << "Failed to parse vpcc."; LOG(ERROR) << "Failed to parse vpcc.";
return false; return false;

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

@ -7,8 +7,8 @@
#include "packager/media/formats/mp4/video_slice_header_parser.h" #include "packager/media/formats/mp4/video_slice_header_parser.h"
#include "packager/media/base/rcheck.h" #include "packager/media/base/rcheck.h"
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/media/filters/hevc_decoder_configuration.h" #include "packager/media/filters/hevc_decoder_configuration_record.h"
namespace shaka { namespace shaka {
namespace media { namespace media {
@ -29,7 +29,7 @@ H264VideoSliceHeaderParser::~H264VideoSliceHeaderParser() {}
bool H264VideoSliceHeaderParser::Initialize( bool H264VideoSliceHeaderParser::Initialize(
const std::vector<uint8_t>& decoder_configuration) { const std::vector<uint8_t>& decoder_configuration) {
AVCDecoderConfiguration config; AVCDecoderConfigurationRecord config;
RCHECK(config.Parse(decoder_configuration)); RCHECK(config.Parse(decoder_configuration));
for (size_t i = 0; i < config.nalu_count(); i++) { for (size_t i = 0; i < config.nalu_count(); i++) {
@ -61,7 +61,7 @@ H265VideoSliceHeaderParser::~H265VideoSliceHeaderParser() {}
bool H265VideoSliceHeaderParser::Initialize( bool H265VideoSliceHeaderParser::Initialize(
const std::vector<uint8_t>& decoder_configuration) { const std::vector<uint8_t>& decoder_configuration) {
int id; int id;
HEVCDecoderConfiguration hevc_config; HEVCDecoderConfigurationRecord hevc_config;
RCHECK(hevc_config.Parse(decoder_configuration)); RCHECK(hevc_config.Parse(decoder_configuration));
for (size_t i = 0; i < hevc_config.nalu_count(); i++) { for (size_t i = 0; i < hevc_config.nalu_count(); i++) {

3
packager/media/formats/webm/webm_cluster_parser.cc
View File

@ -456,7 +456,8 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
return false; return false;
} }
const VPCodecConfiguration* codec_config = &vpx_parser->codec_config(); const VPCodecConfigurationRecord* codec_config =
&vpx_parser->codec_config();
video_stream_info_->set_codec_string( video_stream_info_->set_codec_string(
codec_config->GetCodecString(video_stream_info_->codec())); codec_config->GetCodecString(video_stream_info_->codec()));
std::vector<uint8_t> extra_data; std::vector<uint8_t> extra_data;

16
packager/media/formats/wvm/wvm_media_parser.cc
View File

@ -15,7 +15,7 @@
#include "packager/media/base/media_sample.h" #include "packager/media/base/media_sample.h"
#include "packager/media/base/status.h" #include "packager/media/base/status.h"
#include "packager/media/base/video_stream_info.h" #include "packager/media/base/video_stream_info.h"
#include "packager/media/filters/avc_decoder_configuration.h" #include "packager/media/filters/avc_decoder_configuration_record.h"
#include "packager/media/formats/mp2t/adts_header.h" #include "packager/media/formats/mp2t/adts_header.h"
#include "packager/media/formats/mp4/aac_audio_specific_config.h" #include "packager/media/formats/mp4/aac_audio_specific_config.h"
#include "packager/media/formats/mp4/es_descriptor.h" #include "packager/media/formats/mp4/es_descriptor.h"
@ -725,7 +725,7 @@ bool WvmMediaParser::ParseIndexEntry() {
case Audio_AC3SpecificData: case Audio_AC3SpecificData:
LOG(ERROR) << "Audio type not supported."; LOG(ERROR) << "Audio type not supported.";
return false; return false;
case AVCDecoderConfigurationRecord: case Video_AVCDecoderConfigurationRecord:
video_codec_config = binary_data; video_codec_config = binary_data;
break; break;
default: default:
@ -831,7 +831,7 @@ bool WvmMediaParser::Output(bool output_encrypted_sample) {
byte_to_unit_stream_converter_.GetDecoderConfigurationRecord( byte_to_unit_stream_converter_.GetDecoderConfigurationRecord(
&decoder_config_record); &decoder_config_record);
for (uint32_t i = 0; i < stream_infos_.size(); i++) { for (uint32_t i = 0; i < stream_infos_.size(); i++) {
if (stream_infos_[i]->stream_type() == media::kStreamVideo && if (stream_infos_[i]->stream_type() == kStreamVideo &&
stream_infos_[i]->codec_string().empty()) { stream_infos_[i]->codec_string().empty()) {
const std::vector<uint8_t>* stream_config; const std::vector<uint8_t>* stream_config;
if (stream_infos_[i]->extra_data().empty()) { if (stream_infos_[i]->extra_data().empty()) {
@ -847,7 +847,7 @@ bool WvmMediaParser::Output(bool output_encrypted_sample) {
VideoStreamInfo* video_stream_info = VideoStreamInfo* video_stream_info =
reinterpret_cast<VideoStreamInfo*>(stream_infos_[i].get()); reinterpret_cast<VideoStreamInfo*>(stream_infos_[i].get());
AVCDecoderConfiguration avc_config; AVCDecoderConfigurationRecord avc_config;
if (!avc_config.Parse(*stream_config)) { if (!avc_config.Parse(*stream_config)) {
LOG(WARNING) << "Failed to parse AVCDecoderConfigurationRecord. " LOG(WARNING) << "Failed to parse AVCDecoderConfigurationRecord. "
"Using computed configuration record instead."; "Using computed configuration record instead.";
@ -894,9 +894,9 @@ bool WvmMediaParser::Output(bool output_encrypted_sample) {
} else if ((prev_pes_stream_id_ & kPesStreamIdAudioMask) == } else if ((prev_pes_stream_id_ & kPesStreamIdAudioMask) ==
kPesStreamIdAudio) { kPesStreamIdAudio) {
// Set data on the audio stream. // Set data on the audio stream.
int frame_size = media::mp2t::AdtsHeader::GetAdtsFrameSize( int frame_size = mp2t::AdtsHeader::GetAdtsFrameSize(sample_data_.data(),
sample_data_.data(), kAdtsHeaderMinSize); kAdtsHeaderMinSize);
media::mp2t::AdtsHeader adts_header; mp2t::AdtsHeader adts_header;
const uint8_t* frame_ptr = sample_data_.data(); const uint8_t* frame_ptr = sample_data_.data();
if (!adts_header.Parse(frame_ptr, frame_size)) { if (!adts_header.Parse(frame_ptr, frame_size)) {
LOG(ERROR) << "Could not parse ADTS header"; LOG(ERROR) << "Could not parse ADTS header";
@ -908,7 +908,7 @@ bool WvmMediaParser::Output(bool output_encrypted_sample) {
frame_size - header_size); frame_size - header_size);
if (!is_initialized_) { if (!is_initialized_) {
for (uint32_t i = 0; i < stream_infos_.size(); i++) { for (uint32_t i = 0; i < stream_infos_.size(); i++) {
if (stream_infos_[i]->stream_type() == media::kStreamAudio && if (stream_infos_[i]->stream_type() == kStreamAudio &&
stream_infos_[i]->codec_string().empty()) { stream_infos_[i]->codec_string().empty()) {
AudioStreamInfo* audio_stream_info = AudioStreamInfo* audio_stream_info =
reinterpret_cast<AudioStreamInfo*>(stream_infos_[i].get()); reinterpret_cast<AudioStreamInfo*>(stream_infos_[i].get());

2
packager/media/formats/wvm/wvm_media_parser.h
View File

@ -103,7 +103,7 @@ class WvmMediaParser : public MediaParser {
SparseDownloadMap = 36, SparseDownloadMap = 36,
AudioSampleSize = 37, AudioSampleSize = 37,
Audio_EsDescriptor = 38, Audio_EsDescriptor = 38,
AVCDecoderConfigurationRecord = 39, Video_AVCDecoderConfigurationRecord = 39,
Audio_EC3SpecificData = 40, Audio_EC3SpecificData = 40,
AudioIdentifier = 41, AudioIdentifier = 41,
VideoStreamId = 42, VideoStreamId = 42,