src/pack_ldac.c - platform/external/libldac - Git at Google

 /*
  * Copyright (C) 2003 - 2016 Sony Corporation
  *
  * 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.
  */

 #include "ldac.h"

 /***************************************************************************************************
     Pack and Store from MSB
 ***************************************************************************************************/
 static void pack_store_ldac(
 int idata,
 int nbits,
 STREAM *p_block,
 int *p_loc)
 {
     STREAM *p_bufptr;
     register int bpos;
     register unsigned int tmp;

     p_bufptr = p_block + (*p_loc >> LDAC_LOC_SHIFT);
     bpos = *p_loc & LDAC_LOC_MASK;

     tmp = (idata << (24-nbits)) & 0xffffff;
     tmp >>= bpos;
     *p_bufptr++ |= (tmp>>16);
     *p_bufptr++ = (tmp>>8) & 0xff;
     *p_bufptr = tmp & 0xff;

     *p_loc += nbits;

     return;
 }


 /***************************************************************************************************
     Pack Frame Header
 ***************************************************************************************************/
 DECLFUNC void pack_frame_header_ldac(
 int smplrate_id,
 int chconfig_id,
 int frame_length,
 int frame_status,
 STREAM *p_stream)
 {
     int loc = 0;

     pack_store_ldac(LDAC_SYNCWORD, LDAC_SYNCWORDBITS, p_stream, &loc);

     pack_store_ldac(smplrate_id, LDAC_SMPLRATEBITS, p_stream, &loc);

     pack_store_ldac(chconfig_id, LDAC_CHCONFIG2BITS, p_stream, &loc);

     pack_store_ldac(frame_length-1, LDAC_FRAMELEN2BITS, p_stream, &loc);

     pack_store_ldac(frame_status, LDAC_FRAMESTATBITS, p_stream, &loc);

     return;
 }

 /***************************************************************************************************
     Pack Frame Alignment
 ***************************************************************************************************/
 static void pack_frame_alignment_ldac(
 STREAM *p_stream,
 int *p_loc,
 int nbytes_frame)
 {
     int i;
     int nbytes_filled;

     nbytes_filled = nbytes_frame - *p_loc / LDAC_BYTESIZE;

     for (i = 0; i < nbytes_filled; i++) {
         pack_store_ldac(LDAC_FILLCODE, LDAC_BYTESIZE, p_stream, p_loc);
     }

     return;
 }

 /***************************************************************************************************
     Pack Byte Alignment
 ***************************************************************************************************/
 #define pack_block_alignment_ldac(p_stream, p_loc) pack_byte_alignment_ldac((p_stream), (p_loc))

 static void pack_byte_alignment_ldac(
 STREAM *p_stream,
 int *p_loc)
 {
     int nbits_padding;

     nbits_padding = ((*p_loc + LDAC_BYTESIZE - 1) / LDAC_BYTESIZE) * LDAC_BYTESIZE - *p_loc;

     if (nbits_padding > 0) {
         pack_store_ldac(0, nbits_padding, p_stream, p_loc);
     }

     return;
 }

 /***************************************************************************************************
     Pack Band Info
 ***************************************************************************************************/
 static void pack_band_info_ldac(
 AB *p_ab,
 STREAM *p_stream,
 int *p_loc)
 {
     pack_store_ldac(p_ab->nbands-LDAC_BAND_OFFSET, LDAC_NBANDBITS, p_stream, p_loc);

     pack_store_ldac(LDAC_FALSE, LDAC_FLAGBITS, p_stream, p_loc);

     return;
 }

 /***************************************************************************************************
     Pack Gradient Data
 ***************************************************************************************************/
 static void pack_gradient_ldac(
 AB *p_ab,
 STREAM *p_stream,
 int *p_loc)
 {
     pack_store_ldac(p_ab->grad_mode, LDAC_GRADMODEBITS, p_stream, p_loc);

     if (p_ab->grad_mode == LDAC_MODE_0) {
         pack_store_ldac(p_ab->grad_qu_l, LDAC_GRADQU0BITS, p_stream, p_loc);

         pack_store_ldac(p_ab->grad_qu_h-1, LDAC_GRADQU0BITS, p_stream, p_loc);

         pack_store_ldac(p_ab->grad_os_l, LDAC_GRADOSBITS, p_stream, p_loc);

         pack_store_ldac(p_ab->grad_os_h, LDAC_GRADOSBITS, p_stream, p_loc);
     }
     else {
         pack_store_ldac(p_ab->grad_qu_l, LDAC_GRADQU1BITS, p_stream, p_loc);

         pack_store_ldac(p_ab->grad_os_l, LDAC_GRADOSBITS, p_stream, p_loc);
     }

     pack_store_ldac(p_ab->nadjqus, LDAC_NADJQUBITS, p_stream, p_loc);

     return;
 }

 /***************************************************************************************************
     Subfunction: Pack Scale Factor Data - Mode 0
 ***************************************************************************************************/
 static void pack_scale_factor_0_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     HCENC *p_hcsf;
     int iqu;
     int nqus = p_ac->p_ab->nqus;
     int dif, val0, val1;
     const unsigned char *p_tbl;

     pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_0, LDAC_SFCBLENBITS, p_stream, p_loc);

     pack_store_ldac(p_ac->sfc_offset, LDAC_IDSFBITS, p_stream, p_loc);

     pack_store_ldac(p_ac->sfc_weight, LDAC_SFCWTBLBITS, p_stream, p_loc);

     p_tbl = gaa_sfcwgt_ldac[p_ac->sfc_weight];
     val0 = p_ac->a_idsf[0] + p_tbl[0];

     pack_store_ldac(val0-p_ac->sfc_offset, p_ac->sfc_bitlen, p_stream, p_loc);

     p_hcsf = ga_hcenc_sf0_ldac + (p_ac->sfc_bitlen-LDAC_MINSFCBLEN_0);
     for (iqu = 1; iqu < nqus; iqu++) {
         val1 = p_ac->a_idsf[iqu] + p_tbl[iqu];
         dif = (val1 - val0) & p_hcsf->mask;
         pack_store_ldac(hc_word_ldac(p_hcsf->p_tbl+dif), hc_len_ldac(p_hcsf->p_tbl+dif), p_stream, p_loc);
         val0 = val1;
     }

     return;
 }

 /***************************************************************************************************
     Subfunction: Pack Scale Factor Data - Mode 1
 ***************************************************************************************************/
 static void pack_scale_factor_1_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     int iqu;
     int nqus = p_ac->p_ab->nqus;
     const unsigned char *p_tbl;

     pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_1, LDAC_SFCBLENBITS, p_stream, p_loc);

     if (p_ac->sfc_bitlen > 4) {
         for (iqu = 0; iqu < nqus; iqu++) {
             pack_store_ldac(p_ac->a_idsf[iqu], LDAC_IDSFBITS, p_stream, p_loc);
         }
     }
     else {
         pack_store_ldac(p_ac->sfc_offset, LDAC_IDSFBITS, p_stream, p_loc);

         pack_store_ldac(p_ac->sfc_weight, LDAC_SFCWTBLBITS, p_stream, p_loc);

         p_tbl = gaa_sfcwgt_ldac[p_ac->sfc_weight];
         for (iqu = 0; iqu < nqus; iqu++) {
             pack_store_ldac(p_ac->a_idsf[iqu]+p_tbl[iqu]-p_ac->sfc_offset, p_ac->sfc_bitlen, p_stream, p_loc);
         }
     }

     return;
 }

 /***************************************************************************************************
     Subfunction: Pack Scale Factor Data - Mode 2
 ***************************************************************************************************/
 static void pack_scale_factor_2_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     HCENC *p_hcsf;
     int iqu;
     int nqus = p_ac->p_ab->nqus;
     int dif;

     pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_2, LDAC_SFCBLENBITS, p_stream, p_loc);

     p_hcsf = ga_hcenc_sf1_ldac + (p_ac->sfc_bitlen-LDAC_MINSFCBLEN_2);
     for (iqu = 0; iqu < nqus; iqu++) {
         dif = (p_ac->a_idsf[iqu] - p_ac->p_ab->ap_ac[0]->a_idsf[iqu]) & p_hcsf->mask;
         pack_store_ldac(hc_word_ldac(p_hcsf->p_tbl+dif), hc_len_ldac(p_hcsf->p_tbl+dif), p_stream, p_loc);
     }

     return;
 }

 /***************************************************************************************************
     Pack Scale Factor Data
 ***************************************************************************************************/
 static void pack_scale_factor_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     int sfc_mode = p_ac->sfc_mode;

     pack_store_ldac(sfc_mode, LDAC_SFCMODEBITS, p_stream, p_loc);

     if (p_ac->ich == 0) {
         if (sfc_mode == LDAC_MODE_0) {
             pack_scale_factor_0_ldac(p_ac, p_stream, p_loc);
         }
         else {
             pack_scale_factor_1_ldac(p_ac, p_stream, p_loc);
         }
     }
     else {
         if (sfc_mode == LDAC_MODE_0) {
             pack_scale_factor_0_ldac(p_ac, p_stream, p_loc);
         }
         else {
             pack_scale_factor_2_ldac(p_ac, p_stream, p_loc);
         }
     }

     return;
 }

 /***************************************************************************************************
     Pack Spectrum Data
 ***************************************************************************************************/
 static void pack_spectrum_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     int iqu, isp, i;
     int lsp, hsp;
     int nqus = p_ac->p_ab->nqus;
     int nsps, idwl1, wl, val;

     for (iqu = 0; iqu < nqus; iqu++) {
         lsp = ga_isp_ldac[iqu];
         hsp = ga_isp_ldac[iqu+1];
         nsps = ga_nsps_ldac[iqu];
         idwl1 = p_ac->a_idwl1[iqu];
         wl = ga_wl_ldac[idwl1];

         if (idwl1 == 1) {
             isp = lsp;

             if (nsps == 2) {
                 val  = (p_ac->a_qspec[isp  ]+1) << 2;
                 val += (p_ac->a_qspec[isp+1]+1);
                 pack_store_ldac(ga_2dimenc_spec_ldac[val], LDAC_2DIMSPECBITS, p_stream, p_loc);
             }
             else {
                 for (i = 0; i < nsps>>2; i++, isp+=4) {
                     val  = (p_ac->a_qspec[isp  ]+1) << 6;
                     val += (p_ac->a_qspec[isp+1]+1) << 4;
                     val += (p_ac->a_qspec[isp+2]+1) << 2;
                     val += (p_ac->a_qspec[isp+3]+1);
                     pack_store_ldac(ga_4dimenc_spec_ldac[val], LDAC_4DIMSPECBITS, p_stream, p_loc);
                 }
             }
         }
         else {
             for (isp = lsp; isp < hsp; isp++) {
                 pack_store_ldac(p_ac->a_qspec[isp], wl, p_stream, p_loc);
             }
         }
     }

     return;
 }

 /***************************************************************************************************
     Pack Residual Data
 ***************************************************************************************************/
 static void pack_residual_ldac(
 AC *p_ac,
 STREAM *p_stream,
 int *p_loc)
 {
     int iqu, isp;
     int lsp, hsp;
     int nqus = p_ac->p_ab->nqus;
     int idwl2, wl;

     for (iqu = 0; iqu < nqus; iqu++) {
         idwl2 = p_ac->a_idwl2[iqu];

         if (idwl2 > 0) {
             lsp = ga_isp_ldac[iqu];
             hsp = ga_isp_ldac[iqu+1];
             wl = ga_wl_ldac[idwl2];

             for (isp = lsp; isp < hsp; isp++) {
                 pack_store_ldac(p_ac->a_rspec[isp], wl, p_stream, p_loc);
             }
         }
     }

     return;
 }

 /***************************************************************************************************
     Pack Audio Block
 ***************************************************************************************************/
 static int pack_audio_block_ldac(
 AB *p_ab,
 STREAM *p_stream,
 int *p_loc)
 {
     AC *p_ac;
     int ich;
     int nchs = p_ab->blk_nchs;
     int nbits_band, nbits_grad, a_nbits_scfc[2], a_nbits_spec[2], nbits_used;
     int loc;

     for (ich = 0; ich < 2; ich++) {
         a_nbits_scfc[ich] = 0;
         a_nbits_spec[ich] = 0;
     }

     loc = *p_loc;
     pack_band_info_ldac(p_ab, p_stream, p_loc);
     nbits_band = *p_loc - loc;

     loc = *p_loc;
     pack_gradient_ldac(p_ab, p_stream, p_loc);
     nbits_grad = *p_loc - loc;

     nbits_used = nbits_band + nbits_grad;

     for (ich = 0; ich < nchs; ich++) {
         p_ac = p_ab->ap_ac[ich];

         loc = *p_loc;
         pack_scale_factor_ldac(p_ac, p_stream, p_loc);
         a_nbits_scfc[ich] = *p_loc - loc;

         loc = *p_loc;
         pack_spectrum_ldac(p_ac, p_stream, p_loc);
         a_nbits_spec[ich] = *p_loc - loc;

         loc = *p_loc;
         pack_residual_ldac(p_ac, p_stream, p_loc);
         a_nbits_spec[ich] += *p_loc - loc;

         nbits_used += a_nbits_scfc[ich] + a_nbits_spec[ich];
     }

     if (nbits_used > p_ab->nbits_used) {
         *p_ab->p_error_code = LDAC_ERR_BIT_PACKING;
         return LDAC_FALSE;
     }
     else if (nbits_used < p_ab->nbits_used) {
         *p_ab->p_error_code = LDAC_ERR_BIT_PACKING;
         return LDAC_FALSE;
     }

     return LDAC_TRUE;
 }

 /***************************************************************************************************
     Pack Raw Data Frame
 ***************************************************************************************************/
 DECLFUNC int pack_raw_data_frame_ldac(
 SFINFO *p_sfinfo,
 STREAM *p_stream,
 int *p_loc,
 int *p_nbytes_used)
 {
     CFG *p_cfg = &p_sfinfo->cfg;
     AB *p_ab = p_sfinfo->p_ab;
     int ibk;
     int nbks = gaa_block_setting_ldac[p_cfg->chconfig_id][1];

     for (ibk = 0; ibk < nbks; ibk++) {
         if (!pack_audio_block_ldac(p_ab, p_stream, p_loc)) {
             return LDAC_ERR_PACK_BLOCK_FAILED;
         }

         pack_block_alignment_ldac(p_stream, p_loc);

         p_ab++;
     }

     pack_frame_alignment_ldac(p_stream, p_loc, p_cfg->frame_length);

     *p_nbytes_used = *p_loc / LDAC_BYTESIZE;

     return LDAC_ERR_NONE;
 }

 /***************************************************************************************************
     Pack Null Data Frame
 ***************************************************************************************************/
 static const int sa_null_data_size_ldac[2] = {
     11, 15,
 };
 static const STREAM saa_null_data_ldac[2][15] = {
     {0x07, 0xa0, 0x16, 0x00, 0x20, 0xad, 0x51, 0x45, 0x14, 0x50, 0x49},
     {0x07, 0xa0, 0x0a, 0x00, 0x20, 0xad, 0x51, 0x41, 0x24, 0x93, 0x00, 0x28, 0xa0, 0x92, 0x49},
 };

 DECLFUNC int pack_null_data_frame_ldac(
 SFINFO *p_sfinfo,
 STREAM *p_stream,
 int *p_loc,
 int *p_nbytes_used)
 {
     CFG *p_cfg = &p_sfinfo->cfg;
     AB *p_ab = p_sfinfo->p_ab;
     int ibk;
     int nbks = gaa_block_setting_ldac[p_cfg->chconfig_id][1];
     int blk_type, size, offset = 0;

     for (ibk = 0; ibk < nbks; ibk++) {
         blk_type = p_ab->blk_type;
         size = sa_null_data_size_ldac[blk_type];

         copy_data_ldac(saa_null_data_ldac[blk_type], p_stream+offset, size*sizeof(STREAM));
         *p_loc += size*LDAC_BYTESIZE;

         offset += size;
         p_ab++;
     }
     if (p_cfg->frame_length < offset) {
         return LDAC_ERR_PACK_BLOCK_FAILED;
     }

     pack_frame_alignment_ldac(p_stream, p_loc, p_cfg->frame_length);

     *p_nbytes_used = *p_loc / LDAC_BYTESIZE;

     return LDAC_ERR_NONE;
 }
	/*
	* Copyright (C) 2003 - 2016 Sony Corporation
	*
	* 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.
	*/

	#include "ldac.h"

	/***************************************************************************************************
	Pack and Store from MSB
	***************************************************************************************************/
	static void pack_store_ldac(
	int idata,
	int nbits,
	STREAM *p_block,
	int *p_loc)
	{
	STREAM *p_bufptr;
	register int bpos;
	register unsigned int tmp;

	p_bufptr = p_block + (*p_loc >> LDAC_LOC_SHIFT);
	bpos = *p_loc & LDAC_LOC_MASK;

	tmp = (idata << (24-nbits)) & 0xffffff;
	tmp >>= bpos;
	*p_bufptr++ \|= (tmp>>16);
	*p_bufptr++ = (tmp>>8) & 0xff;
	*p_bufptr = tmp & 0xff;

	*p_loc += nbits;

	return;
	}


	/***************************************************************************************************
	Pack Frame Header
	***************************************************************************************************/
	DECLFUNC void pack_frame_header_ldac(
	int smplrate_id,
	int chconfig_id,
	int frame_length,
	int frame_status,
	STREAM *p_stream)
	{
	int loc = 0;

	pack_store_ldac(LDAC_SYNCWORD, LDAC_SYNCWORDBITS, p_stream, &loc);

	pack_store_ldac(smplrate_id, LDAC_SMPLRATEBITS, p_stream, &loc);

	pack_store_ldac(chconfig_id, LDAC_CHCONFIG2BITS, p_stream, &loc);

	pack_store_ldac(frame_length-1, LDAC_FRAMELEN2BITS, p_stream, &loc);

	pack_store_ldac(frame_status, LDAC_FRAMESTATBITS, p_stream, &loc);

	return;
	}

	/***************************************************************************************************
	Pack Frame Alignment
	***************************************************************************************************/
	static void pack_frame_alignment_ldac(
	STREAM *p_stream,
	int *p_loc,
	int nbytes_frame)
	{
	int i;
	int nbytes_filled;

	nbytes_filled = nbytes_frame - *p_loc / LDAC_BYTESIZE;

	for (i = 0; i < nbytes_filled; i++) {
	pack_store_ldac(LDAC_FILLCODE, LDAC_BYTESIZE, p_stream, p_loc);
	}

	return;
	}

	/***************************************************************************************************
	Pack Byte Alignment
	***************************************************************************************************/
	#define pack_block_alignment_ldac(p_stream, p_loc) pack_byte_alignment_ldac((p_stream), (p_loc))

	static void pack_byte_alignment_ldac(
	STREAM *p_stream,
	int *p_loc)
	{
	int nbits_padding;

	nbits_padding = ((p_loc + LDAC_BYTESIZE - 1) / LDAC_BYTESIZE) LDAC_BYTESIZE - *p_loc;

	if (nbits_padding > 0) {
	pack_store_ldac(0, nbits_padding, p_stream, p_loc);
	}

	return;
	}

	/***************************************************************************************************
	Pack Band Info
	***************************************************************************************************/
	static void pack_band_info_ldac(
	AB *p_ab,
	STREAM *p_stream,
	int *p_loc)
	{
	pack_store_ldac(p_ab->nbands-LDAC_BAND_OFFSET, LDAC_NBANDBITS, p_stream, p_loc);

	pack_store_ldac(LDAC_FALSE, LDAC_FLAGBITS, p_stream, p_loc);

	return;
	}

	/***************************************************************************************************
	Pack Gradient Data
	***************************************************************************************************/
	static void pack_gradient_ldac(
	AB *p_ab,
	STREAM *p_stream,
	int *p_loc)
	{
	pack_store_ldac(p_ab->grad_mode, LDAC_GRADMODEBITS, p_stream, p_loc);

	if (p_ab->grad_mode == LDAC_MODE_0) {
	pack_store_ldac(p_ab->grad_qu_l, LDAC_GRADQU0BITS, p_stream, p_loc);

	pack_store_ldac(p_ab->grad_qu_h-1, LDAC_GRADQU0BITS, p_stream, p_loc);

	pack_store_ldac(p_ab->grad_os_l, LDAC_GRADOSBITS, p_stream, p_loc);

	pack_store_ldac(p_ab->grad_os_h, LDAC_GRADOSBITS, p_stream, p_loc);
	}
	else {
	pack_store_ldac(p_ab->grad_qu_l, LDAC_GRADQU1BITS, p_stream, p_loc);

	pack_store_ldac(p_ab->grad_os_l, LDAC_GRADOSBITS, p_stream, p_loc);
	}

	pack_store_ldac(p_ab->nadjqus, LDAC_NADJQUBITS, p_stream, p_loc);

	return;
	}

	/***************************************************************************************************
	Subfunction: Pack Scale Factor Data - Mode 0
	***************************************************************************************************/
	static void pack_scale_factor_0_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	HCENC *p_hcsf;
	int iqu;
	int nqus = p_ac->p_ab->nqus;
	int dif, val0, val1;
	const unsigned char *p_tbl;

	pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_0, LDAC_SFCBLENBITS, p_stream, p_loc);

	pack_store_ldac(p_ac->sfc_offset, LDAC_IDSFBITS, p_stream, p_loc);

	pack_store_ldac(p_ac->sfc_weight, LDAC_SFCWTBLBITS, p_stream, p_loc);

	p_tbl = gaa_sfcwgt_ldac[p_ac->sfc_weight];
	val0 = p_ac->a_idsf[0] + p_tbl[0];

	pack_store_ldac(val0-p_ac->sfc_offset, p_ac->sfc_bitlen, p_stream, p_loc);

	p_hcsf = ga_hcenc_sf0_ldac + (p_ac->sfc_bitlen-LDAC_MINSFCBLEN_0);
	for (iqu = 1; iqu < nqus; iqu++) {
	val1 = p_ac->a_idsf[iqu] + p_tbl[iqu];
	dif = (val1 - val0) & p_hcsf->mask;
	pack_store_ldac(hc_word_ldac(p_hcsf->p_tbl+dif), hc_len_ldac(p_hcsf->p_tbl+dif), p_stream, p_loc);
	val0 = val1;
	}

	return;
	}

	/***************************************************************************************************
	Subfunction: Pack Scale Factor Data - Mode 1
	***************************************************************************************************/
	static void pack_scale_factor_1_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	int iqu;
	int nqus = p_ac->p_ab->nqus;
	const unsigned char *p_tbl;

	pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_1, LDAC_SFCBLENBITS, p_stream, p_loc);

	if (p_ac->sfc_bitlen > 4) {
	for (iqu = 0; iqu < nqus; iqu++) {
	pack_store_ldac(p_ac->a_idsf[iqu], LDAC_IDSFBITS, p_stream, p_loc);
	}
	}
	else {
	pack_store_ldac(p_ac->sfc_offset, LDAC_IDSFBITS, p_stream, p_loc);

	pack_store_ldac(p_ac->sfc_weight, LDAC_SFCWTBLBITS, p_stream, p_loc);

	p_tbl = gaa_sfcwgt_ldac[p_ac->sfc_weight];
	for (iqu = 0; iqu < nqus; iqu++) {
	pack_store_ldac(p_ac->a_idsf[iqu]+p_tbl[iqu]-p_ac->sfc_offset, p_ac->sfc_bitlen, p_stream, p_loc);
	}
	}

	return;
	}

	/***************************************************************************************************
	Subfunction: Pack Scale Factor Data - Mode 2
	***************************************************************************************************/
	static void pack_scale_factor_2_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	HCENC *p_hcsf;
	int iqu;
	int nqus = p_ac->p_ab->nqus;
	int dif;

	pack_store_ldac(p_ac->sfc_bitlen-LDAC_MINSFCBLEN_2, LDAC_SFCBLENBITS, p_stream, p_loc);

	p_hcsf = ga_hcenc_sf1_ldac + (p_ac->sfc_bitlen-LDAC_MINSFCBLEN_2);
	for (iqu = 0; iqu < nqus; iqu++) {
	dif = (p_ac->a_idsf[iqu] - p_ac->p_ab->ap_ac[0]->a_idsf[iqu]) & p_hcsf->mask;
	pack_store_ldac(hc_word_ldac(p_hcsf->p_tbl+dif), hc_len_ldac(p_hcsf->p_tbl+dif), p_stream, p_loc);
	}

	return;
	}

	/***************************************************************************************************
	Pack Scale Factor Data
	***************************************************************************************************/
	static void pack_scale_factor_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	int sfc_mode = p_ac->sfc_mode;

	pack_store_ldac(sfc_mode, LDAC_SFCMODEBITS, p_stream, p_loc);

	if (p_ac->ich == 0) {
	if (sfc_mode == LDAC_MODE_0) {
	pack_scale_factor_0_ldac(p_ac, p_stream, p_loc);
	}
	else {
	pack_scale_factor_1_ldac(p_ac, p_stream, p_loc);
	}
	}
	else {
	if (sfc_mode == LDAC_MODE_0) {
	pack_scale_factor_0_ldac(p_ac, p_stream, p_loc);
	}
	else {
	pack_scale_factor_2_ldac(p_ac, p_stream, p_loc);
	}
	}

	return;
	}

	/***************************************************************************************************
	Pack Spectrum Data
	***************************************************************************************************/
	static void pack_spectrum_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	int iqu, isp, i;
	int lsp, hsp;
	int nqus = p_ac->p_ab->nqus;
	int nsps, idwl1, wl, val;

	for (iqu = 0; iqu < nqus; iqu++) {
	lsp = ga_isp_ldac[iqu];
	hsp = ga_isp_ldac[iqu+1];
	nsps = ga_nsps_ldac[iqu];
	idwl1 = p_ac->a_idwl1[iqu];
	wl = ga_wl_ldac[idwl1];

	if (idwl1 == 1) {
	isp = lsp;

	if (nsps == 2) {
	val = (p_ac->a_qspec[isp ]+1) << 2;
	val += (p_ac->a_qspec[isp+1]+1);
	pack_store_ldac(ga_2dimenc_spec_ldac[val], LDAC_2DIMSPECBITS, p_stream, p_loc);
	}
	else {
	for (i = 0; i < nsps>>2; i++, isp+=4) {
	val = (p_ac->a_qspec[isp ]+1) << 6;
	val += (p_ac->a_qspec[isp+1]+1) << 4;
	val += (p_ac->a_qspec[isp+2]+1) << 2;
	val += (p_ac->a_qspec[isp+3]+1);
	pack_store_ldac(ga_4dimenc_spec_ldac[val], LDAC_4DIMSPECBITS, p_stream, p_loc);
	}
	}
	}
	else {
	for (isp = lsp; isp < hsp; isp++) {
	pack_store_ldac(p_ac->a_qspec[isp], wl, p_stream, p_loc);
	}
	}
	}

	return;
	}

	/***************************************************************************************************
	Pack Residual Data
	***************************************************************************************************/
	static void pack_residual_ldac(
	AC *p_ac,
	STREAM *p_stream,
	int *p_loc)
	{
	int iqu, isp;
	int lsp, hsp;
	int nqus = p_ac->p_ab->nqus;
	int idwl2, wl;

	for (iqu = 0; iqu < nqus; iqu++) {
	idwl2 = p_ac->a_idwl2[iqu];

	if (idwl2 > 0) {
	lsp = ga_isp_ldac[iqu];
	hsp = ga_isp_ldac[iqu+1];
	wl = ga_wl_ldac[idwl2];

	for (isp = lsp; isp < hsp; isp++) {
	pack_store_ldac(p_ac->a_rspec[isp], wl, p_stream, p_loc);
	}
	}
	}

	return;
	}

	/***************************************************************************************************
	Pack Audio Block
	***************************************************************************************************/
	static int pack_audio_block_ldac(
	AB *p_ab,
	STREAM *p_stream,
	int *p_loc)
	{
	AC *p_ac;
	int ich;
	int nchs = p_ab->blk_nchs;
	int nbits_band, nbits_grad, a_nbits_scfc[2], a_nbits_spec[2], nbits_used;
	int loc;

	for (ich = 0; ich < 2; ich++) {
	a_nbits_scfc[ich] = 0;
	a_nbits_spec[ich] = 0;
	}

	loc = *p_loc;
	pack_band_info_ldac(p_ab, p_stream, p_loc);
	nbits_band = *p_loc - loc;

	loc = *p_loc;
	pack_gradient_ldac(p_ab, p_stream, p_loc);
	nbits_grad = *p_loc - loc;

	nbits_used = nbits_band + nbits_grad;

	for (ich = 0; ich < nchs; ich++) {
	p_ac = p_ab->ap_ac[ich];

	loc = *p_loc;
	pack_scale_factor_ldac(p_ac, p_stream, p_loc);
	a_nbits_scfc[ich] = *p_loc - loc;

	loc = *p_loc;
	pack_spectrum_ldac(p_ac, p_stream, p_loc);
	a_nbits_spec[ich] = *p_loc - loc;

	loc = *p_loc;
	pack_residual_ldac(p_ac, p_stream, p_loc);
	a_nbits_spec[ich] += *p_loc - loc;

	nbits_used += a_nbits_scfc[ich] + a_nbits_spec[ich];
	}

	if (nbits_used > p_ab->nbits_used) {
	*p_ab->p_error_code = LDAC_ERR_BIT_PACKING;
	return LDAC_FALSE;
	}
	else if (nbits_used < p_ab->nbits_used) {
	*p_ab->p_error_code = LDAC_ERR_BIT_PACKING;
	return LDAC_FALSE;
	}

	return LDAC_TRUE;
	}

	/***************************************************************************************************
	Pack Raw Data Frame
	***************************************************************************************************/
	DECLFUNC int pack_raw_data_frame_ldac(
	SFINFO *p_sfinfo,
	STREAM *p_stream,
	int *p_loc,
	int *p_nbytes_used)
	{
	CFG *p_cfg = &p_sfinfo->cfg;
	AB *p_ab = p_sfinfo->p_ab;
	int ibk;
	int nbks = gaa_block_setting_ldac[p_cfg->chconfig_id][1];

	for (ibk = 0; ibk < nbks; ibk++) {
	if (!pack_audio_block_ldac(p_ab, p_stream, p_loc)) {
	return LDAC_ERR_PACK_BLOCK_FAILED;
	}

	pack_block_alignment_ldac(p_stream, p_loc);

	p_ab++;
	}

	pack_frame_alignment_ldac(p_stream, p_loc, p_cfg->frame_length);

	p_nbytes_used = p_loc / LDAC_BYTESIZE;

	return LDAC_ERR_NONE;
	}

	/***************************************************************************************************
	Pack Null Data Frame
	***************************************************************************************************/
	static const int sa_null_data_size_ldac[2] = {
	11, 15,
	};
	static const STREAM saa_null_data_ldac[2][15] = {
	{0x07, 0xa0, 0x16, 0x00, 0x20, 0xad, 0x51, 0x45, 0x14, 0x50, 0x49},
	{0x07, 0xa0, 0x0a, 0x00, 0x20, 0xad, 0x51, 0x41, 0x24, 0x93, 0x00, 0x28, 0xa0, 0x92, 0x49},
	};

	DECLFUNC int pack_null_data_frame_ldac(
	SFINFO *p_sfinfo,
	STREAM *p_stream,
	int *p_loc,
	int *p_nbytes_used)
	{
	CFG *p_cfg = &p_sfinfo->cfg;
	AB *p_ab = p_sfinfo->p_ab;
	int ibk;
	int nbks = gaa_block_setting_ldac[p_cfg->chconfig_id][1];
	int blk_type, size, offset = 0;

	for (ibk = 0; ibk < nbks; ibk++) {
	blk_type = p_ab->blk_type;
	size = sa_null_data_size_ldac[blk_type];

	copy_data_ldac(saa_null_data_ldac[blk_type], p_stream+offset, size*sizeof(STREAM));
	p_loc += sizeLDAC_BYTESIZE;

	offset += size;
	p_ab++;
	}
	if (p_cfg->frame_length < offset) {
	return LDAC_ERR_PACK_BLOCK_FAILED;
	}

	pack_frame_alignment_ldac(p_stream, p_loc, p_cfg->frame_length);

	p_nbytes_used = p_loc / LDAC_BYTESIZE;

	return LDAC_ERR_NONE;
	}