mirror of
https://github.com/mpv-player/mpv
synced 2024-12-14 19:05:33 +00:00
e24087509a
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10990 b3059339-0415-0410-9bf9-f77b7e298cf2
1946 lines
62 KiB
C
1946 lines
62 KiB
C
/*
|
||
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
||
** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
|
||
**
|
||
** This program is free software; you can redistribute it and/or modify
|
||
** it under the terms of the GNU General Public License as published by
|
||
** the Free Software Foundation; either version 2 of the License, or
|
||
** (at your option) any later version.
|
||
**
|
||
** This program is distributed in the hope that it will be useful,
|
||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
** GNU General Public License for more details.
|
||
**
|
||
** You should have received a copy of the GNU General Public License
|
||
** along with this program; if not, write to the Free Software
|
||
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||
**
|
||
** Any non-GPL usage of this software or parts of this software is strictly
|
||
** forbidden.
|
||
**
|
||
** Commercial non-GPL licensing of this software is possible.
|
||
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
||
**
|
||
** $Id: syntax.c,v 1.56 2003/09/30 12:43:05 menno Exp $
|
||
**/
|
||
|
||
/*
|
||
Reads the AAC bitstream as defined in 14496-3 (MPEG-4 Audio)
|
||
*/
|
||
|
||
#include "common.h"
|
||
#include "structs.h"
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#include "decoder.h"
|
||
#include "syntax.h"
|
||
#include "specrec.h"
|
||
#include "huffman.h"
|
||
#include "bits.h"
|
||
#include "pulse.h"
|
||
#include "analysis.h"
|
||
#include "drc.h"
|
||
#ifdef ERROR_RESILIENCE
|
||
#include "rvlc.h"
|
||
#endif
|
||
#ifdef SBR_DEC
|
||
#include "sbr_syntax.h"
|
||
#endif
|
||
|
||
|
||
/* Table 4.4.1 */
|
||
int8_t GASpecificConfig(bitfile *ld, mp4AudioSpecificConfig *mp4ASC,
|
||
program_config *pce_out)
|
||
{
|
||
program_config pce;
|
||
|
||
/* 1024 or 960 */
|
||
mp4ASC->frameLengthFlag = faad_get1bit(ld
|
||
DEBUGVAR(1,138,"GASpecificConfig(): FrameLengthFlag"));
|
||
|
||
mp4ASC->dependsOnCoreCoder = faad_get1bit(ld
|
||
DEBUGVAR(1,139,"GASpecificConfig(): DependsOnCoreCoder"));
|
||
if (mp4ASC->dependsOnCoreCoder == 1)
|
||
{
|
||
mp4ASC->coreCoderDelay = (uint16_t)faad_getbits(ld, 14
|
||
DEBUGVAR(1,140,"GASpecificConfig(): CoreCoderDelay"));
|
||
}
|
||
|
||
mp4ASC->extensionFlag = faad_get1bit(ld DEBUGVAR(1,141,"GASpecificConfig(): ExtensionFlag"));
|
||
if (mp4ASC->channelsConfiguration == 0)
|
||
{
|
||
program_config_element(&pce, ld);
|
||
//mp4ASC->channelsConfiguration = pce.channels;
|
||
|
||
if (pce_out != NULL)
|
||
memcpy(pce_out, &pce, sizeof(program_config));
|
||
|
||
/*
|
||
if (pce.num_valid_cc_elements)
|
||
return -3;
|
||
*/
|
||
}
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (mp4ASC->extensionFlag == 1)
|
||
{
|
||
/* Error resilience not supported yet */
|
||
if (mp4ASC->objectTypeIndex >= ER_OBJECT_START)
|
||
{
|
||
mp4ASC->aacSectionDataResilienceFlag = faad_get1bit(ld
|
||
DEBUGVAR(1,144,"GASpecificConfig(): aacSectionDataResilienceFlag"));
|
||
mp4ASC->aacScalefactorDataResilienceFlag = faad_get1bit(ld
|
||
DEBUGVAR(1,145,"GASpecificConfig(): aacScalefactorDataResilienceFlag"));
|
||
mp4ASC->aacSpectralDataResilienceFlag = faad_get1bit(ld
|
||
DEBUGVAR(1,146,"GASpecificConfig(): aacSpectralDataResilienceFlag"));
|
||
|
||
/* 1 bit: extensionFlag3 */
|
||
}
|
||
}
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.2 */
|
||
/* An MPEG-4 Audio decoder is only required to follow the Program
|
||
Configuration Element in GASpecificConfig(). The decoder shall ignore
|
||
any Program Configuration Elements that may occur in raw data blocks.
|
||
PCEs transmitted in raw data blocks cannot be used to convey decoder
|
||
configuration information.
|
||
*/
|
||
uint8_t program_config_element(program_config *pce, bitfile *ld)
|
||
{
|
||
uint8_t i;
|
||
|
||
memset(pce, 0, sizeof(program_config));
|
||
|
||
pce->channels = 0;
|
||
|
||
pce->element_instance_tag = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,10,"program_config_element(): element_instance_tag"));
|
||
|
||
pce->object_type = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,11,"program_config_element(): object_type"));
|
||
pce->sf_index = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,12,"program_config_element(): sf_index"));
|
||
pce->num_front_channel_elements = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,13,"program_config_element(): num_front_channel_elements"));
|
||
pce->num_side_channel_elements = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,14,"program_config_element(): num_side_channel_elements"));
|
||
pce->num_back_channel_elements = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,15,"program_config_element(): num_back_channel_elements"));
|
||
pce->num_lfe_channel_elements = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,16,"program_config_element(): num_lfe_channel_elements"));
|
||
pce->num_assoc_data_elements = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,17,"program_config_element(): num_assoc_data_elements"));
|
||
pce->num_valid_cc_elements = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,18,"program_config_element(): num_valid_cc_elements"));
|
||
|
||
pce->mono_mixdown_present = faad_get1bit(ld
|
||
DEBUGVAR(1,19,"program_config_element(): mono_mixdown_present"));
|
||
if (pce->mono_mixdown_present == 1)
|
||
{
|
||
pce->mono_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,20,"program_config_element(): mono_mixdown_element_number"));
|
||
}
|
||
|
||
pce->stereo_mixdown_present = faad_get1bit(ld
|
||
DEBUGVAR(1,21,"program_config_element(): stereo_mixdown_present"));
|
||
if (pce->stereo_mixdown_present == 1)
|
||
{
|
||
pce->stereo_mixdown_element_number = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,22,"program_config_element(): stereo_mixdown_element_number"));
|
||
}
|
||
|
||
pce->matrix_mixdown_idx_present = faad_get1bit(ld
|
||
DEBUGVAR(1,23,"program_config_element(): matrix_mixdown_idx_present"));
|
||
if (pce->matrix_mixdown_idx_present == 1)
|
||
{
|
||
pce->matrix_mixdown_idx = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,24,"program_config_element(): matrix_mixdown_idx"));
|
||
pce->pseudo_surround_enable = faad_get1bit(ld
|
||
DEBUGVAR(1,25,"program_config_element(): pseudo_surround_enable"));
|
||
}
|
||
|
||
for (i = 0; i < pce->num_front_channel_elements; i++)
|
||
{
|
||
pce->front_element_is_cpe[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,26,"program_config_element(): front_element_is_cpe"));
|
||
pce->front_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,27,"program_config_element(): front_element_tag_select"));
|
||
|
||
if (pce->front_element_is_cpe[i] & 1)
|
||
{
|
||
pce->cpe_channel[pce->front_element_tag_select[i]] = pce->channels;
|
||
pce->num_front_channels += 2;
|
||
pce->channels += 2;
|
||
} else {
|
||
pce->sce_channel[pce->front_element_tag_select[i]] = pce->channels;
|
||
pce->num_front_channels++;
|
||
pce->channels++;
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < pce->num_side_channel_elements; i++)
|
||
{
|
||
pce->side_element_is_cpe[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,28,"program_config_element(): side_element_is_cpe"));
|
||
pce->side_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,29,"program_config_element(): side_element_tag_select"));
|
||
|
||
if (pce->side_element_is_cpe[i] & 1)
|
||
{
|
||
pce->cpe_channel[pce->side_element_tag_select[i]] = pce->channels;
|
||
pce->num_side_channels += 2;
|
||
pce->channels += 2;
|
||
} else {
|
||
pce->sce_channel[pce->side_element_tag_select[i]] = pce->channels;
|
||
pce->num_side_channels++;
|
||
pce->channels++;
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < pce->num_back_channel_elements; i++)
|
||
{
|
||
pce->back_element_is_cpe[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,30,"program_config_element(): back_element_is_cpe"));
|
||
pce->back_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,31,"program_config_element(): back_element_tag_select"));
|
||
|
||
if (pce->back_element_is_cpe[i] & 1)
|
||
{
|
||
pce->cpe_channel[pce->back_element_tag_select[i]] = pce->channels;
|
||
pce->channels += 2;
|
||
pce->num_back_channels += 2;
|
||
} else {
|
||
pce->sce_channel[pce->back_element_tag_select[i]] = pce->channels;
|
||
pce->num_back_channels++;
|
||
pce->channels++;
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < pce->num_lfe_channel_elements; i++)
|
||
{
|
||
pce->lfe_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,32,"program_config_element(): lfe_element_tag_select"));
|
||
|
||
pce->sce_channel[pce->lfe_element_tag_select[i]] = pce->channels;
|
||
pce->num_lfe_channels++;
|
||
pce->channels++;
|
||
}
|
||
|
||
for (i = 0; i < pce->num_assoc_data_elements; i++)
|
||
pce->assoc_data_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,33,"program_config_element(): assoc_data_element_tag_select"));
|
||
|
||
for (i = 0; i < pce->num_valid_cc_elements; i++)
|
||
{
|
||
pce->cc_element_is_ind_sw[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,34,"program_config_element(): cc_element_is_ind_sw"));
|
||
pce->valid_cc_element_tag_select[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,35,"program_config_element(): valid_cc_element_tag_select"));
|
||
}
|
||
|
||
faad_byte_align(ld);
|
||
|
||
pce->comment_field_bytes = (uint8_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,36,"program_config_element(): comment_field_bytes"));
|
||
|
||
for (i = 0; i < pce->comment_field_bytes; i++)
|
||
{
|
||
pce->comment_field_data[i] = (uint8_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,37,"program_config_element(): comment_field_data"));
|
||
}
|
||
pce->comment_field_data[i] = 0;
|
||
|
||
return 0;
|
||
}
|
||
|
||
element *decode_sce_lfe(faacDecHandle hDecoder,
|
||
faacDecFrameInfo *hInfo, bitfile *ld,
|
||
real_t **spec_coef, uint8_t id_syn_ele)
|
||
{
|
||
element *ele;
|
||
uint8_t channels = hDecoder->fr_channels;
|
||
|
||
if (channels+1 > MAX_CHANNELS)
|
||
{
|
||
hInfo->error = 12;
|
||
return NULL;
|
||
}
|
||
if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
|
||
{
|
||
hInfo->error = 13;
|
||
return NULL;
|
||
}
|
||
|
||
spec_coef[channels] = (real_t*)malloc(hDecoder->frameLength*sizeof(real_t));
|
||
|
||
ele = (element*)malloc(sizeof(element));
|
||
memset(ele, 0, sizeof(element));
|
||
ele->ele_id = id_syn_ele;
|
||
ele->channel = channels;
|
||
ele->paired_channel = -1;
|
||
|
||
hInfo->error = single_lfe_channel_element(hDecoder, ele,
|
||
ld, spec_coef[channels]);
|
||
|
||
if (hDecoder->pce_set)
|
||
hDecoder->internal_channel[hDecoder->pce.sce_channel[ele->element_instance_tag]] = channels;
|
||
else
|
||
hDecoder->internal_channel[channels] = channels;
|
||
|
||
if (id_syn_ele == ID_SCE)
|
||
hDecoder->channel_element[channels] = hDecoder->fr_ch_ele;
|
||
else /* LFE */
|
||
hDecoder->channel_element[channels] = hDecoder->fr_ch_ele;
|
||
|
||
hDecoder->fr_channels++;
|
||
hDecoder->fr_ch_ele++;
|
||
|
||
return ele;
|
||
}
|
||
|
||
element *decode_cpe(faacDecHandle hDecoder,
|
||
faacDecFrameInfo *hInfo, bitfile *ld,
|
||
real_t **spec_coef, uint8_t id_syn_ele)
|
||
{
|
||
element *ele;
|
||
uint8_t channels = hDecoder->fr_channels;
|
||
|
||
if (channels+2 > MAX_CHANNELS)
|
||
{
|
||
hInfo->error = 12;
|
||
return NULL;
|
||
}
|
||
if (hDecoder->fr_ch_ele+1 > MAX_SYNTAX_ELEMENTS)
|
||
{
|
||
hInfo->error = 13;
|
||
return NULL;
|
||
}
|
||
|
||
spec_coef[channels] = (real_t*)malloc(hDecoder->frameLength*sizeof(real_t));
|
||
spec_coef[channels+1] = (real_t*)malloc(hDecoder->frameLength*sizeof(real_t));
|
||
|
||
ele = (element*)malloc(sizeof(element));
|
||
memset(ele, 0, sizeof(element));
|
||
ele->ele_id = id_syn_ele;
|
||
ele->channel = channels;
|
||
ele->paired_channel = channels+1;
|
||
|
||
hInfo->error = channel_pair_element(hDecoder, ele,
|
||
ld, spec_coef[channels], spec_coef[channels+1]);
|
||
|
||
if (hDecoder->pce_set)
|
||
{
|
||
hDecoder->internal_channel[hDecoder->pce.cpe_channel[ele->element_instance_tag]] = channels;
|
||
hDecoder->internal_channel[hDecoder->pce.cpe_channel[ele->element_instance_tag]+1] = channels+1;
|
||
} else {
|
||
hDecoder->internal_channel[channels] = channels;
|
||
hDecoder->internal_channel[channels+1] = channels+1;
|
||
}
|
||
|
||
hDecoder->channel_element[channels] = hDecoder->fr_ch_ele;
|
||
hDecoder->channel_element[channels+1] = hDecoder->fr_ch_ele;
|
||
|
||
hDecoder->fr_channels += 2;
|
||
hDecoder->fr_ch_ele++;
|
||
|
||
return ele;
|
||
}
|
||
|
||
element **raw_data_block(faacDecHandle hDecoder, faacDecFrameInfo *hInfo,
|
||
bitfile *ld, element **elements,
|
||
real_t **spec_coef, program_config *pce, drc_info *drc)
|
||
{
|
||
uint8_t id_syn_ele;
|
||
uint8_t ch_ele = 0;
|
||
|
||
hDecoder->fr_channels = 0;
|
||
hDecoder->fr_ch_ele = 0;
|
||
hDecoder->first_syn_ele = 25;
|
||
hDecoder->has_lfe = 0;
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (hDecoder->object_type < ER_OBJECT_START)
|
||
{
|
||
#endif
|
||
/* Table 4.4.3: raw_data_block() */
|
||
while ((id_syn_ele = (uint8_t)faad_getbits(ld, LEN_SE_ID
|
||
DEBUGVAR(1,4,"faacDecDecode(): id_syn_ele"))) != ID_END)
|
||
{
|
||
switch (id_syn_ele) {
|
||
case ID_SCE:
|
||
if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
|
||
hDecoder->last_syn_ele = id_syn_ele;
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, id_syn_ele);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case ID_CPE:
|
||
if (hDecoder->first_syn_ele == 25) hDecoder->first_syn_ele = id_syn_ele;
|
||
hDecoder->last_syn_ele = id_syn_ele;
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, id_syn_ele);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case ID_LFE:
|
||
hDecoder->has_lfe++;
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, id_syn_ele);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case ID_CCE: /* not implemented yet, but skip the bits */
|
||
hInfo->error = coupling_channel_element(hDecoder, ld);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case ID_DSE:
|
||
data_stream_element(hDecoder, ld);
|
||
break;
|
||
case ID_PCE:
|
||
if ((hInfo->error = program_config_element(pce, ld)) > 0)
|
||
return elements;
|
||
hDecoder->pce_set = 1;
|
||
break;
|
||
case ID_FIL:
|
||
/* one sbr_info describes a channel_element not a channel! */
|
||
if ((hInfo->error = fill_element(hDecoder, ld, drc
|
||
#ifdef SBR_DEC
|
||
, (ch_ele-1)
|
||
#endif
|
||
)) > 0)
|
||
return elements;
|
||
#ifdef SBR_DEC
|
||
if (hDecoder->sbr_used[ch_ele-1])
|
||
{
|
||
hDecoder->sbr_present_flag = 1;
|
||
hDecoder->sbr[ch_ele-1]->sample_rate = get_sample_rate(hDecoder->sf_index);
|
||
hDecoder->sbr[ch_ele-1]->sample_rate *= 2;
|
||
}
|
||
#endif
|
||
break;
|
||
}
|
||
}
|
||
#ifdef ERROR_RESILIENCE
|
||
} else {
|
||
/* Table 262: er_raw_data_block() */
|
||
switch (hDecoder->channelConfiguration)
|
||
{
|
||
case 1:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 2:
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 3:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 4:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 5:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 6:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_LFE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
case 7:
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_SCE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_cpe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_CPE);
|
||
elements[ch_ele++] = decode_sce_lfe(hDecoder,
|
||
hInfo, ld, spec_coef, ID_LFE);
|
||
if (hInfo->error > 0)
|
||
return elements;
|
||
break;
|
||
default:
|
||
hInfo->error = 7;
|
||
return elements;
|
||
}
|
||
#if 0
|
||
cnt = bits_to_decode() / 8;
|
||
while (cnt >= 1)
|
||
{
|
||
cnt -= extension_payload(cnt);
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
/* new in corrigendum 14496-3:2002 */
|
||
#ifdef DRM
|
||
if (hDecoder->object_type != DRM_ER_LC)
|
||
#endif
|
||
{
|
||
faad_byte_align(ld);
|
||
}
|
||
|
||
return elements;
|
||
}
|
||
|
||
/* Table 4.4.4 and */
|
||
/* Table 4.4.9 */
|
||
static uint8_t single_lfe_channel_element(faacDecHandle hDecoder,
|
||
element *sce, bitfile *ld,
|
||
real_t *spec_coef)
|
||
{
|
||
uint8_t retval = 0;
|
||
ic_stream *ics = &(sce->ics1);
|
||
int16_t spec_data[1024];
|
||
#ifdef DRM
|
||
uint8_t result;
|
||
|
||
if (hDecoder->object_type != DRM_ER_LC)
|
||
#endif
|
||
sce->element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
|
||
DEBUGVAR(1,38,"single_lfe_channel_element(): element_instance_tag"));
|
||
|
||
#ifdef DRM
|
||
if (hDecoder->object_type == DRM_ER_LC)
|
||
{
|
||
individual_channel_stream(hDecoder, sce, ld, ics, 0, spec_data);
|
||
|
||
if (ics->tns_data_present)
|
||
tns_data(ics, &(ics->tns), ld);
|
||
|
||
if ((result = faad_check_CRC( ld, faad_get_processed_bits(ld) - 8 )) > 0)
|
||
return result;
|
||
|
||
/* error resilient spectral data decoding */
|
||
if ((result = reordered_spectral_data(hDecoder, ics, ld, spec_data)) > 0)
|
||
return result;
|
||
|
||
/* pulse coding reconstruction */
|
||
if (ics->pulse_data_present)
|
||
{
|
||
if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
if ((result = pulse_decode(ics, spec_data, hDecoder->frameLength)) > 0)
|
||
return result;
|
||
} else {
|
||
return 2; /* pulse coding not allowed for short blocks */
|
||
}
|
||
}
|
||
} else
|
||
#endif
|
||
{
|
||
retval = individual_channel_stream(hDecoder, sce, ld, ics, 0, spec_data);
|
||
if (retval > 0)
|
||
return retval;
|
||
}
|
||
|
||
|
||
/* noiseless coding is done, spectral reconstruction is done now */
|
||
|
||
/* inverse quantization */
|
||
inverse_quantization(spec_coef, spec_data, hDecoder->frameLength);
|
||
|
||
/* apply scalefactors */
|
||
apply_scalefactors(hDecoder, ics, spec_coef, hDecoder->frameLength);
|
||
|
||
/* deinterleave short block grouping */
|
||
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
quant_to_spec(ics, spec_coef, hDecoder->frameLength);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.5 */
|
||
static uint8_t channel_pair_element(faacDecHandle hDecoder, element *cpe,
|
||
bitfile *ld,
|
||
real_t *spec_coef1, real_t *spec_coef2)
|
||
{
|
||
uint8_t result;
|
||
ic_stream *ics1 = &(cpe->ics1);
|
||
ic_stream *ics2 = &(cpe->ics2);
|
||
int16_t spec_data1[1024];
|
||
int16_t spec_data2[1024];
|
||
|
||
#ifdef DRM
|
||
if (hDecoder->object_type != DRM_ER_LC)
|
||
#endif
|
||
cpe->element_instance_tag = (uint8_t)faad_getbits(ld, LEN_TAG
|
||
DEBUGVAR(1,39,"channel_pair_element(): element_instance_tag"));
|
||
|
||
if ((cpe->common_window = faad_get1bit(ld
|
||
DEBUGVAR(1,40,"channel_pair_element(): common_window"))) & 1)
|
||
{
|
||
/* both channels have common ics information */
|
||
if ((result = ics_info(hDecoder, ics1, ld, cpe->common_window)) > 0)
|
||
return result;
|
||
|
||
ics1->ms_mask_present = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,41,"channel_pair_element(): ms_mask_present"));
|
||
if (ics1->ms_mask_present == 1)
|
||
{
|
||
uint8_t g, sfb;
|
||
for (g = 0; g < ics1->num_window_groups; g++)
|
||
{
|
||
for (sfb = 0; sfb < ics1->max_sfb; sfb++)
|
||
{
|
||
ics1->ms_used[g][sfb] = faad_get1bit(ld
|
||
DEBUGVAR(1,42,"channel_pair_element(): faad_get1bit"));
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if ((hDecoder->object_type >= ER_OBJECT_START) && (ics1->predictor_data_present))
|
||
{
|
||
if ((ics1->ltp.data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
|
||
{
|
||
ltp_data(hDecoder, ics1, &(ics1->ltp), ld);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
memcpy(ics2, ics1, sizeof(ic_stream));
|
||
} else {
|
||
ics1->ms_mask_present = 0;
|
||
}
|
||
|
||
if ((result = individual_channel_stream(hDecoder, cpe, ld, ics1,
|
||
0, spec_data1)) > 0)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (cpe->common_window && (hDecoder->object_type >= ER_OBJECT_START) &&
|
||
(ics1->predictor_data_present))
|
||
{
|
||
if ((ics1->ltp2.data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,50,"channel_pair_element(): ltp.data_present"))) & 1)
|
||
{
|
||
ltp_data(hDecoder, ics1, &(ics1->ltp2), ld);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
if ((result = individual_channel_stream(hDecoder, cpe, ld, ics2,
|
||
0, spec_data2)) > 0)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
#ifdef DRM
|
||
if (hDecoder->object_type == DRM_ER_LC)
|
||
{
|
||
if (ics1->tns_data_present)
|
||
tns_data(ics1, &(ics1->tns), ld);
|
||
|
||
if (ics1->tns_data_present)
|
||
tns_data(ics2, &(ics2->tns), ld);
|
||
|
||
if ((result = faad_check_CRC( ld, faad_get_processed_bits(ld) - 8 )) > 0)
|
||
return result;
|
||
|
||
/* error resilient spectral data decoding */
|
||
if ((result = reordered_spectral_data(hDecoder, ics1, ld, spec_data1)) > 0)
|
||
return result;
|
||
if ((result = reordered_spectral_data(hDecoder, ics2, ld, spec_data2)) > 0)
|
||
return result;
|
||
/* pulse coding reconstruction */
|
||
if (ics1->pulse_data_present)
|
||
{
|
||
if (ics1->window_sequence != EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
if ((result = pulse_decode(ics1, spec_data1, hDecoder->frameLength)) > 0)
|
||
return result;
|
||
} else {
|
||
return 2; /* pulse coding not allowed for short blocks */
|
||
}
|
||
}
|
||
if (ics2->pulse_data_present)
|
||
{
|
||
if (ics2->window_sequence != EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
if ((result = pulse_decode(ics2, spec_data2, hDecoder->frameLength)) > 0)
|
||
return result;
|
||
} else {
|
||
return 2; /* pulse coding not allowed for short blocks */
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/* noiseless coding is done, spectral reconstruction is done now */
|
||
|
||
/* inverse quantization */
|
||
inverse_quantization(spec_coef1, spec_data1, hDecoder->frameLength);
|
||
inverse_quantization(spec_coef2, spec_data2, hDecoder->frameLength);
|
||
|
||
/* apply scalefactors */
|
||
apply_scalefactors(hDecoder, ics1, spec_coef1, hDecoder->frameLength);
|
||
apply_scalefactors(hDecoder, ics2, spec_coef2, hDecoder->frameLength);
|
||
|
||
/* deinterleave short block grouping */
|
||
if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
quant_to_spec(ics1, spec_coef1, hDecoder->frameLength);
|
||
if (ics2->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
quant_to_spec(ics2, spec_coef2, hDecoder->frameLength);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static uint8_t pred_sfb_max[] =
|
||
{
|
||
33, /* 96000 */
|
||
33, /* 88200 */
|
||
38, /* 64000 */
|
||
40, /* 48000 */
|
||
40, /* 44100 */
|
||
40, /* 32000 */
|
||
41, /* 24000 */
|
||
41, /* 22050 */
|
||
37, /* 16000 */
|
||
37, /* 12000 */
|
||
37, /* 11025 */
|
||
34 /* 8000 */
|
||
};
|
||
|
||
/* Table 4.4.6 */
|
||
static uint8_t ics_info(faacDecHandle hDecoder, ic_stream *ics, bitfile *ld,
|
||
uint8_t common_window)
|
||
{
|
||
uint8_t retval = 0;
|
||
|
||
/* ics->ics_reserved_bit = */ faad_get1bit(ld
|
||
DEBUGVAR(1,43,"ics_info(): ics_reserved_bit"));
|
||
ics->window_sequence = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,44,"ics_info(): window_sequence"));
|
||
ics->window_shape = faad_get1bit(ld
|
||
DEBUGVAR(1,45,"ics_info(): window_shape"));
|
||
|
||
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
ics->max_sfb = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,46,"ics_info(): max_sfb (short)"));
|
||
ics->scale_factor_grouping = (uint8_t)faad_getbits(ld, 7
|
||
DEBUGVAR(1,47,"ics_info(): scale_factor_grouping"));
|
||
} else {
|
||
ics->max_sfb = (uint8_t)faad_getbits(ld, 6
|
||
DEBUGVAR(1,48,"ics_info(): max_sfb (long)"));
|
||
}
|
||
|
||
/* get the grouping information */
|
||
if ((retval = window_grouping_info(hDecoder, ics)) > 0)
|
||
return retval;
|
||
|
||
/* should be an error */
|
||
/* check the range of max_sfb */
|
||
if (ics->max_sfb > ics->num_swb)
|
||
return 16;
|
||
|
||
if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
if ((ics->predictor_data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,49,"ics_info(): predictor_data_present"))) & 1)
|
||
{
|
||
if (hDecoder->object_type == MAIN) /* MPEG2 style AAC predictor */
|
||
{
|
||
uint8_t sfb;
|
||
|
||
ics->pred.limit = min(ics->max_sfb, pred_sfb_max[hDecoder->sf_index]);
|
||
|
||
if ((ics->pred.predictor_reset = faad_get1bit(ld
|
||
DEBUGVAR(1,53,"ics_info(): pred.predictor_reset"))) & 1)
|
||
{
|
||
ics->pred.predictor_reset_group_number = (uint8_t)faad_getbits(ld, 5
|
||
DEBUGVAR(1,54,"ics_info(): pred.predictor_reset_group_number"));
|
||
}
|
||
|
||
for (sfb = 0; sfb < ics->pred.limit; sfb++)
|
||
{
|
||
ics->pred.prediction_used[sfb] = faad_get1bit(ld
|
||
DEBUGVAR(1,55,"ics_info(): pred.prediction_used"));
|
||
}
|
||
}
|
||
#ifdef LTP_DEC
|
||
else { /* Long Term Prediction */
|
||
if (hDecoder->object_type < ER_OBJECT_START)
|
||
{
|
||
if ((ics->ltp.data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
|
||
{
|
||
ltp_data(hDecoder, ics, &(ics->ltp), ld);
|
||
}
|
||
if (common_window)
|
||
{
|
||
if ((ics->ltp2.data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,51,"ics_info(): ltp2.data_present"))) & 1)
|
||
{
|
||
ltp_data(hDecoder, ics, &(ics->ltp2), ld);
|
||
}
|
||
}
|
||
}
|
||
#ifdef ERROR_RESILIENCE
|
||
if (!common_window && (hDecoder->object_type >= ER_OBJECT_START))
|
||
{
|
||
if ((ics->ltp.data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,50,"ics_info(): ltp.data_present"))) & 1)
|
||
{
|
||
ltp_data(hDecoder, ics, &(ics->ltp), ld);
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
return retval;
|
||
}
|
||
|
||
/* Table 4.4.7 */
|
||
static uint8_t pulse_data(ic_stream *ics, pulse_info *pul, bitfile *ld)
|
||
{
|
||
uint8_t i;
|
||
|
||
pul->number_pulse = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,56,"pulse_data(): number_pulse"));
|
||
pul->pulse_start_sfb = (uint8_t)faad_getbits(ld, 6
|
||
DEBUGVAR(1,57,"pulse_data(): pulse_start_sfb"));
|
||
|
||
/* check the range of pulse_start_sfb */
|
||
if (pul->pulse_start_sfb > ics->num_swb)
|
||
return 16;
|
||
|
||
for (i = 0; i < pul->number_pulse+1; i++)
|
||
{
|
||
pul->pulse_offset[i] = (uint8_t)faad_getbits(ld, 5
|
||
DEBUGVAR(1,58,"pulse_data(): pulse_offset"));
|
||
pul->pulse_amp[i] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,59,"pulse_data(): pulse_amp"));
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.8: Currently just for skipping the bits... */
|
||
static uint8_t coupling_channel_element(faacDecHandle hDecoder, bitfile *ld)
|
||
{
|
||
uint8_t c, result = 0;
|
||
uint8_t ind_sw_cce_flag = 0;
|
||
uint8_t num_gain_element_lists = 0;
|
||
uint8_t num_coupled_elements = 0;
|
||
|
||
element el_empty;
|
||
ic_stream ics_empty;
|
||
int16_t sh_data[1024];
|
||
|
||
memset(&el_empty, 0, sizeof(element));
|
||
memset(&ics_empty, 0, sizeof(ic_stream));
|
||
|
||
c = faad_getbits(ld, LEN_TAG
|
||
DEBUGVAR(1,900,"coupling_channel_element(): element_instance_tag"));
|
||
|
||
ind_sw_cce_flag = faad_get1bit(ld
|
||
DEBUGVAR(1,901,"coupling_channel_element(): ind_sw_cce_flag"));
|
||
num_coupled_elements = faad_getbits(ld, 3
|
||
DEBUGVAR(1,902,"coupling_channel_element(): num_coupled_elements"));
|
||
|
||
for (c = 0; c < num_coupled_elements + 1; c++)
|
||
{
|
||
uint8_t cc_target_is_cpe, cc_target_tag_select;
|
||
|
||
num_gain_element_lists++;
|
||
|
||
cc_target_is_cpe = faad_get1bit(ld
|
||
DEBUGVAR(1,903,"coupling_channel_element(): cc_target_is_cpe"));
|
||
cc_target_tag_select = faad_getbits(ld, 4
|
||
DEBUGVAR(1,904,"coupling_channel_element(): cc_target_tag_select"));
|
||
|
||
if (cc_target_is_cpe)
|
||
{
|
||
uint8_t cc_l = faad_get1bit(ld
|
||
DEBUGVAR(1,905,"coupling_channel_element(): cc_l"));
|
||
uint8_t cc_r = faad_get1bit(ld
|
||
DEBUGVAR(1,906,"coupling_channel_element(): cc_r"));
|
||
|
||
if (cc_l && cc_r)
|
||
num_gain_element_lists++;
|
||
}
|
||
}
|
||
|
||
faad_get1bit(ld
|
||
DEBUGVAR(1,907,"coupling_channel_element(): cc_domain"));
|
||
faad_get1bit(ld
|
||
DEBUGVAR(1,908,"coupling_channel_element(): gain_element_sign"));
|
||
faad_getbits(ld, 2
|
||
DEBUGVAR(1,909,"coupling_channel_element(): gain_element_scale"));
|
||
|
||
if ((result = individual_channel_stream(hDecoder, &el_empty, ld, &ics_empty,
|
||
0, sh_data)) > 0)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
for (c = 1; c < num_gain_element_lists; c++)
|
||
{
|
||
uint8_t cge;
|
||
|
||
if (ind_sw_cce_flag)
|
||
{
|
||
cge = 1;
|
||
} else {
|
||
cge = faad_get1bit(ld
|
||
DEBUGVAR(1,910,"coupling_channel_element(): common_gain_element_present"));
|
||
}
|
||
|
||
if (cge)
|
||
{
|
||
huffman_scale_factor(ld);
|
||
} else {
|
||
uint8_t g, sfb;
|
||
|
||
for (g = 0; g < ics_empty.num_window_groups; g++)
|
||
{
|
||
for (sfb = 0; sfb < ics_empty.max_sfb; sfb++)
|
||
{
|
||
if (ics_empty.sfb_cb[g][sfb] != ZERO_HCB)
|
||
huffman_scale_factor(ld);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.10 */
|
||
static uint16_t data_stream_element(faacDecHandle hDecoder, bitfile *ld)
|
||
{
|
||
uint8_t byte_aligned;
|
||
uint16_t i, count;
|
||
|
||
/* element_instance_tag = */ faad_getbits(ld, LEN_TAG
|
||
DEBUGVAR(1,60,"data_stream_element(): element_instance_tag"));
|
||
byte_aligned = faad_get1bit(ld
|
||
DEBUGVAR(1,61,"data_stream_element(): byte_aligned"));
|
||
count = (uint16_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,62,"data_stream_element(): count"));
|
||
if (count == 255)
|
||
{
|
||
count += (uint16_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,63,"data_stream_element(): extra count"));
|
||
}
|
||
if (byte_aligned)
|
||
faad_byte_align(ld);
|
||
|
||
for (i = 0; i < count; i++)
|
||
{
|
||
uint8_t data = faad_getbits(ld, LEN_BYTE
|
||
DEBUGVAR(1,64,"data_stream_element(): data_stream_byte"));
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
/* Table 4.4.11 */
|
||
static uint8_t fill_element(faacDecHandle hDecoder, bitfile *ld, drc_info *drc
|
||
#ifdef SBR_DEC
|
||
,uint8_t sbr_ele
|
||
#endif
|
||
)
|
||
{
|
||
uint16_t count;
|
||
#ifdef SBR_DEC
|
||
uint8_t bs_extension_type;
|
||
#endif
|
||
|
||
count = (uint16_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,65,"fill_element(): count"));
|
||
if (count == 15)
|
||
{
|
||
count += (uint16_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,66,"fill_element(): extra count")) - 1;
|
||
}
|
||
|
||
if (count > 0)
|
||
{
|
||
#ifdef SBR_DEC
|
||
hDecoder->sbr_used[sbr_ele] = 0;
|
||
bs_extension_type = (uint8_t)faad_showbits(ld, 4);
|
||
|
||
if ((bs_extension_type == EXT_SBR_DATA) ||
|
||
(bs_extension_type == EXT_SBR_DATA_CRC))
|
||
{
|
||
hDecoder->sbr_used[sbr_ele] = 1;
|
||
|
||
if (!hDecoder->sbr[sbr_ele])
|
||
{
|
||
hDecoder->sbr[sbr_ele] = sbrDecodeInit(hDecoder->frameLength
|
||
#ifdef DRM
|
||
, 0
|
||
#endif
|
||
);
|
||
}
|
||
|
||
/* read in all the SBR data for processing later on */
|
||
hDecoder->sbr[sbr_ele]->data = (uint8_t*)faad_getbitbuffer(ld, count*8);
|
||
hDecoder->sbr[sbr_ele]->data_size = count;
|
||
} else {
|
||
hDecoder->sbr_used[sbr_ele] = 0;
|
||
#endif
|
||
while (count > 0)
|
||
{
|
||
count -= extension_payload(ld, drc, count);
|
||
}
|
||
#ifdef SBR_DEC
|
||
}
|
||
#endif
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.12 */
|
||
#ifdef SSR_DEC
|
||
static void gain_control_data(bitfile *ld, ic_stream *ics)
|
||
{
|
||
uint8_t bd, wd, ad;
|
||
ssr_info *ssr = &(ics->ssr);
|
||
|
||
ssr->max_band = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,1000,"gain_control_data(): max_band"));
|
||
|
||
if (ics->window_sequence == ONLY_LONG_SEQUENCE)
|
||
{
|
||
for (bd = 1; bd <= ssr->max_band; bd++)
|
||
{
|
||
for (wd = 0; wd < 1; wd++)
|
||
{
|
||
ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
|
||
|
||
for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
|
||
{
|
||
ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
}
|
||
}
|
||
}
|
||
} else if (ics->window_sequence == LONG_START_SEQUENCE) {
|
||
for (bd = 1; bd <= ssr->max_band; bd++)
|
||
{
|
||
for (wd = 0; wd < 2; wd++)
|
||
{
|
||
ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
|
||
|
||
for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
|
||
{
|
||
ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
|
||
if (wd == 0)
|
||
{
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
} else {
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else if (ics->window_sequence == EIGHT_SHORT_SEQUENCE) {
|
||
for (bd = 1; bd <= ssr->max_band; bd++)
|
||
{
|
||
for (wd = 0; wd < 8; wd++)
|
||
{
|
||
ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
|
||
|
||
for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
|
||
{
|
||
ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
}
|
||
}
|
||
}
|
||
} else if (ics->window_sequence == LONG_STOP_SEQUENCE) {
|
||
for (bd = 1; bd <= ssr->max_band; bd++)
|
||
{
|
||
for (wd = 0; wd < 2; wd++)
|
||
{
|
||
ssr->adjust_num[bd][wd] = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,1001,"gain_control_data(): adjust_num"));
|
||
|
||
for (ad = 0; ad < ssr->adjust_num[bd][wd]; ad++)
|
||
{
|
||
ssr->alevcode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1002,"gain_control_data(): alevcode"));
|
||
|
||
if (wd == 0)
|
||
{
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
} else {
|
||
ssr->aloccode[bd][wd][ad] = (uint8_t)faad_getbits(ld, 5
|
||
DEBUGVAR(1,1003,"gain_control_data(): aloccode"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/* Table 4.4.24 */
|
||
static uint8_t individual_channel_stream(faacDecHandle hDecoder, element *ele,
|
||
bitfile *ld, ic_stream *ics, uint8_t scal_flag,
|
||
int16_t *spec_data)
|
||
{
|
||
uint8_t result;
|
||
|
||
ics->global_gain = (uint8_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,67,"individual_channel_stream(): global_gain"));
|
||
|
||
if (!ele->common_window && !scal_flag)
|
||
{
|
||
if ((result = ics_info(hDecoder, ics, ld, ele->common_window)) > 0)
|
||
return result;
|
||
}
|
||
|
||
if ((result = section_data(hDecoder, ics, ld)) > 0)
|
||
return result;
|
||
|
||
if ((result = scale_factor_data(hDecoder, ics, ld)) > 0)
|
||
return result;
|
||
|
||
if (!scal_flag)
|
||
{
|
||
/**
|
||
** NOTE: It could be that pulse data is available in scalable AAC too,
|
||
** as said in Amendment 1, this could be only the case for ER AAC,
|
||
** though. (have to check this out later)
|
||
**/
|
||
/* get pulse data */
|
||
if ((ics->pulse_data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,68,"individual_channel_stream(): pulse_data_present"))) & 1)
|
||
{
|
||
if ((result = pulse_data(ics, &(ics->pul), ld)) > 0)
|
||
return result;
|
||
}
|
||
|
||
/* get tns data */
|
||
if ((ics->tns_data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,69,"individual_channel_stream(): tns_data_present"))) & 1)
|
||
{
|
||
#ifdef ERROR_RESILIENCE
|
||
if (hDecoder->object_type < ER_OBJECT_START)
|
||
#endif
|
||
tns_data(ics, &(ics->tns), ld);
|
||
}
|
||
|
||
/* get gain control data */
|
||
if ((ics->gain_control_data_present = faad_get1bit(ld
|
||
DEBUGVAR(1,70,"individual_channel_stream(): gain_control_data_present"))) & 1)
|
||
{
|
||
#ifdef SSR_DEC
|
||
if (hDecoder->object_type != SSR)
|
||
return 1;
|
||
else
|
||
gain_control_data(ld, ics);
|
||
#else
|
||
return 1;
|
||
#endif
|
||
}
|
||
}
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (hDecoder->aacSpectralDataResilienceFlag)
|
||
{
|
||
ics->length_of_reordered_spectral_data = (uint16_t)faad_getbits(ld, 14
|
||
DEBUGVAR(1,147,"individual_channel_stream(): length_of_reordered_spectral_data"));
|
||
|
||
if (hDecoder->channelConfiguration == 2)
|
||
{
|
||
if (ics->length_of_reordered_spectral_data > 6144)
|
||
ics->length_of_reordered_spectral_data = 6144;
|
||
} else {
|
||
if (ics->length_of_reordered_spectral_data > 12288)
|
||
ics->length_of_reordered_spectral_data = 12288;
|
||
}
|
||
|
||
ics->length_of_longest_codeword = (uint8_t)faad_getbits(ld, 6
|
||
DEBUGVAR(1,148,"individual_channel_stream(): length_of_longest_codeword"));
|
||
if (ics->length_of_longest_codeword >= 49)
|
||
ics->length_of_longest_codeword = 49;
|
||
}
|
||
|
||
/* RVLC spectral data is put here */
|
||
if (hDecoder->aacScalefactorDataResilienceFlag)
|
||
{
|
||
if ((result = rvlc_decode_scale_factors(ics, ld)) > 0)
|
||
return result;
|
||
}
|
||
|
||
#ifdef DRM
|
||
if (hDecoder->object_type == DRM_ER_LC)
|
||
return 0;
|
||
#endif
|
||
|
||
if (hDecoder->object_type >= ER_OBJECT_START)
|
||
{
|
||
if (ics->tns_data_present)
|
||
tns_data(ics, &(ics->tns), ld);
|
||
}
|
||
|
||
if (hDecoder->aacSpectralDataResilienceFlag)
|
||
{
|
||
/* error resilient spectral data decoding */
|
||
if ((result = reordered_spectral_data(hDecoder, ics, ld, spec_data)) > 0)
|
||
{
|
||
return result;
|
||
}
|
||
} else {
|
||
#endif
|
||
/* decode the spectral data */
|
||
if ((result = spectral_data(hDecoder, ics, ld, spec_data)) > 0)
|
||
{
|
||
return result;
|
||
}
|
||
#ifdef ERROR_RESILIENCE
|
||
}
|
||
#endif
|
||
|
||
/* pulse coding reconstruction */
|
||
if (ics->pulse_data_present)
|
||
{
|
||
if (ics->window_sequence != EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
if ((result = pulse_decode(ics, spec_data, hDecoder->frameLength)) > 0)
|
||
return result;
|
||
} else {
|
||
return 2; /* pulse coding not allowed for short blocks */
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.25 */
|
||
static uint8_t section_data(faacDecHandle hDecoder, ic_stream *ics, bitfile *ld)
|
||
{
|
||
uint8_t g;
|
||
uint8_t sect_esc_val, sect_bits;
|
||
|
||
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
sect_bits = 3;
|
||
else
|
||
sect_bits = 5;
|
||
sect_esc_val = (1<<sect_bits) - 1;
|
||
|
||
#if 0
|
||
printf("\ntotal sfb %d\n", ics->max_sfb);
|
||
printf(" sect top cb\n");
|
||
#endif
|
||
|
||
for (g = 0; g < ics->num_window_groups; g++)
|
||
{
|
||
uint8_t k = 0;
|
||
uint8_t i = 0;
|
||
|
||
while (k < ics->max_sfb)
|
||
{
|
||
#ifdef ERROR_RESILIENCE
|
||
uint8_t vcb11 = 0;
|
||
#endif
|
||
uint8_t sfb;
|
||
uint8_t sect_len_incr;
|
||
uint16_t sect_len = 0;
|
||
uint8_t sect_cb_bits = 4;
|
||
|
||
/* if "faad_getbits" detects error and returns "0", "k" is never
|
||
incremented and we cannot leave the while loop */
|
||
if ((ld->error != 0) || (ld->no_more_reading))
|
||
return 14;
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (hDecoder->aacSectionDataResilienceFlag)
|
||
sect_cb_bits = 5;
|
||
#endif
|
||
|
||
ics->sect_cb[g][i] = (uint8_t)faad_getbits(ld, sect_cb_bits
|
||
DEBUGVAR(1,71,"section_data(): sect_cb"));
|
||
|
||
if (ics->sect_cb[g][i] == NOISE_HCB)
|
||
ics->noise_used = 1;
|
||
|
||
#ifdef ERROR_RESILIENCE
|
||
if (hDecoder->aacSectionDataResilienceFlag)
|
||
{
|
||
if ((ics->sect_cb[g][i] == 11) ||
|
||
((ics->sect_cb[g][i] >= 16) && (ics->sect_cb[g][i] <= 32)))
|
||
{
|
||
vcb11 = 1;
|
||
}
|
||
}
|
||
if (vcb11)
|
||
{
|
||
sect_len_incr = 1;
|
||
} else {
|
||
#endif
|
||
sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
|
||
DEBUGVAR(1,72,"section_data(): sect_len_incr"));
|
||
#ifdef ERROR_RESILIENCE
|
||
}
|
||
#endif
|
||
while ((sect_len_incr == sect_esc_val) /* &&
|
||
(k+sect_len < ics->max_sfb)*/)
|
||
{
|
||
sect_len += sect_len_incr;
|
||
sect_len_incr = (uint8_t)faad_getbits(ld, sect_bits
|
||
DEBUGVAR(1,72,"section_data(): sect_len_incr"));
|
||
}
|
||
|
||
sect_len += sect_len_incr;
|
||
|
||
ics->sect_start[g][i] = k;
|
||
ics->sect_end[g][i] = k + sect_len;
|
||
|
||
if (k + sect_len >= 8*15)
|
||
return 15;
|
||
if (i >= 8*15)
|
||
return 15;
|
||
|
||
for (sfb = k; sfb < k + sect_len; sfb++)
|
||
ics->sfb_cb[g][sfb] = ics->sect_cb[g][i];
|
||
|
||
#if 0
|
||
printf(" %6d %6d %6d\n",
|
||
i,
|
||
ics->sect_end[g][i],
|
||
ics->sect_cb[g][i]);
|
||
#endif
|
||
|
||
k += sect_len;
|
||
i++;
|
||
}
|
||
ics->num_sec[g] = i;
|
||
}
|
||
|
||
#if 0
|
||
printf("\n");
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* decode_scale_factors()
|
||
* decodes the scalefactors from the bitstream
|
||
*/
|
||
/*
|
||
* All scalefactors (and also the stereo positions and pns energies) are
|
||
* transmitted using Huffman coded DPCM relative to the previous active
|
||
* scalefactor (respectively previous stereo position or previous pns energy,
|
||
* see subclause 4.6.2 and 4.6.3). The first active scalefactor is
|
||
* differentially coded relative to the global gain.
|
||
*/
|
||
static uint8_t decode_scale_factors(ic_stream *ics, bitfile *ld)
|
||
{
|
||
uint8_t g, sfb;
|
||
int16_t t;
|
||
int8_t noise_pcm_flag = 1;
|
||
|
||
int16_t scale_factor = ics->global_gain;
|
||
int16_t is_position = 0;
|
||
int16_t noise_energy = ics->global_gain - 90;
|
||
|
||
for (g = 0; g < ics->num_window_groups; g++)
|
||
{
|
||
for (sfb = 0; sfb < ics->max_sfb; sfb++)
|
||
{
|
||
switch (ics->sfb_cb[g][sfb])
|
||
{
|
||
case ZERO_HCB: /* zero book */
|
||
ics->scale_factors[g][sfb] = 0;
|
||
break;
|
||
case INTENSITY_HCB: /* intensity books */
|
||
case INTENSITY_HCB2:
|
||
|
||
/* decode intensity position */
|
||
t = huffman_scale_factor(ld);
|
||
if (t < 0)
|
||
return 9;
|
||
is_position += (t - 60);
|
||
ics->scale_factors[g][sfb] = is_position;
|
||
|
||
break;
|
||
case NOISE_HCB: /* noise books */
|
||
|
||
/* decode noise energy */
|
||
if (noise_pcm_flag)
|
||
{
|
||
noise_pcm_flag = 0;
|
||
t = (int16_t)faad_getbits(ld, 9
|
||
DEBUGVAR(1,73,"scale_factor_data(): first noise")) - 256;
|
||
} else {
|
||
t = huffman_scale_factor(ld);
|
||
if (t < 0)
|
||
return 9;
|
||
t -= 60;
|
||
}
|
||
noise_energy += t;
|
||
ics->scale_factors[g][sfb] = noise_energy;
|
||
|
||
break;
|
||
default: /* spectral books */
|
||
|
||
/* decode scale factor */
|
||
t = huffman_scale_factor(ld);
|
||
if (t < 0)
|
||
return 9;
|
||
scale_factor += (t - 60);
|
||
if (scale_factor < 0)
|
||
return 4;
|
||
ics->scale_factors[g][sfb] = scale_factor;
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.26 */
|
||
static uint8_t scale_factor_data(faacDecHandle hDecoder, ic_stream *ics, bitfile *ld)
|
||
{
|
||
#ifdef ERROR_RESILIENCE
|
||
if (!hDecoder->aacScalefactorDataResilienceFlag)
|
||
{
|
||
#endif
|
||
return decode_scale_factors(ics, ld);
|
||
#ifdef ERROR_RESILIENCE
|
||
} else {
|
||
/* In ER AAC the parameters for RVLC are seperated from the actual
|
||
data that holds the scale_factors.
|
||
Strangely enough, 2 parameters for HCR are put inbetween them.
|
||
*/
|
||
return rvlc_scale_factor_data(ics, ld);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
/* Table 4.4.27 */
|
||
static void tns_data(ic_stream *ics, tns_info *tns, bitfile *ld)
|
||
{
|
||
uint8_t w, filt, i, start_coef_bits, coef_bits;
|
||
uint8_t n_filt_bits = 2;
|
||
uint8_t length_bits = 6;
|
||
uint8_t order_bits = 5;
|
||
|
||
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
n_filt_bits = 1;
|
||
length_bits = 4;
|
||
order_bits = 3;
|
||
}
|
||
|
||
for (w = 0; w < ics->num_windows; w++)
|
||
{
|
||
tns->n_filt[w] = (uint8_t)faad_getbits(ld, n_filt_bits
|
||
DEBUGVAR(1,74,"tns_data(): n_filt"));
|
||
|
||
if (tns->n_filt[w])
|
||
{
|
||
if ((tns->coef_res[w] = faad_get1bit(ld
|
||
DEBUGVAR(1,75,"tns_data(): coef_res"))) & 1)
|
||
{
|
||
start_coef_bits = 4;
|
||
} else {
|
||
start_coef_bits = 3;
|
||
}
|
||
}
|
||
|
||
for (filt = 0; filt < tns->n_filt[w]; filt++)
|
||
{
|
||
tns->length[w][filt] = (uint8_t)faad_getbits(ld, length_bits
|
||
DEBUGVAR(1,76,"tns_data(): length"));
|
||
tns->order[w][filt] = (uint8_t)faad_getbits(ld, order_bits
|
||
DEBUGVAR(1,77,"tns_data(): order"));
|
||
if (tns->order[w][filt])
|
||
{
|
||
tns->direction[w][filt] = faad_get1bit(ld
|
||
DEBUGVAR(1,78,"tns_data(): direction"));
|
||
tns->coef_compress[w][filt] = faad_get1bit(ld
|
||
DEBUGVAR(1,79,"tns_data(): coef_compress"));
|
||
|
||
coef_bits = start_coef_bits - tns->coef_compress[w][filt];
|
||
for (i = 0; i < tns->order[w][filt]; i++)
|
||
{
|
||
tns->coef[w][filt][i] = (uint8_t)faad_getbits(ld, coef_bits
|
||
DEBUGVAR(1,80,"tns_data(): coef"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef LTP_DEC
|
||
/* Table 4.4.28 */
|
||
static void ltp_data(faacDecHandle hDecoder, ic_stream *ics, ltp_info *ltp, bitfile *ld)
|
||
{
|
||
uint8_t sfb, w;
|
||
|
||
#ifdef LD_DEC
|
||
if (hDecoder->object_type == LD)
|
||
{
|
||
ltp->lag_update = (uint8_t)faad_getbits(ld, 1
|
||
DEBUGVAR(1,142,"ltp_data(): lag_update"));
|
||
|
||
if (ltp->lag_update)
|
||
{
|
||
ltp->lag = (uint16_t)faad_getbits(ld, 10
|
||
DEBUGVAR(1,81,"ltp_data(): lag"));
|
||
}
|
||
} else {
|
||
#endif
|
||
ltp->lag = (uint16_t)faad_getbits(ld, 11
|
||
DEBUGVAR(1,81,"ltp_data(): lag"));
|
||
#ifdef LD_DEC
|
||
}
|
||
#endif
|
||
ltp->coef = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,82,"ltp_data(): coef"));
|
||
|
||
if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
||
{
|
||
for (w = 0; w < ics->num_windows; w++)
|
||
{
|
||
if ((ltp->short_used[w] = faad_get1bit(ld
|
||
DEBUGVAR(1,83,"ltp_data(): short_used"))) & 1)
|
||
{
|
||
ltp->short_lag_present[w] = faad_get1bit(ld
|
||
DEBUGVAR(1,84,"ltp_data(): short_lag_present"));
|
||
if (ltp->short_lag_present[w])
|
||
{
|
||
ltp->short_lag[w] = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,85,"ltp_data(): short_lag"));
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
ltp->last_band = (ics->max_sfb < MAX_LTP_SFB ? ics->max_sfb : MAX_LTP_SFB);
|
||
|
||
for (sfb = 0; sfb < ltp->last_band; sfb++)
|
||
{
|
||
ltp->long_used[sfb] = faad_get1bit(ld
|
||
DEBUGVAR(1,86,"ltp_data(): long_used"));
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/* Table 4.4.29 */
|
||
static uint8_t spectral_data(faacDecHandle hDecoder, ic_stream *ics, bitfile *ld,
|
||
int16_t *spectral_data)
|
||
{
|
||
int8_t i;
|
||
uint8_t g;
|
||
int16_t *sp;
|
||
uint16_t k, p = 0;
|
||
uint8_t groups = 0;
|
||
uint8_t sect_cb;
|
||
uint8_t result;
|
||
uint16_t nshort = hDecoder->frameLength/8;
|
||
|
||
sp = spectral_data;
|
||
memset(sp, 0, hDecoder->frameLength*sizeof(int16_t));
|
||
|
||
for(g = 0; g < ics->num_window_groups; g++)
|
||
{
|
||
p = groups*nshort;
|
||
|
||
for (i = 0; i < ics->num_sec[g]; i++)
|
||
{
|
||
sect_cb = ics->sect_cb[g][i];
|
||
|
||
switch (sect_cb)
|
||
{
|
||
case ZERO_HCB:
|
||
case NOISE_HCB:
|
||
case INTENSITY_HCB:
|
||
case INTENSITY_HCB2:
|
||
p += (ics->sect_sfb_offset[g][ics->sect_end[g][i]] -
|
||
ics->sect_sfb_offset[g][ics->sect_start[g][i]]);
|
||
break;
|
||
default:
|
||
for (k = ics->sect_sfb_offset[g][ics->sect_start[g][i]];
|
||
k < ics->sect_sfb_offset[g][ics->sect_end[g][i]]; k += 4)
|
||
{
|
||
sp = spectral_data + p;
|
||
|
||
if ((result = huffman_spectral_data(sect_cb, ld, sp)) > 0)
|
||
return result;
|
||
if (sect_cb >= FIRST_PAIR_HCB)
|
||
{
|
||
if ((result = huffman_spectral_data(sect_cb, ld, sp+2)) > 0)
|
||
return result;
|
||
}
|
||
p += 4;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
groups += ics->window_group_length[g];
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 4.4.30 */
|
||
static uint16_t extension_payload(bitfile *ld, drc_info *drc, uint16_t count)
|
||
{
|
||
uint16_t i, n, dataElementLength;
|
||
uint8_t dataElementLengthPart;
|
||
uint8_t align = 4, data_element_version, loopCounter;
|
||
|
||
uint8_t extension_type = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,87,"extension_payload(): extension_type"));
|
||
|
||
switch (extension_type)
|
||
{
|
||
case EXT_DYNAMIC_RANGE:
|
||
drc->present = 1;
|
||
n = dynamic_range_info(ld, drc);
|
||
return n;
|
||
case EXT_FILL_DATA:
|
||
/* fill_nibble = */ faad_getbits(ld, 4
|
||
DEBUGVAR(1,136,"extension_payload(): fill_nibble")); /* must be <20>0000<30> */
|
||
for (i = 0; i < count-1; i++)
|
||
{
|
||
/* fill_byte[i] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,88,"extension_payload(): fill_byte")); /* must be <20>10100101<30> */
|
||
}
|
||
return count;
|
||
case EXT_DATA_ELEMENT:
|
||
data_element_version = faad_getbits(ld, 4
|
||
DEBUGVAR(1,400,"extension_payload(): data_element_version"));
|
||
switch (data_element_version)
|
||
{
|
||
case ANC_DATA:
|
||
loopCounter = 0;
|
||
dataElementLength = 0;
|
||
do {
|
||
dataElementLengthPart = faad_getbits(ld, 8
|
||
DEBUGVAR(1,401,"extension_payload(): dataElementLengthPart"));
|
||
dataElementLength += dataElementLengthPart;
|
||
loopCounter++;
|
||
} while (dataElementLengthPart == 255);
|
||
|
||
for (i = 0; i < dataElementLength; i++)
|
||
{
|
||
/* data_element_byte[i] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,402,"extension_payload(): data_element_byte"));
|
||
return (dataElementLength+loopCounter+1);
|
||
}
|
||
default:
|
||
align = 0;
|
||
}
|
||
case EXT_FIL:
|
||
default:
|
||
faad_getbits(ld, align
|
||
DEBUGVAR(1,88,"extension_payload(): fill_nibble"));
|
||
for (i = 0; i < count-1; i++)
|
||
{
|
||
/* other_bits[i] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,89,"extension_payload(): fill_bit"));
|
||
}
|
||
return count;
|
||
}
|
||
}
|
||
|
||
/* Table 4.4.31 */
|
||
static uint8_t dynamic_range_info(bitfile *ld, drc_info *drc)
|
||
{
|
||
uint8_t i, n = 1;
|
||
uint8_t band_incr;
|
||
|
||
drc->num_bands = 1;
|
||
|
||
if (faad_get1bit(ld
|
||
DEBUGVAR(1,90,"dynamic_range_info(): has instance_tag")) & 1)
|
||
{
|
||
drc->pce_instance_tag = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,91,"dynamic_range_info(): pce_instance_tag"));
|
||
/* drc->drc_tag_reserved_bits = */ faad_getbits(ld, 4
|
||
DEBUGVAR(1,92,"dynamic_range_info(): drc_tag_reserved_bits"));
|
||
n++;
|
||
}
|
||
|
||
drc->excluded_chns_present = faad_get1bit(ld
|
||
DEBUGVAR(1,93,"dynamic_range_info(): excluded_chns_present"));
|
||
if (drc->excluded_chns_present == 1)
|
||
{
|
||
n += excluded_channels(ld, drc);
|
||
}
|
||
|
||
if (faad_get1bit(ld
|
||
DEBUGVAR(1,94,"dynamic_range_info(): has bands data")) & 1)
|
||
{
|
||
band_incr = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,95,"dynamic_range_info(): band_incr"));
|
||
/* drc->drc_bands_reserved_bits = */ faad_getbits(ld, 4
|
||
DEBUGVAR(1,96,"dynamic_range_info(): drc_bands_reserved_bits"));
|
||
n++;
|
||
drc->num_bands += band_incr;
|
||
|
||
for (i = 0; i < drc->num_bands; i++);
|
||
{
|
||
drc->band_top[i] = (uint8_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,97,"dynamic_range_info(): band_top"));
|
||
n++;
|
||
}
|
||
}
|
||
|
||
if (faad_get1bit(ld
|
||
DEBUGVAR(1,98,"dynamic_range_info(): has prog_ref_level")) & 1)
|
||
{
|
||
drc->prog_ref_level = (uint8_t)faad_getbits(ld, 7
|
||
DEBUGVAR(1,99,"dynamic_range_info(): prog_ref_level"));
|
||
/* drc->prog_ref_level_reserved_bits = */ faad_get1bit(ld
|
||
DEBUGVAR(1,100,"dynamic_range_info(): prog_ref_level_reserved_bits"));
|
||
n++;
|
||
}
|
||
|
||
for (i = 0; i < drc->num_bands; i++)
|
||
{
|
||
drc->dyn_rng_sgn[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,101,"dynamic_range_info(): dyn_rng_sgn"));
|
||
drc->dyn_rng_ctl[i] = (uint8_t)faad_getbits(ld, 7
|
||
DEBUGVAR(1,102,"dynamic_range_info(): dyn_rng_ctl"));
|
||
n++;
|
||
}
|
||
|
||
return n;
|
||
}
|
||
|
||
/* Table 4.4.32 */
|
||
static uint8_t excluded_channels(bitfile *ld, drc_info *drc)
|
||
{
|
||
uint8_t i, n = 0;
|
||
uint8_t num_excl_chan = 7;
|
||
|
||
for (i = 0; i < 7; i++)
|
||
{
|
||
drc->exclude_mask[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,103,"excluded_channels(): exclude_mask"));
|
||
}
|
||
n++;
|
||
|
||
while ((drc->additional_excluded_chns[n-1] = faad_get1bit(ld
|
||
DEBUGVAR(1,104,"excluded_channels(): additional_excluded_chns"))) == 1)
|
||
{
|
||
for (i = num_excl_chan; i < num_excl_chan+7; i++)
|
||
{
|
||
drc->exclude_mask[i] = faad_get1bit(ld
|
||
DEBUGVAR(1,105,"excluded_channels(): exclude_mask"));
|
||
}
|
||
n++;
|
||
num_excl_chan += 7;
|
||
}
|
||
|
||
return n;
|
||
}
|
||
|
||
/* Annex A: Audio Interchange Formats */
|
||
|
||
/* Table 1.A.2 */
|
||
void get_adif_header(adif_header *adif, bitfile *ld)
|
||
{
|
||
uint8_t i;
|
||
|
||
/* adif_id[0] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,106,"get_adif_header(): adif_id[0]"));
|
||
/* adif_id[1] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,107,"get_adif_header(): adif_id[1]"));
|
||
/* adif_id[2] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,108,"get_adif_header(): adif_id[2]"));
|
||
/* adif_id[3] = */ faad_getbits(ld, 8
|
||
DEBUGVAR(1,109,"get_adif_header(): adif_id[3]"));
|
||
adif->copyright_id_present = faad_get1bit(ld
|
||
DEBUGVAR(1,110,"get_adif_header(): copyright_id_present"));
|
||
if(adif->copyright_id_present)
|
||
{
|
||
for (i = 0; i < 72/8; i++)
|
||
{
|
||
adif->copyright_id[i] = (int8_t)faad_getbits(ld, 8
|
||
DEBUGVAR(1,111,"get_adif_header(): copyright_id"));
|
||
}
|
||
adif->copyright_id[i] = 0;
|
||
}
|
||
adif->original_copy = faad_get1bit(ld
|
||
DEBUGVAR(1,112,"get_adif_header(): original_copy"));
|
||
adif->home = faad_get1bit(ld
|
||
DEBUGVAR(1,113,"get_adif_header(): home"));
|
||
adif->bitstream_type = faad_get1bit(ld
|
||
DEBUGVAR(1,114,"get_adif_header(): bitstream_type"));
|
||
adif->bitrate = faad_getbits(ld, 23
|
||
DEBUGVAR(1,115,"get_adif_header(): bitrate"));
|
||
adif->num_program_config_elements = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,116,"get_adif_header(): num_program_config_elements"));
|
||
|
||
for (i = 0; i < adif->num_program_config_elements + 1; i++)
|
||
{
|
||
if(adif->bitstream_type == 0)
|
||
{
|
||
adif->adif_buffer_fullness = faad_getbits(ld, 20
|
||
DEBUGVAR(1,117,"get_adif_header(): adif_buffer_fullness"));
|
||
} else {
|
||
adif->adif_buffer_fullness = 0;
|
||
}
|
||
|
||
program_config_element(&adif->pce[i], ld);
|
||
}
|
||
}
|
||
|
||
/* Table 1.A.5 */
|
||
uint8_t adts_frame(adts_header *adts, bitfile *ld)
|
||
{
|
||
/* faad_byte_align(ld); */
|
||
if (adts_fixed_header(adts, ld))
|
||
return 5;
|
||
adts_variable_header(adts, ld);
|
||
adts_error_check(adts, ld);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 1.A.6 */
|
||
static uint8_t adts_fixed_header(adts_header *adts, bitfile *ld)
|
||
{
|
||
uint16_t i;
|
||
uint8_t sync_err = 1;
|
||
|
||
/* try to recover from sync errors */
|
||
for (i = 0; i < 768; i++)
|
||
{
|
||
adts->syncword = (uint16_t)faad_showbits(ld, 12);
|
||
if (adts->syncword != 0xFFF)
|
||
{
|
||
faad_getbits(ld, 8
|
||
DEBUGVAR(0,0,""));
|
||
} else {
|
||
sync_err = 0;
|
||
faad_getbits(ld, 12
|
||
DEBUGVAR(1,118,"adts_fixed_header(): syncword"));
|
||
break;
|
||
}
|
||
}
|
||
if (sync_err)
|
||
return 5;
|
||
|
||
adts->id = faad_get1bit(ld
|
||
DEBUGVAR(1,119,"adts_fixed_header(): id"));
|
||
adts->layer = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,120,"adts_fixed_header(): layer"));
|
||
adts->protection_absent = faad_get1bit(ld
|
||
DEBUGVAR(1,121,"adts_fixed_header(): protection_absent"));
|
||
adts->profile = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,122,"adts_fixed_header(): profile"));
|
||
adts->sf_index = (uint8_t)faad_getbits(ld, 4
|
||
DEBUGVAR(1,123,"adts_fixed_header(): sf_index"));
|
||
adts->private_bit = faad_get1bit(ld
|
||
DEBUGVAR(1,124,"adts_fixed_header(): private_bit"));
|
||
adts->channel_configuration = (uint8_t)faad_getbits(ld, 3
|
||
DEBUGVAR(1,125,"adts_fixed_header(): channel_configuration"));
|
||
adts->original = faad_get1bit(ld
|
||
DEBUGVAR(1,126,"adts_fixed_header(): original"));
|
||
adts->home = faad_get1bit(ld
|
||
DEBUGVAR(1,127,"adts_fixed_header(): home"));
|
||
|
||
if (adts->old_format == 1)
|
||
{
|
||
/* Removed in corrigendum 14496-3:2002 */
|
||
if (adts->id == 0)
|
||
{
|
||
adts->emphasis = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,128,"adts_fixed_header(): emphasis"));
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Table 1.A.7 */
|
||
static void adts_variable_header(adts_header *adts, bitfile *ld)
|
||
{
|
||
adts->copyright_identification_bit = faad_get1bit(ld
|
||
DEBUGVAR(1,129,"adts_variable_header(): copyright_identification_bit"));
|
||
adts->copyright_identification_start = faad_get1bit(ld
|
||
DEBUGVAR(1,130,"adts_variable_header(): copyright_identification_start"));
|
||
adts->aac_frame_length = (uint16_t)faad_getbits(ld, 13
|
||
DEBUGVAR(1,131,"adts_variable_header(): aac_frame_length"));
|
||
adts->adts_buffer_fullness = (uint16_t)faad_getbits(ld, 11
|
||
DEBUGVAR(1,132,"adts_variable_header(): adts_buffer_fullness"));
|
||
adts->no_raw_data_blocks_in_frame = (uint8_t)faad_getbits(ld, 2
|
||
DEBUGVAR(1,133,"adts_variable_header(): no_raw_data_blocks_in_frame"));
|
||
}
|
||
|
||
/* Table 1.A.8 */
|
||
static void adts_error_check(adts_header *adts, bitfile *ld)
|
||
{
|
||
if (adts->protection_absent == 0)
|
||
{
|
||
adts->crc_check = (uint16_t)faad_getbits(ld, 16
|
||
DEBUGVAR(1,134,"adts_error_check(): crc_check"));
|
||
}
|
||
}
|