Merge branch 'lpd_dec_changes' into 'main' (73415f28) · Commits · SA4 / Audio / IVAS BASOP

lib_com/bits_alloc_fx.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -55,7 +55,7 @@ void BITS_ALLOC_init_config_acelp(
		move16();
		move16();
		move16();
		rate_mode_index=(bit_rate > ACELP_9k60);
		rate_mode_index = (Word8)GT_32( bit_rate, ACELP_9k60 );

		pConfigAcelp->mode_index=rate_mode_index;

		@@ -66,7 +66,7 @@ void BITS_ALLOC_init_config_acelp(

		/ACELP ICB config/
		test();
		IF( (rate_mode_index==0) \|\| narrowBand != 0 )
		IF( EQ_16( rate_mode_index, 0 ) \|\| NE_16( narrowBand, 0 ) )
		{
		move16();
		move16();

lib_com/bitstream_fx.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -389,13 +389,13 @@ UWord16 get_next_indice_fx( /* o : value of the indice */
		{
		UWord16 value;
		Word16 i;
		Word32 nbits_total;
		Word16 nbits_total;

		assert(nb_bits <= 16);
		value = 0;
		move16();

		nbits_total = st_fx->total_brate / FRAMES_PER_SEC;
		nbits_total = (Word16)(st_fx->total_brate / FRAMES_PER_SEC);
		/* detect corrupted bitstream */
		IF(GT_16(add(st_fx->next_bit_pos, nb_bits), nbits_total))
		{
		@@ -425,8 +425,8 @@ UWord16 get_next_indice_1_fx( /* o : value of the indice */
		Decoder_State st_fx / i/o: decoder state structure */
		)
		{
		Word32 nbits_total;
		nbits_total = st_fx->total_brate / FRAMES_PER_SEC;
		Word16 nbits_total;
		nbits_total = (Word16)(st_fx->total_brate / FRAMES_PER_SEC);
		/* detect corrupted bitstream */
		test();
		test();

lib_com/cldfb.c

+19 −16

Original line number	Diff line number	Diff line
		@@ -1412,6 +1412,7 @@ ivas_error openCldfb_ivas(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for CLDFB" );
		}
		hs->cldfb_state_length = buf_len;//Temporarily added to store the length of buffer
		set32_fx(hs->cldfb_state_fx, 0, buf_len);
		#endif // IVAS_FLOAT_FIXED

		@@ -2080,22 +2081,24 @@ void cldfb_reset_memory_ivas(
		}
		#ifdef IVAS_FLOAT_FIXED
		void cldfb_reset_memory_fx(
		HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */,
		Word16 *memory_length )
		HANDLE_CLDFB_FILTER_BANK hs /* i/o: filter bank handle */
		)
		{
		Word16 memory_length;
		UWord16 offset = sub(hs->p_filter_length, hs->no_channels);

		IF (hs->type == CLDFB_ANALYSIS)
		{
		*memory_length = offset;
		memory_length = offset;
		}
		ELSE
		{
		*memory_length = hs->p_filter_length;
		memory_length = hs->p_filter_length;
		}

		hs->cldfb_state_length = memory_length;
		/* save the memory */
		set32_fx( hs->cldfb_state_fx, 0, *memory_length );
		set32_fx(hs->cldfb_state_fx, 0, memory_length);

		return;
		}

lib_com/float_to_fix_ops.c

+18 −8

Original line number	Diff line number	Diff line
		@@ -5,18 +5,22 @@
		#include "prot.h"
		Word32 floatToFixed(const float f, Word16 Q)
		{
		if (f == 1.0f && Q == Q15)
		return MAX16B;
		if (f == 1.0f && Q == Q31)
		return MAXVAL_WORD32;
		if (Q < 0)
		return (Word32)((float)(f) / (float)(1 << (-Q)) + (f >= 0 ? 0.5 : -0.5));
		return (Word32)((float)(f) / (float)(((unsigned)1) << (-Q)) + (f >= 0 ? 0.5 : -0.5));
		else
		return (Word32)(f * (float)(1 << Q) + (f >= 0 ? 0.5 : -0.5));
		return (Word32)(f * (float)(((unsigned)1) << Q) + (f >= 0 ? 0.5 : -0.5));
		}

		float fixedToFloat(const Word32 i, Word16 Q)
		{
		if (Q < 0)
		return (i * (float)(1 << (-Q)));
		return (i * (float)(((unsigned)1) << (-Q)));
		else
		return (float)(i) / (float)(1 << Q);
		return (float)(i) / (float)(((unsigned)1) << Q);
		}
		void floatToFixed_arrL(const float f, Word32 i, Word16 Q, Word16 l)
		{
		@@ -46,13 +50,19 @@ void fixedToFloat_arr(const Word16 i, float f, Word16 Q, Word16 l)
		f[j] = fixedToFloat(i[j], Q);
		}
		}
		Word16 Q_factor(Word16 x)
		Word16 Q_factor(float x)
		{
		return norm_s(x);
		Word16 Q = 15;
		if ( x >= 1 \|\| x <= -1 )
		Q = norm_s((Word16)x);
		return Q;
		}
		Word16 Q_factor_L(Word32 x)
		Word16 Q_factor_L(float x)
		{
		return norm_l(x);
		Word16 Q = 31;
		if ( x >= 1 \|\| x <= -1 )
		Q = norm_l((Word32)x);
		return Q;
		}
		Word16 Q_factor_arr(float *x, Word16 l)
		{

lib_com/igf_base_fx.c

+261 −0

Original line number	Diff line number	Diff line
		@@ -848,6 +848,186 @@ static void IGF_gridSetUp(H_IGF_GRID hGrid,
		}

		}
		#ifdef IVAS_FLOAT_FIXED
		static void IGF_gridSetUp_ivas_fx(
		H_IGF_GRID hGrid, /* o : IGF grid handle */
		Word16 bitRateIndex, /* i : IGF bitrate index */
		const Word32 sampleRate, /* i : sample rate */
		Word16 frameLength, /* i : frame length */
		const Word16 transFac, /* i : transFac */
		const Word16 igfMinFq /* i : IGF minimum frequency indicating lower start frequency for copy up */
		)
		{
		Word16 t, k;
		Word16 sfb;
		Word16 swb_offset_len;
		const Word16 *swb_offset;
		Word16 bandwidth_fx;
		const Word16 *igf_tile_offset;
		Word16 tmp2, tmp1;
		Word32 L_tmp1, L_tmp2;

		/* inits */
		swb_offset = NULL;
		swb_offset_len = 0;
		IF( EQ_16( transFac, 8192 ) && EQ_16( bitRateIndex, IGF_BITRATE_SWB_48000_CPE ) )
		{
		bitRateIndex = IGF_BITRATE_SWB_48000_CPE_TCX10;
		}
		ELSE IF( EQ_16( transFac, 8192 ) && EQ_16( bitRateIndex, IGF_BITRATE_FB_48000_CPE ) )
		{
		bitRateIndex = IGF_BITRATE_FB_48000_CPE_TCX10;
		}

		IF( NE_16( bitRateIndex, IGF_BITRATE_UNKNOWN ) )
		{
		swb_offset = &swb_offset_LB_new[bitRateIndex][1];
		swb_offset_len = swb_offset_LB_new[bitRateIndex][0];
		Copy( &igf_whitening_TH_ivas_fx[bitRateIndex][0][0], &hGrid->whiteningThreshold[0][0], IGF_MAX_TILES * 2 );
		}
		ELSE
		{
		assert( 0 );
		}

		FOR( sfb = 0; sfb < swb_offset_len; sfb++ )
		{
		hGrid->swb_offset[sfb] = IGF_ApplyTransFac( swb_offset[sfb], transFac );
		}
		FOR( sfb = swb_offset_len; sfb < IGF_MAX_SFB; sfb++ )
		{
		hGrid->swb_offset[sfb] = 0;
		}

		hGrid->infoIsRefined = 0;
		frameLength = IGF_ApplyTransFac( frameLength, transFac );
		tmp2 = norm_s( frameLength );
		bandwidth_fx = shl( frameLength, tmp2 );
		hGrid->swb_offset_len = extract_l( L_shr( sampleRate, 2 ) );
		tmp1 = sub( norm_s( hGrid->swb_offset_len ), 1 );
		hGrid->swb_offset_len = shl( hGrid->swb_offset_len, tmp1 );
		bandwidth_fx = div_s( hGrid->swb_offset_len, bandwidth_fx );
		tmp2 = sub( add( tmp2, 1 ), tmp1 );
		bandwidth_fx = shr( bandwidth_fx, sub( 15, tmp2 ) );
		hGrid->swb_offset_len = swb_offset_len;
		hGrid->startSfb = 0;
		hGrid->stopSfb = sub( hGrid->swb_offset_len, 1 );
		hGrid->startLine = hGrid->swb_offset[hGrid->startSfb];
		hGrid->stopLine = hGrid->swb_offset[hGrid->stopSfb];
		hGrid->startFrequency = imult1616( bandwidth_fx, hGrid->startLine );
		hGrid->stopFrequency = imult1616( bandwidth_fx, hGrid->stopLine );
		L_tmp1 = L_mult0( igfMinFq, frameLength );
		tmp1 = sub( norm_l( L_tmp1 ), 1 );
		L_tmp1 = L_shl( L_tmp1, tmp1 );
		tmp2 = norm_l( sampleRate );
		L_tmp2 = L_shl( sampleRate, tmp2 );
		tmp1 = add( WORD16_BITS - 1, sub( tmp1, add( tmp2, 1 ) ) ); /* takes into account sampleRate >> 1 */
		hGrid->minSrcSubband = div_s( extract_h( L_tmp1 ), extract_h( L_tmp2 ) );
		hGrid->minSrcSubband = shr( hGrid->minSrcSubband, tmp1 );
		hGrid->minSrcSubband = add( hGrid->minSrcSubband, s_and( hGrid->minSrcSubband, 1 ) );
		hGrid->minSrcFrequency = imult1616( bandwidth_fx, hGrid->minSrcSubband );
		hGrid->infoGranuleLen = frameLength;
		hGrid->sfbWrap[0] = 0;
		hGrid->tile[0] = hGrid->startLine;

		igf_tile_offset = &igf_tile_offset_table[bitRateIndex][1];
		hGrid->nTiles = igf_tile_offset_table[bitRateIndex][0];
		hGrid->tile[0] = hGrid->startLine;
		hGrid->sfbWrap[0] = 0;
		FOR( k = 0; k < hGrid->nTiles; k++ )
		{
		hGrid->sfbWrap[k + 1] = igf_tile_offset[2 * k];
		hGrid->sbWrap[k] = add( hGrid->minSrcSubband, IGF_ApplyTransFac( igf_tile_offset[2 * k + 1], transFac ) );
		hGrid->tile[k + 1] = hGrid->swb_offset[igf_tile_offset[2 * k]];
		}
		FOR( t = hGrid->nTiles + 1; t < IGF_MAX_TILES; t++ )
		{
		hGrid->tile[t] = 0;
		hGrid->sbWrap[t - 1] = 0;
		hGrid->sfbWrap[t] = 0;
		}

		/* adapt level envelope: */
		SWITCH( bitRateIndex )
		{
		case IGF_BITRATE_RF_WB_13200:
		case IGF_BITRATE_WB_9600:
		case IGF_BITRATE_WB_13200_CPE:
		case IGF_BITRATE_WB_16400_CPE:
		hGrid->gFactor = 13107 /0.80f Q14/;
		move16();
		hGrid->fFactor = 11469 /0.70f Q14/;
		move16();
		hGrid->lFactor = 9830 /0.60f Q14/;
		move16();
		BREAK;
		case IGF_BITRATE_SWB_13200:
		case IGF_BITRATE_SWB_16400_CPE:
		case IGF_BITRATE_FB_16400:
		case IGF_BITRATE_SWB_16400:
		case IGF_BITRATE_FB_24400_CPE:
		case IGF_BITRATE_SWB_24400_CPE:
		hGrid->gFactor = 15237 /0.93f Q14/;
		move16();
		hGrid->fFactor = 3277 /0.20f Q14/;
		move16();
		hGrid->lFactor = 13926 /0.85f Q14/;
		move16();
		BREAK;
		case IGF_BITRATE_FB_24400:
		case IGF_BITRATE_SWB_24400:
		case IGF_BITRATE_FB_32000_CPE:
		case IGF_BITRATE_SWB_32000_CPE:
		case IGF_BITRATE_FB_32000:
		case IGF_BITRATE_SWB_32000:
		case IGF_BITRATE_SWB_48000_CPE:
		case IGF_BITRATE_SWB_64000_CPE:
		hGrid->gFactor = 15811 /0.965f Q14/;
		move16();
		hGrid->fFactor = 3277 /0.20f Q14/;
		move16();
		hGrid->lFactor = 13926 /0.85f Q14/;
		move16();
		BREAK;
		case IGF_BITRATE_FB_48000:
		case IGF_BITRATE_SWB_48000:
		case IGF_BITRATE_FB_64000:
		case IGF_BITRATE_SWB_64000:
		case IGF_BITRATE_SWB_80000_CPE:
		case IGF_BITRATE_SWB_96000_CPE:
		hGrid->gFactor = 16384 /1.00f Q14/;
		move16();
		hGrid->fFactor = 3277 /0.20f Q14/;
		move16();
		hGrid->lFactor = 16384 /1.00f Q14/;
		move16();
		BREAK;
		case IGF_BITRATE_SWB_9600:
		case IGF_BITRATE_SWB_13200_CPE:
		case IGF_BITRATE_RF_SWB_13200:
		default:
		hGrid->gFactor = 16384 /1.00f Q14/;
		move16();
		hGrid->fFactor = 0; /0.00f Q30/
		;
		move16();
		hGrid->lFactor = 16384 /1.00f Q14/;
		move16();
		}

		FOR ( t = add(hGrid->nTiles , 1); t < IGF_MAX_TILES; t++ )
		{
		hGrid->tile[t] = 0;
		move16();
		hGrid->sbWrap[t - 1] = 0;
		move16();
		hGrid->sfbWrap[t] = 0;
		move16();
		}
		return;
		}

		#endif // IVAS_FLOAT_FIXED

		/*********************************************************************/ /
		calculates energy per sfb via power spectrum
		@@ -1045,6 +1225,87 @@ Word16 IGFCommonFuncsIGFConfiguration(

		return retValue;
		}
		#ifdef IVAS_FLOAT_FIXED
		Word16 IGFCommonFuncsIGFConfiguration_ivas_fx(
		const Word32 total_brate, /* i : bitrate in bs e.g. 9600 for 9.6kbs */
		const Word16 bwidth, /* i : audio bandwidth */
		const Word16 element_mode, /* i : element mode */
		H_IGF_INFO hIGFInfo, /* o : IGF info handle */
		const Word16 rf_mode /* i : flag to signal the RF mode */
		)
		{
		H_IGF_GRID hGrid;
		Word16 retValue;
		Word32 sampleRate;
		Word16 frameLength;
		Word16 igfMinFq;
		Word16 maxHopsize;

		retValue = 0; /* bitrate index is unknown -> error! */
		move16();

		/* interface call for reading in settings */
		hIGFInfo->bitRateIndex = IGF_MapBitRateToIndex( total_brate, bwidth, element_mode, rf_mode );

		IF( NE_16( hIGFInfo->bitRateIndex, IGF_BITRATE_UNKNOWN ) )
		{
		retValue = 1; /* no error */
		move16();

		/* mapping to local values */
		sampleRate = igfMode[hIGFInfo->bitRateIndex].sampleRate;
		move32();
		frameLength = igfMode[hIGFInfo->bitRateIndex].frameLength;
		move16();
		igfMinFq = igfMode[hIGFInfo->bitRateIndex].igfMinFq;
		move16();
		maxHopsize = igfMode[hIGFInfo->bitRateIndex].maxHopsize;
		move16();

		/* basic information */
		hIGFInfo->sampleRate = sampleRate;
		move32();
		hIGFInfo->frameLength = frameLength;
		move16();
		hIGFInfo->maxHopsize = maxHopsize;
		move16();
		#if 0
		//100820 temp fix
		#endif
		hIGFInfo->nfSeedBuf[0] = 0;
		hIGFInfo->nfSeedBuf[1] = 0;
		hIGFInfo->nfSeed = &hIGFInfo->nfSeedBuf[0];
		move16();

		/* set up regular IGF grid for TCX 20 (transfac = 1.f) */
		hGrid = &hIGFInfo->grid[IGF_GRID_LB_NORM];
		IGF_gridSetUp_ivas_fx( hGrid,
		hIGFInfo->bitRateIndex,
		sampleRate,
		frameLength,
		16384 /1 Q14/,
		igfMinFq );
		/* set up IGF grid for CELP->TCX 20 transitions (transfac = 1.25) */
		hGrid = &hIGFInfo->grid[IGF_GRID_LB_TRAN];
		IGF_gridSetUp_ivas_fx( hGrid,
		hIGFInfo->bitRateIndex,
		sampleRate,
		frameLength,
		20480 /1.25 Q14/,
		igfMinFq );
		/* set up IGF grid for TCX 10 (transfac = 0.5) */
		hGrid = &hIGFInfo->grid[IGF_GRID_LB_SHORT];
		IGF_gridSetUp_ivas_fx( hGrid,
		hIGFInfo->bitRateIndex,
		sampleRate,
		frameLength,
		8192 /0.50f Q14/,
		igfMinFq );
		}

		return retValue;
		}
		#endif // IVAS_FLOAT_FIXED

		/*********************************************************************/ /
		selects cumulative frequency tables and offsets for the IGF SCF arithmetic coder