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

Revert "Support DTS audio in MP4 - Part 1" 

This reverts commit 9b0d4abece.

Change-Id: I3897fffde2ab162638876df1eafa7a4058573e49
This commit is contained in:
Bei Li 2015-12-07 19:35:11 +00:00
parent 9b0d4abece
commit c647c25d5f
9 changed files with 53 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
packager/media/base/audio_stream_info.cc
View File

@ -43,18 +43,6 @@ std::string AudioCodecToString(AudioCodec audio_codec) {
return "Opus";
case kCodecEAC3:
return "EAC3";
case kCodecDTSC:
return "DTSC";
case kCodecDTSH:
return "DTSH";
case kCodecDTSL:
return "DTSL";
case kCodecDTSE:
return "DTSE";
case kCodecDTSP:
return "DTS+";
case kCodecDTSM:
return "DTS-";
default:
NOTIMPLEMENTED() << "Unknown Audio Codec: " << audio_codec;
return "UnknownAudioCodec";
@ -116,18 +104,6 @@ std::string AudioStreamInfo::GetCodecString(AudioCodec codec,
return "opus";
case kCodecAAC:
return "mp4a.40." + base::UintToString(audio_object_type);
case kCodecDTSC:
return "dtsc";
case kCodecDTSH:
return "dtsh";
case kCodecDTSL:
return "dtsl";
case kCodecDTSE:
return "dtse";
case kCodecDTSP:
return "dts+";
case kCodecDTSM:
return "dts-";
default:
NOTIMPLEMENTED() << "Codec: " << codec;
return "unknown";

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

@ -29,12 +29,6 @@ enum AudioCodec {
kCodecPCM_S24BE,
kCodecOpus,
kCodecEAC3,
kCodecDTSC,
kCodecDTSH,
kCodecDTSL,
kCodecDTSE,
kCodecDTSP,
kCodecDTSM,
kNumAudioCodec
};

41
packager/media/formats/mp4/box_definitions.cc
View File

@ -1101,43 +1101,30 @@ bool AudioSampleEntry::ReadWrite(BoxBuffer* buffer) {
// Convert from 16.16 fixed point to integer.
samplerate >>= 16;
if (format == FOURCC_ENCA || format == FOURCC_MP4A) {
RCHECK(buffer->PrepareChildren());
if (format == FOURCC_ENCA) {
if (buffer->Reading()) {
// Continue scanning until a recognized protection scheme is found,
// or until we run out of protection schemes.
while (sinf.type.type != FOURCC_CENC) {
if (!buffer->ReadWriteChild(&sinf))
return false;
}
} else {
RCHECK(buffer->ReadWriteChild(&sinf));
RCHECK(buffer->PrepareChildren());
if (format == FOURCC_ENCA) {
if (buffer->Reading()) {
// Continue scanning until a recognized protection scheme is found,
// or until we run out of protection schemes.
while (sinf.type.type != FOURCC_CENC) {
if (!buffer->ReadWriteChild(&sinf))
return false;
}
} else {
RCHECK(buffer->ReadWriteChild(&sinf));
}
// ESDS is not valid in case of EAC3.
RCHECK(buffer->TryReadWriteChild(&esds));
}
// Read/write all other data in the buffer extra_data.
if (buffer->Reading()) {
LOG(INFO) << "read vector: " << buffer->Size() << ", " << buffer->Pos();
RCHECK(buffer->ReadWriteVector(&extra_data, buffer->Size() - buffer->Pos()));
} else {
LOG(INFO) << "write vector: " << extra_data.size();
RCHECK(buffer->ReadWriteVector(&extra_data, extra_data.size()));
}
// ESDS is not valid in case of EAC3.
RCHECK(buffer->TryReadWriteChild(&esds));
return true;
}
uint32_t AudioSampleEntry::ComputeSize() {
atom_size = kBoxSize + sizeof(data_reference_index) + sizeof(channelcount) +
sizeof(samplesize) + sizeof(samplerate) + sinf.ComputeSize() +
esds.ComputeSize() + extra_data.size() +
6 + 8 + // 6 + 8 bytes reserved.
4; // 4 bytes predefined.
esds.ComputeSize() + 6 + 8 + // 6 + 8 bytes reserved.
4; // 4 bytes predefined.
return atom_size;
}

1
packager/media/formats/mp4/box_definitions.h
View File

@ -218,7 +218,6 @@ struct AudioSampleEntry : Box {
ProtectionSchemeInfo sinf;
ElementaryStreamDescriptor esds;
std::vector<uint8_t> extra_data;
};
struct SampleDescription : FullBox {

3
packager/media/formats/mp4/box_definitions_comparison.h
View File

@ -200,8 +200,7 @@ inline bool operator==(const AudioSampleEntry& lhs,
lhs.data_reference_index == rhs.data_reference_index &&
lhs.channelcount == rhs.channelcount &&
lhs.samplesize == rhs.samplesize && lhs.samplerate == rhs.samplerate &&
lhs.sinf == rhs.sinf && lhs.esds == rhs.esds &&
lhs.extra_data == rhs.extra_data;
lhs.sinf == rhs.sinf && lhs.esds == rhs.esds;
}
inline bool operator==(const MediaHeader& lhs, const MediaHeader& rhs) {

20
packager/media/formats/mp4/box_definitions_unittest.cc
View File

@ -479,6 +479,7 @@ class BoxDefinitionsTestGeneral : public testing::Test {
url->flags = 2;
url->location.assign(kData8, kData8 + arraysize(kData8));
}
void Modify(DataEntryUrl* url) {
url->flags += 1;
url->location.assign(kData4, kData4 + arraysize(kData4));
@ -853,25 +854,6 @@ INSTANTIATE_TYPED_TEST_CASE_P(BoxDefinitionTypedTests2,
// Test other cases of box input.
class BoxDefinitionsTest : public BoxDefinitionsTestGeneral<Box> {};
TEST_F(BoxDefinitionsTest, DTSSampleEntry) {
const uint8_t kDtseData[] = {0x00, 0x00, 0x00, 0x1c, 0x64, 0x64, 0x74,
0x73, 0x00, 0x00, 0xbb, 0x80, 0x00, 0x03,
0xe4, 0x18, 0x00, 0x03, 0xe4, 0x18, 0x18,
0xe4, 0x7c, 0x00, 0x04, 0x00, 0x0f, 0x00};
AudioSampleEntry entry;
entry.format = FOURCC_DTSE;
entry.data_reference_index = 2;
entry.channelcount = 5;
entry.samplesize = 16;
entry.samplerate = 44100;
entry.extra_data.assign(kDtseData, kDtseData + arraysize(kDtseData));
entry.Write(this->buffer_.get());
AudioSampleEntry entry_readback;
ASSERT_TRUE(ReadBack(&entry_readback));
ASSERT_EQ(entry, entry_readback);
}
TEST_F(BoxDefinitionsTest, ProtectionSystemSpecificHeader) {
ProtectionSystemSpecificHeader pssh;
Fill(&pssh);

1
packager/media/formats/mp4/es_descriptor.h
View File

@ -24,6 +24,7 @@ enum ObjectType {
kForbidden = 0,
kISO_14496_3 = 0x40, // MPEG4 AAC
kISO_13818_7_AAC_LC = 0x67, // MPEG2 AAC-LC
kEAC3 = 0xa6 // Dolby Digital Plus
};
/// This class parses object type and decoder specific information from an

6
packager/media/formats/mp4/fourccs.h
View File

@ -22,12 +22,6 @@ enum FourCC {
FOURCC_DASH = 0x64617368,
FOURCC_DINF = 0x64696e66,
FOURCC_DREF = 0x64726566,
FOURCC_DTSE = 0x64747365,
FOURCC_DTSC = 0x64747363,
FOURCC_DTSH = 0x64747368,
FOURCC_DTSL = 0x6474736c,
FOURCC_DTSP = 0x6474732b,
FOURCC_DTSM = 0x6474732d,
FOURCC_EAC3 = 0x65632d33,
FOURCC_EDTS = 0x65647473,
FOURCC_ELST = 0x656c7374,

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

@ -40,7 +40,7 @@ uint64_t Rescale(uint64_t time_in_old_scale,
return (static_cast<double>(time_in_old_scale) / old_scale) * new_scale;
}
VideoCodec FourCCToVideoCodec(FourCC fourcc) {
VideoCodec FourCCToCodec(FourCC fourcc) {
switch (fourcc) {
case FOURCC_AVC1:
return kCodecH264;
@ -59,27 +59,6 @@ VideoCodec FourCCToVideoCodec(FourCC fourcc) {
}
}
AudioCodec FourCCToAudioCodec(FourCC fourcc) {
switch(fourcc) {
case FOURCC_DTSC:
return kCodecDTSC;
case FOURCC_DTSH:
return kCodecDTSH;
case FOURCC_DTSL:
return kCodecDTSL;
case FOURCC_DTSE:
return kCodecDTSE;
case FOURCC_DTSP:
return kCodecDTSP;
case FOURCC_DTSM:
return kCodecDTSM;
case FOURCC_EAC3:
return kCodecEAC3;
default:
return kUnknownAudioCodec;
}
}
const char kWidevineKeySystemId[] = "edef8ba979d64acea3c827dcd51d21ed";
} // namespace
@ -331,50 +310,45 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
// description indices, so we fail gracefully in that case.
if (desc_idx >= samp_descr.audio_entries.size())
desc_idx = 0;
const AudioSampleEntry& entry = samp_descr.audio_entries[desc_idx];
const FourCC actual_format = entry.GetActualFormat();
AudioCodec codec = FourCCToAudioCodec(actual_format);
if (!(entry.format == FOURCC_MP4A || entry.format == FOURCC_EAC3 ||
(entry.format == FOURCC_ENCA &&
entry.sinf.format.format == FOURCC_MP4A))) {
LOG(ERROR) << "Unsupported audio format 0x"
<< std::hex << entry.format << " in stsd box.";
return false;
}
ObjectType audio_type = entry.esds.es_descriptor.object_type();
DVLOG(1) << "audio_type " << std::hex << audio_type;
if (audio_type == kForbidden && entry.format == FOURCC_EAC3) {
audio_type = kEAC3;
}
AudioCodec codec = kUnknownAudioCodec;
uint8_t num_channels = 0;
uint32_t sampling_frequency = 0;
uint8_t audio_object_type = 0;
std::vector<uint8_t> extra_data;
switch (actual_format) {
case FOURCC_MP4A:
// Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
// supported MPEG2 AAC variants.
if (entry.esds.es_descriptor.IsAAC()) {
codec = kCodecAAC;
const AACAudioSpecificConfig& aac_audio_specific_config =
entry.esds.aac_audio_specific_config;
num_channels = aac_audio_specific_config.num_channels();
sampling_frequency = aac_audio_specific_config.frequency();
audio_object_type = aac_audio_specific_config.audio_object_type();
extra_data = entry.esds.es_descriptor.decoder_specific_info();
break;
} else {
LOG(ERROR) << "Unsupported audio format 0x" << std::hex
<< actual_format << " in stsd box.";
return false;
}
case FOURCC_DTSC:
case FOURCC_DTSH:
case FOURCC_DTSL:
case FOURCC_DTSE:
case FOURCC_DTSP:
case FOURCC_DTSM:
extra_data = entry.extra_data;
sampling_frequency = entry.samplerate;
break;
case FOURCC_EAC3:
num_channels = entry.channelcount;
sampling_frequency = entry.samplerate;
break;
default:
LOG(ERROR) << "Unsupported audio format 0x" << std::hex
<< actual_format << " in stsd box.";
return false;
// Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
// supported MPEG2 AAC variants.
if (entry.esds.es_descriptor.IsAAC()) {
codec = kCodecAAC;
const AACAudioSpecificConfig& aac_audio_specific_config =
entry.esds.aac_audio_specific_config;
num_channels = aac_audio_specific_config.num_channels();
sampling_frequency = aac_audio_specific_config.frequency();
audio_object_type = aac_audio_specific_config.audio_object_type();
extra_data = entry.esds.es_descriptor.decoder_specific_info();
} else if (audio_type == kEAC3) {
codec = kCodecEAC3;
num_channels = entry.channelcount;
sampling_frequency = entry.samplerate;
} else {
LOG(ERROR) << "Unsupported audio object type 0x"
<< std::hex << audio_type << " in esds.";
return false;
}
bool is_encrypted = entry.sinf.info.track_encryption.is_encrypted;
@ -412,7 +386,7 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
uint8_t nalu_length_size = 0;
const FourCC actual_format = entry.GetActualFormat();
const VideoCodec video_codec = FourCCToVideoCodec(actual_format);
const VideoCodec video_codec = FourCCToCodec(actual_format);
switch (actual_format) {
case FOURCC_AVC1: {
AVCDecoderConfiguration avc_config;