king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
v811_spc009/frameworks/av/media/extractors/mp4/AC4Parser.cpp

625 lines
26 KiB
Raw Permalink Blame History

/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "AC4Parser"
#include <inttypes.h>
#include <utils/Log.h>
#include <utils/misc.h>
#include "AC4Parser.h"
#define BOOLSTR(a) ((a)?"true":"false")
#define BYTE_ALIGN mBitReader.skipBits(mBitReader.numBitsLeft() % 8)
#define CHECK_BITS_LEFT(n) if (mBitReader.numBitsLeft() < n) {return false;}
namespace android {
AC4Parser::AC4Parser() {
}
AC4DSIParser::AC4DSIParser(ABitReader &br)
: mBitReader(br){
mDSISize = mBitReader.numBitsLeft();
}
// ETSI TS 103 190-2 V1.1.1 (2015-09) Table 79: channel_mode
static const char *ChannelModes[] = {
"mono",
"stereo",
"3.0",
"5.0",
"5.1",
"7.0 (3/4/0)",
"7.1 (3/4/0.1)",
"7.0 (5/2/0)",
"7.1 (5/2/0.1)",
"7.0 (3/2/2)",
"7.1 (3/2/2.1)",
"7.0.4",
"7.1.4",
"9.0.4",
"9.1.4",
"22.2"
};
static const char* ContentClassifier[] = {
"Complete Main",
"Music and Effects",
"Visually Impaired",
"Hearing Impaired",
"Dialog",
"Commentary",
"Emergency",
"Voice Over"
};
bool AC4DSIParser::parseLanguageTag(uint32_t presentationID, uint32_t substreamID){
CHECK_BITS_LEFT(6);
uint32_t n_language_tag_bytes = mBitReader.getBits(6);
if (n_language_tag_bytes < 2 || n_language_tag_bytes >= 42) {
return false;
}
CHECK_BITS_LEFT(n_language_tag_bytes * 8);
char language_tag_bytes[42]; // TS 103 190 part 1 4.3.3.8.7
for (uint32_t i = 0; i < n_language_tag_bytes; i++) {
language_tag_bytes[i] = (char)mBitReader.getBits(8);
}
language_tag_bytes[n_language_tag_bytes] = 0;
ALOGV("%u.%u: language_tag = %s\n", presentationID, substreamID, language_tag_bytes);
std::string language(language_tag_bytes, n_language_tag_bytes);
mPresentations[presentationID].mLanguage = language;
return true;
}
// TS 103 190-1 v1.2.1 E.5 and TS 103 190-2 v1.1.1 E.9
bool AC4DSIParser::parseSubstreamDSI(uint32_t presentationID, uint32_t substreamID){
CHECK_BITS_LEFT(5);
uint32_t channel_mode = mBitReader.getBits(5);
CHECK_BITS_LEFT(2);
uint32_t dsi_sf_multiplier = mBitReader.getBits(2);
CHECK_BITS_LEFT(1);
bool b_substream_bitrate_indicator = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u: channel_mode = %u (%s)\n", presentationID, substreamID, channel_mode,
channel_mode < NELEM(ChannelModes) ? ChannelModes[channel_mode] : "reserved");
ALOGV("%u.%u: dsi_sf_multiplier = %u\n", presentationID,
substreamID, dsi_sf_multiplier);
ALOGV("%u.%u: b_substream_bitrate_indicator = %s\n", presentationID,
substreamID, BOOLSTR(b_substream_bitrate_indicator));
if (b_substream_bitrate_indicator) {
CHECK_BITS_LEFT(5);
uint32_t substream_bitrate_indicator = mBitReader.getBits(5);
ALOGV("%u.%u: substream_bitrate_indicator = %u\n", presentationID, substreamID,
substream_bitrate_indicator);
}
if (channel_mode >= 7 && channel_mode <= 10) {
CHECK_BITS_LEFT(1);
uint32_t add_ch_base = mBitReader.getBits(1);
ALOGV("%u.%u: add_ch_base = %u\n", presentationID, substreamID, add_ch_base);
}
CHECK_BITS_LEFT(1);
bool b_content_type = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u: b_content_type = %s\n", presentationID, substreamID, BOOLSTR(b_content_type));
if (b_content_type) {
CHECK_BITS_LEFT(3);
uint32_t content_classifier = mBitReader.getBits(3);
ALOGV("%u.%u: content_classifier = %u (%s)\n", presentationID, substreamID,
content_classifier, ContentClassifier[content_classifier]);
// For streams based on TS 103 190 part 1 the presentation level channel_mode doesn't
// exist and so we use the channel_mode from either the CM or M&E substream
// (they are mutually exclusive)
if (mPresentations[presentationID].mChannelMode == -1 &&
(content_classifier == 0 || content_classifier == 1)) {
mPresentations[presentationID].mChannelMode = channel_mode;
}
mPresentations[presentationID].mContentClassifier = content_classifier;
CHECK_BITS_LEFT(1);
bool b_language_indicator = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u: b_language_indicator = %s\n", presentationID, substreamID,
BOOLSTR(b_language_indicator));
if (b_language_indicator) {
if (!parseLanguageTag(presentationID, substreamID)) {
return false;
}
}
}
return true;
}
// ETSI TS 103 190-2 v1.1.1 section E.11
bool AC4DSIParser::parseSubstreamGroupDSI(uint32_t presentationID, uint32_t groupID)
{
CHECK_BITS_LEFT(1);
bool b_substreams_present = (mBitReader.getBits(1) == 1);
CHECK_BITS_LEFT(1);
bool b_hsf_ext = (mBitReader.getBits(1) == 1);
CHECK_BITS_LEFT(1);
bool b_channel_coded = (mBitReader.getBits(1) == 1);
CHECK_BITS_LEFT(8);
uint32_t n_substreams = mBitReader.getBits(8);
ALOGV("%u.%u: b_substreams_present = %s\n", presentationID, groupID,
BOOLSTR(b_substreams_present));
ALOGV("%u.%u: b_hsf_ext = %s\n", presentationID, groupID, BOOLSTR(b_hsf_ext));
ALOGV("%u.%u: b_channel_coded = %s\n", presentationID, groupID, BOOLSTR(b_channel_coded));
ALOGV("%u.%u: n_substreams = %u\n", presentationID, groupID, n_substreams);
for (uint32_t i = 0; i < n_substreams; i++) {
CHECK_BITS_LEFT(2);
uint32_t dsi_sf_multiplier = mBitReader.getBits(2);
CHECK_BITS_LEFT(1);
bool b_substream_bitrate_indicator = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u.%u: dsi_sf_multiplier = %u\n", presentationID, groupID, i, dsi_sf_multiplier);
ALOGV("%u.%u.%u: b_substream_bitrate_indicator = %s\n", presentationID, groupID, i,
BOOLSTR(b_substream_bitrate_indicator));
if (b_substream_bitrate_indicator) {
CHECK_BITS_LEFT(5);
uint32_t substream_bitrate_indicator = mBitReader.getBits(5);
ALOGV("%u.%u.%u: substream_bitrate_indicator = %u\n", presentationID, groupID, i,
substream_bitrate_indicator);
}
if (b_channel_coded) {
CHECK_BITS_LEFT(24);
uint32_t dsi_substream_channel_mask = mBitReader.getBits(24);
ALOGV("%u.%u.%u: dsi_substream_channel_mask = 0x%06x\n", presentationID, groupID, i,
dsi_substream_channel_mask);
} else {
CHECK_BITS_LEFT(1);
bool b_ajoc = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u.%u: b_ajoc = %s\n", presentationID, groupID, i, BOOLSTR(b_ajoc));
if (b_ajoc) {
CHECK_BITS_LEFT(1);
bool b_static_dmx = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u.%u: b_static_dmx = %s\n", presentationID, groupID, i,
BOOLSTR(b_static_dmx));
if (!b_static_dmx) {
CHECK_BITS_LEFT(4);
uint32_t n_dmx_objects_minus1 = mBitReader.getBits(4);
ALOGV("%u.%u.%u: n_dmx_objects_minus1 = %u\n", presentationID, groupID, i,
n_dmx_objects_minus1);
}
CHECK_BITS_LEFT(6);
uint32_t n_umx_objects_minus1 = mBitReader.getBits(6);
ALOGV("%u.%u.%u: n_umx_objects_minus1 = %u\n", presentationID, groupID, i,
n_umx_objects_minus1);
}
CHECK_BITS_LEFT(4);
mBitReader.skipBits(4); // objects_assignment_mask
}
}
CHECK_BITS_LEFT(1);
bool b_content_type = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u: b_content_type = %s\n", presentationID, groupID, BOOLSTR(b_content_type));
if (b_content_type) {
CHECK_BITS_LEFT(3);
uint32_t content_classifier = mBitReader.getBits(3);
ALOGV("%u.%u: content_classifier = %s (%u)\n", presentationID, groupID,
ContentClassifier[content_classifier], content_classifier);
mPresentations[presentationID].mContentClassifier = content_classifier;
CHECK_BITS_LEFT(1);
bool b_language_indicator = (mBitReader.getBits(1) == 1);
ALOGV("%u.%u: b_language_indicator = %s\n", presentationID, groupID,
BOOLSTR(b_language_indicator));
if (b_language_indicator) {
if (!parseLanguageTag(presentationID, groupID)) {
return false;
}
}
}
return true;
}
bool AC4DSIParser::parseBitrateDsi() {
CHECK_BITS_LEFT(2 + 32 + 32);
mBitReader.skipBits(2); // bit_rate_mode
mBitReader.skipBits(32); // bit_rate
mBitReader.skipBits(32); // bit_rate_precision
return true;
}
// TS 103 190-1 section E.4 (ac4_dsi) and TS 103 190-2 section E.6 (ac4_dsi_v1)
bool AC4DSIParser::parse() {
CHECK_BITS_LEFT(3);
uint32_t ac4_dsi_version = mBitReader.getBits(3);
if (ac4_dsi_version > 1) {
ALOGE("error while parsing ac-4 dsi: only versions 0 and 1 are supported");
return false;
}
CHECK_BITS_LEFT(7 + 1 + 4 + 9);
uint32_t bitstream_version = mBitReader.getBits(7);
mBitReader.skipBits(1); // fs_index
mBitReader.skipBits(4); // frame_rate_index
uint32_t n_presentations = mBitReader.getBits(9);
int32_t short_program_id = -1;
if (bitstream_version > 1) {
if (ac4_dsi_version == 0) {
ALOGE("invalid ac4 dsi");
return false;
}
CHECK_BITS_LEFT(1);
bool b_program_id = (mBitReader.getBits(1) == 1);
if (b_program_id) {
CHECK_BITS_LEFT(16 + 1);
short_program_id = mBitReader.getBits(16);
bool b_uuid = (mBitReader.getBits(1) == 1);
if (b_uuid) {
const uint32_t kAC4UUIDSizeInBytes = 16;
char program_uuid[kAC4UUIDSizeInBytes];
CHECK_BITS_LEFT(kAC4UUIDSizeInBytes * 8);
for (uint32_t i = 0; i < kAC4UUIDSizeInBytes; i++) {
program_uuid[i] = (char)(mBitReader.getBits(8));
}
ALOGV("UUID = %s", program_uuid);
}
}
}
if (ac4_dsi_version == 1) {
if (!parseBitrateDsi()) {
return false;
}
BYTE_ALIGN;
}
for (uint32_t presentation = 0; presentation < n_presentations; presentation++) {
mPresentations[presentation].mProgramID = short_program_id;
// known as b_single_substream in ac4_dsi_version 0
bool b_single_substream_group = false;
uint32_t presentation_config = 0, presentation_version = 0;
uint32_t pres_bytes = 0;
uint64_t start = 0;
if (ac4_dsi_version == 0) {
CHECK_BITS_LEFT(1 + 5 + 5);
b_single_substream_group = (mBitReader.getBits(1) == 1);
presentation_config = mBitReader.getBits(5);
presentation_version = mBitReader.getBits(5);
} else if (ac4_dsi_version == 1) {
CHECK_BITS_LEFT(8 + 8);
presentation_version = mBitReader.getBits(8);
pres_bytes = mBitReader.getBits(8);
if (pres_bytes == 0xff) {
CHECK_BITS_LEFT(16);
pres_bytes += mBitReader.getBits(16);
}
ALOGV("%u: pres_bytes = %u\n", presentation, pres_bytes);
if (presentation_version > 2) {
CHECK_BITS_LEFT(pres_bytes * 8);
mBitReader.skipBits(pres_bytes * 8);
continue;
}
/* record a marker, less the size of the presentation_config */
start = (mDSISize - mBitReader.numBitsLeft()) / 8;
// ac4_presentation_v0_dsi(), ac4_presentation_v1_dsi() and ac4_presentation_v2_dsi()
// all start with a presentation_config of 5 bits
CHECK_BITS_LEFT(5);
presentation_config = mBitReader.getBits(5);
b_single_substream_group = (presentation_config == 0x1f);
}
static const char *PresentationConfig[] = {
"Music&Effects + Dialog",
"Main + DE",
"Main + Associate",
"Music&Effects + Dialog + Associate",
"Main + DE + Associate",
"Arbitrary substream groups",
"EMDF only"
};
ALOGV("%u: b_single_substream/group = %s\n", presentation,
BOOLSTR(b_single_substream_group));
ALOGV("%u: presentation_version = %u\n", presentation, presentation_version);
ALOGV("%u: presentation_config = %u (%s)\n", presentation, presentation_config,
(presentation_config >= NELEM(PresentationConfig) ?
"reserved" : PresentationConfig[presentation_config]));
bool b_add_emdf_substreams = false;
if (!b_single_substream_group && presentation_config == 6) {
b_add_emdf_substreams = true;
ALOGV("%u: b_add_emdf_substreams = %s\n", presentation, BOOLSTR(b_add_emdf_substreams));
} else {
CHECK_BITS_LEFT(3 + 1);
uint32_t mdcompat = mBitReader.getBits(3);
ALOGV("%u: mdcompat = %d\n", presentation, mdcompat);
bool b_presentation_group_index = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_presentation_group_index = %s\n", presentation,
BOOLSTR(b_presentation_group_index));
if (b_presentation_group_index) {
CHECK_BITS_LEFT(5);
mPresentations[presentation].mGroupIndex = mBitReader.getBits(5);
ALOGV("%u: presentation_group_index = %d\n", presentation,
mPresentations[presentation].mGroupIndex);
}
CHECK_BITS_LEFT(2);
uint32_t dsi_frame_rate_multiply_info = mBitReader.getBits(2);
ALOGV("%u: dsi_frame_rate_multiply_info = %d\n", presentation,
dsi_frame_rate_multiply_info);
if (ac4_dsi_version == 1 && (presentation_version == 1 || presentation_version == 2)) {
CHECK_BITS_LEFT(2);
uint32_t dsi_frame_rate_fraction_info = mBitReader.getBits(2);
ALOGV("%u: dsi_frame_rate_fraction_info = %d\n", presentation,
dsi_frame_rate_fraction_info);
}
CHECK_BITS_LEFT(5 + 10);
uint32_t presentation_emdf_version = mBitReader.getBits(5);
uint32_t presentation_key_id = mBitReader.getBits(10);
ALOGV("%u: presentation_emdf_version = %d\n", presentation, presentation_emdf_version);
ALOGV("%u: presentation_key_id = %d\n", presentation, presentation_key_id);
if (ac4_dsi_version == 1) {
bool b_presentation_channel_coded = false;
if (presentation_version == 0) {
b_presentation_channel_coded = true;
} else {
CHECK_BITS_LEFT(1);
b_presentation_channel_coded = (mBitReader.getBits(1) == 1);
}
ALOGV("%u: b_presentation_channel_coded = %s\n", presentation,
BOOLSTR(b_presentation_channel_coded));
if (b_presentation_channel_coded) {
if (presentation_version == 1 || presentation_version == 2) {
CHECK_BITS_LEFT(5);
uint32_t dsi_presentation_ch_mode = mBitReader.getBits(5);
mPresentations[presentation].mChannelMode = dsi_presentation_ch_mode;
ALOGV("%u: dsi_presentation_ch_mode = %d (%s)\n", presentation,
dsi_presentation_ch_mode,
dsi_presentation_ch_mode < NELEM(ChannelModes) ?
ChannelModes[dsi_presentation_ch_mode] : "reserved");
if (dsi_presentation_ch_mode >= 11 && dsi_presentation_ch_mode <= 14) {
CHECK_BITS_LEFT(1 + 2);
uint32_t pres_b_4_back_channels_present = mBitReader.getBits(1);
uint32_t pres_top_channel_pairs = mBitReader.getBits(2);
ALOGV("%u: pres_b_4_back_channels_present = %s\n", presentation,
BOOLSTR(pres_b_4_back_channels_present));
ALOGV("%u: pres_top_channel_pairs = %d\n", presentation,
pres_top_channel_pairs);
}
}
// presentation_channel_mask in ac4_presentation_v0_dsi()
CHECK_BITS_LEFT(24);
uint32_t presentation_channel_mask_v1 = mBitReader.getBits(24);
ALOGV("%u: presentation_channel_mask_v1 = 0x%06x\n", presentation,
presentation_channel_mask_v1);
}
if (presentation_version == 1 || presentation_version == 2) {
CHECK_BITS_LEFT(1);
bool b_presentation_core_differs = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_presentation_core_differs = %s\n", presentation,
BOOLSTR(b_presentation_core_differs));
if (b_presentation_core_differs) {
CHECK_BITS_LEFT(1);
bool b_presentation_core_channel_coded = (mBitReader.getBits(1) == 1);
if (b_presentation_core_channel_coded) {
CHECK_BITS_LEFT(2);
mBitReader.skipBits(2); // dsi_presentation_channel_mode_core
}
}
CHECK_BITS_LEFT(1);
bool b_presentation_filter = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_presentation_filter = %s\n", presentation,
BOOLSTR(b_presentation_filter));
if (b_presentation_filter) {
CHECK_BITS_LEFT(1 + 8);
bool b_enable_presentation = (mBitReader.getBits(1) == 1);
if (!b_enable_presentation) {
mPresentations[presentation].mEnabled = false;
}
ALOGV("%u: b_enable_presentation = %s\n", presentation,
BOOLSTR(b_enable_presentation));
uint32_t n_filter_bytes = mBitReader.getBits(8);
CHECK_BITS_LEFT(n_filter_bytes * 8);
for (uint32_t i = 0; i < n_filter_bytes; i++) {
mBitReader.skipBits(8); // filter_data
}
}
}
} /* ac4_dsi_version == 1 */
if (b_single_substream_group) {
if (presentation_version == 0) {
if (!parseSubstreamDSI(presentation, 0)) {
return false;
}
} else {
if (!parseSubstreamGroupDSI(presentation, 0)) {
return false;
}
}
} else {
if (ac4_dsi_version == 1) {
CHECK_BITS_LEFT(1);
bool b_multi_pid = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_multi_pid = %s\n", presentation, BOOLSTR(b_multi_pid));
} else {
CHECK_BITS_LEFT(1);
bool b_hsf_ext = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_hsf_ext = %s\n", presentation, BOOLSTR(b_hsf_ext));
}
switch (presentation_config) {
case 0:
case 1:
case 2:
if (presentation_version == 0) {
if (!parseSubstreamDSI(presentation, 0)) {
return false;
}
if (!parseSubstreamDSI(presentation, 1)) {
return false;
}
} else {
if (!parseSubstreamGroupDSI(presentation, 0)) {
return false;
}
if (!parseSubstreamGroupDSI(presentation, 1)) {
return false;
}
}
break;
case 3:
case 4:
if (presentation_version == 0) {
if (!parseSubstreamDSI(presentation, 0)) {
return false;
}
if (!parseSubstreamDSI(presentation, 1)) {
return false;
}
if (!parseSubstreamDSI(presentation, 2)) {
return false;
}
} else {
if (!parseSubstreamGroupDSI(presentation, 0)) {
return false;
}
if (!parseSubstreamGroupDSI(presentation, 1)) {
return false;
}
if (!parseSubstreamGroupDSI(presentation, 2)) {
return false;
}
}
break;
case 5:
if (presentation_version == 0) {
if (!parseSubstreamDSI(presentation, 0)) {
return false;
}
} else {
CHECK_BITS_LEFT(3);
uint32_t n_substream_groups_minus2 = mBitReader.getBits(3);
ALOGV("%u: n_substream_groups_minus2 = %d\n", presentation,
n_substream_groups_minus2);
for (uint32_t sg = 0; sg < n_substream_groups_minus2 + 2; sg++) {
if (!parseSubstreamGroupDSI(presentation, sg)) {
return false;
}
}
}
break;
default:
CHECK_BITS_LEFT(7);
uint32_t n_skip_bytes = mBitReader.getBits(7);
CHECK_BITS_LEFT(n_skip_bytes * 8)
for (uint32_t j = 0; j < n_skip_bytes; j++) {
mBitReader.getBits(8);
}
break;
}
}
CHECK_BITS_LEFT(1 + 1);
bool b_pre_virtualized = (mBitReader.getBits(1) == 1);
mPresentations[presentation].mPreVirtualized = b_pre_virtualized;
b_add_emdf_substreams = (mBitReader.getBits(1) == 1);
ALOGV("%u: b_pre_virtualized = %s\n", presentation, BOOLSTR(b_pre_virtualized));
ALOGV("%u: b_add_emdf_substreams = %s\n", presentation,
BOOLSTR(b_add_emdf_substreams));
}
if (b_add_emdf_substreams) {
CHECK_BITS_LEFT(7);
uint32_t n_add_emdf_substreams = mBitReader.getBits(7);
for (uint32_t j = 0; j < n_add_emdf_substreams; j++) {
CHECK_BITS_LEFT(5 + 10);
uint32_t substream_emdf_version = mBitReader.getBits(5);
uint32_t substream_key_id = mBitReader.getBits(10);
ALOGV("%u: emdf_substream[%d]: version=%d, key_id=%d\n", presentation, j,
substream_emdf_version, substream_key_id);
}
}
bool b_presentation_bitrate_info = false;
if (presentation_version > 0) {
CHECK_BITS_LEFT(1);
b_presentation_bitrate_info = (mBitReader.getBits(1) == 1);
}
ALOGV("b_presentation_bitrate_info = %s\n", BOOLSTR(b_presentation_bitrate_info));
if (b_presentation_bitrate_info) {
if (!parseBitrateDsi()) {
return false;
}
}
if (presentation_version > 0) {
CHECK_BITS_LEFT(1);
bool b_alternative = (mBitReader.getBits(1) == 1);
ALOGV("b_alternative = %s\n", BOOLSTR(b_alternative));
if (b_alternative) {
BYTE_ALIGN;
CHECK_BITS_LEFT(16);
uint32_t name_len = mBitReader.getBits(16);
CHECK_BITS_LEFT(name_len * 8);
std::string &presentation_name =
mPresentations[presentation].mDescription;
presentation_name.clear();
presentation_name.resize(name_len);
for (uint32_t i = 0; i < name_len; i++) {
presentation_name[i] = (char)(mBitReader.getBits(8));
}
CHECK_BITS_LEFT(5);
uint32_t n_targets = mBitReader.getBits(5);
CHECK_BITS_LEFT(n_targets * (3 + 8));
for (uint32_t i = 0; i < n_targets; i++){
mBitReader.skipBits(3); // target_md_compat
mBitReader.skipBits(8); // target_device_category
}
}
}
BYTE_ALIGN;
if (ac4_dsi_version == 1) {
uint64_t end = (mDSISize - mBitReader.numBitsLeft()) / 8;
uint64_t presentation_bytes = end - start;
if (pres_bytes < presentation_bytes) {
ALOGE("pres_bytes is smaller than presentation_bytes.");
return false;
}
uint64_t skip_bytes = pres_bytes - presentation_bytes;
ALOGV("skipping = %" PRIu64 " bytes", skip_bytes);
CHECK_BITS_LEFT(skip_bytes * 8);
mBitReader.skipBits(skip_bytes * 8);
}
// we should know this or something is probably wrong
// with the bitstream (or we don't support it)
if (mPresentations[presentation].mChannelMode == -1) {
ALOGE("could not determing channel mode of presentation %d", presentation);
return false;
}
} /* each presentation */
return true;
}
};
Reference in new issue View Git Blame Copy Permalink