commit 1 (6eecf07a) · Commits · SA4 / Audio / IVAS BASOP

lib_enc/acelp_core_enc.c

+160 −151

File changed.

Preview size limit exceeded, changes collapsed.

lib_enc/avq_cod_fx.c

+459 −2

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@
		* Local prototypes
		-------------------------------------------------------------------/
		static void wrte_cv( BSTR_ENC_HANDLE hBstr, const Word16 nq, const Word16 i_ind, const Word16 kv_ind, UWord16 I, Word16 kv[], Word16 *bits );
		static void wrte_cv_ivas( BSTR_ENC_HANDLE hBstr, const Word16 nq, const Word16 i_ind, const Word16 kv_ind, UWord16 I, Word16 kv[], Word16 *bits );

		/-------------------------------------------------------------------
		* Function AVQ_cod() *
		@@ -408,7 +409,7 @@ void AVQ_encmux_fx(
		bits = sub( bits, 1 );
		}

		wrte_cv( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[shl( k, 3 )], &bits );
		wrte_cv( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[k * 8], &bits );
		}
		} /* for */
		/* Bit Saving Solution */
		@@ -545,7 +546,7 @@ void AVQ_encmux_fx(
		move16();

		/* write codebook indices (rank I and event. Voronoi index kv) */
		wrte_cv( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[shl( i, 3 )], &bits );
		wrte_cv( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[i * 8], &bits );

		bits = sub( bits, dummy_bits );

		@@ -566,6 +567,402 @@ void AVQ_encmux_fx(
		return;
		}

		void AVQ_encmux_ivas_fx(
		BSTR_ENC_HANDLE hBstr, /* i/o: bitstream handle */
		const Word16 extl, /* i : extension layer */
		Word16 xriq[], /* i/o: rounded subvectors [0..8*Nsv-1] followed
		by rounded bit allocations [8Nsv..8Nsv+Nsv-1] */
		Word16 nb_bits, / i/o: number of allocated bits */
		const Word16 Nsv, /* i: number of subvectors */
		Word16 nq_out[], /* o : AVQ nq index */
		Word16 avq_bit_sFlag, /* i : flag for AVQ bit saving solution */
		Word16 trgtSvPos /* i : target SV for AVQ bit savings */
		)
		{
		Word16 i, j = 0, bits, pos, pos_max, overflow, pos_tmp, bit_tmp;
		Word16 sort_idx[NSV_MAX], nq[NSV_MAX], kv[NSV_MAX * 8];
		Word16 *t;
		UWord16 I[NSV_MAX];
		Word16 nq_ind, i_ind, kv_ind;
		Word16 nq_est, unused_bits, unused_bits_idx;
		Word16 bitsMod, Nsvm1, Nsvm2;
		Word16 unusedbitsFlag;
		Word16 svOrder[NSV_MAX], k, nullVec, dummy_bits;

		test();
		IF( EQ_16( extl, SWB_BWE_HIGHRATE ) \|\| EQ_16( extl, FB_BWE_HIGHRATE ) )
		{
		nq_ind = IND_NQ2;
		move16();
		i_ind = IND_I2;
		move16();
		kv_ind = IND_KV2;
		move16();
		}
		ELSE
		{
		nq_ind = IND_NQ;
		move16();
		i_ind = IND_I;
		move16();
		kv_ind = IND_KV;
		move16();
		}

		FOR( i = 0; i < NSV_MAX; i++ )
		{
		I[i] = (UWord16) -1;
		move16();
		}
		unusedbitsFlag = 0;
		bitsMod = 0;
		move16();
		move16();
		/*-----------------------------------------------------------------
		* Encode subvectors and fix possible overflows in total bit budget,
		* i.e. find for each subvector a codebook index nq (nq=0,2,3,4,...,NSV_MAX),
		* a base codebook index (I), and a Voronoi index (kv)
		-----------------------------------------------------------------/

		/* sort subvectors by estimated bit allocations in decreasing order */
		t = kv;
		move16(); /* reuse vector to save memory */
		move16(); /ptr init/
		FOR( i = 0; i < Nsv; i++ )
		{
		t[i] = xriq[8 * Nsv + i];
		move16();
		}

		FOR( i = 0; i < Nsv; i++ )
		{
		bits = t[0];
		move16();
		pos = 0;
		move16();
		FOR( j = 1; j < Nsv; j++ )
		{
		if ( GT_16( t[j], bits ) )
		{
		pos = j;
		move16();
		}
		bits = s_max( t[j], bits );
		}
		sort_idx[i] = pos;
		move16();
		t[pos] = -1;
		move16();
		}

		/* compute multi-rate indices and avoid bit budget overflow */
		pos_max = 0;
		move16();
		bits = 0;
		move16();
		FOR( i = 0; i < Nsv; i++ )
		{
		/* find vector to quantize (criteria: nb of estimated bits) */
		pos = sort_idx[i];
		move16();

		/* compute multi-rate index of rounded subvector (nq,I,kv[]) */
		re8_cod_fx( &xriq[pos * 8], &nq[pos], &I[pos], &kv[8 * pos] );

		IF( nq[pos] > 0 )
		{
		j = pos_max;
		move16();
		j = s_max( pos, j );

		/* compute (number of bits -1) to describe Q #nq */
		IF( GE_16( nq[pos], 2 ) )
		{
		overflow = sub( i_mult2( nq[pos], 5 ), 1 );
		}
		ELSE
		{
		overflow = 0;
		move16();
		}

		/* check for overflow and compute number of bits-1 (n) */
		IF( GT_16( add( bits, add( overflow, j ) ), *nb_bits ) )
		{
		/* if budget overflow */
		pos_tmp = add( shl( pos, 3 ), 8 ); /(pos8)+8*/
		FOR( j = pos * 8; j < pos_tmp; j++ )
		{
		xriq[j] = 0;
		move16();
		}
		nq[pos] = 0;
		move16(); /* force Q0 */
		}
		ELSE
		{
		bits = add( bits, overflow );
		pos_max = j;
		move16(); /* update index of the last described subvector */
		}
		}
		}
		nullVec = 0;
		Nsvm1 = sub( Nsv, 1 );
		Nsvm2 = sub( Nsvm1, 1 );
		dummy_bits = 0;
		svOrder[Nsvm1] = trgtSvPos;
		svOrder[0] = 0;
		svOrder[1] = 1;
		i = 2;
		j = i;
		move16();
		move16();
		move16();
		move16();
		move16();
		move16();
		if ( EQ_16( avq_bit_sFlag, 2 ) )
		{
		j = add( i, 1 );
		}
		WHILE( LT_16( i, Nsvm1 ) )
		{
		svOrder[i] = j;
		move16();
		i++; /ptr/
		j = add( j, 1 );
		}
		/* write indexes to the bitstream */
		/* ============================== */

		bits = *nb_bits;
		move16();
		overflow = 0;
		move16();
		FOR( i = 0; i < Nsv; i++ )
		{
		k = svOrder[i];
		move16();
		test();
		test();
		test();
		test();
		test();
		IF( EQ_16( avq_bit_sFlag, 2 ) && EQ_16( s_and( bits, 4 ), 4 ) && GT_16( bits, 8 ) && LT_16( bits, 30 ) && GE_16( k, trgtSvPos ) && LT_16( i, Nsvm1 ) )
		{
		ordr_esti( sub( Nsv, i ), &trgtSvPos, &svOrder[i], Nsv );
		k = svOrder[i];
		move16();
		avq_bit_sFlag = 1;
		move16();
		}

		test();
		IF( EQ_16( k, trgtSvPos ) && avq_bit_sFlag > 0 )
		{
		test();
		test();
		IF( EQ_16( sub( *nb_bits, bits ), 7 ) \|\| LT_16( bits, BIT_SAVING_LOW_THR ) \|\| GE_16( bits, BIT_SAVING_HIGH_THR ) )
		{
		avq_bit_sFlag = 0;
		move16();
		}
		ELSE
		{
		BREAK;
		}
		}

		if ( EQ_16( sub( i_mult2( 5, nq[k] ), 1 ), bits ) ) /* check the overflow */
		{
		overflow = 1;
		move16();
		}

		IF( GT_16( bits, 8 ) )
		{
		/* write the unary code for nq[i] */
		j = sub( nq[k], 1 );
		IF( nq[k] > 0 )
		{
		/* write the unary code */
		FOR( ; j > 16; j -= 16 )
		{
		push_indice( hBstr, nq_ind, 65535, 16 );
		bits = sub( bits, 16 );
		}

		IF( j > 0 )
		{
		push_indice( hBstr, nq_ind, extract_l( L_sub( L_shl( 1L, j ), 1L ) ), j );
		bits = sub( bits, j );
		}
		}
		IF( !overflow )
		{
		/* write the stop bit */
		push_indice( hBstr, nq_ind, 0, 1 );
		bits = sub( bits, 1 );
		}

		wrte_cv_ivas( hBstr, nq[k], i_ind, kv_ind, I[k], &kv[k * 8], &bits );
		}
		} /* for */
		/* Bit Saving Solution */
		test();
		IF( avq_bit_sFlag > 0 && bits > 8 )
		{
		// PMT("code not validated yet")
		bitsMod = s_and( bits, 4 /bits%5/ );
		i = svOrder[Nsvm1];
		move16();
		IF( NE_16( i, Nsvm1 ) )
		{
		nullVec = 0;
		move16();
		FOR( j = i; j < Nsv - 1; j++ )
		{
		if ( nq[svOrder[j]] == 0 )
		{
		nullVec = add( nullVec, 1 );
		}
		}
		/nq_est = bits / 5;/
		nq_est = mult( bits, 6554 );
		assert( nq_est == bits / 5 );

		test();
		test();
		test();
		test();
		test();
		test();
		test();
		test();
		test();
		test();
		test();
		IF( ( bitsMod > 0 \|\| ( EQ_16( nullVec, 4 ) && EQ_16( nq_est, 5 ) ) ) && NE_16( bitsMod, 4 ) && GE_16( add( bits, nullVec ), add( add( shl( nq_est, 2 ), nq_est ), 4 ) ) /5 nq_est + 4/ && nq[svOrder[Nsvm2]] == 0 ) / detect need for dummy bits */
		{
		dummy_bits = sub( 5, bitsMod );
		bits = add( bits, dummy_bits ); /* add dummy bits */
		bitsMod = 0;
		move16();
		}
		ELSE IF( nq_est > 4 && ( ( bitsMod == 0 && nullVec > 3 && nullVec < 6 ) \|\| ( bitsMod == 4 && nullVec == 5 ) ) && nq[svOrder[Nsvm2]] == 0 ) /* wasted bits 4, 5 for nq 6,7..*/
		{
		overflow = 0;
		move16();
		if ( s_and( add( bitsMod, nullVec ), 4 ) != 0 )
		{
		overflow = 1;
		move16();
		}
		dummy_bits = add( nullVec, overflow );
		bits = add( bits, dummy_bits ); /* add dummy bits */
		bitsMod = 0;
		move16();
		}
		}

		overflow = 1;
		move16();
		IF( NE_16( bitsMod, 4 ) )
		{
		overflow = 0;
		move16();
		bits = sub( bits, bitsMod );
		}
		bits = add( bits, overflow ); /add fake bit /
		unused_bits = sub( bits, add( shl( nq[i], 2 ), nq[i] ) );
		if ( nq[i] == 0 ) /no bit savings/
		{
		unused_bits = sub( unused_bits, 1 ); /Stop Bit/
		}
		/unused_bits_idx = (int16_t)unused_bits / 5;/
		unused_bits_idx = mult( unused_bits, 6554 );
		assert( unused_bits_idx == unused_bits / 5 );
		unusedbitsFlag = 0;
		move16();
		IF( dummy_bits == 0 )
		{
		test();
		test();
		IF( EQ_16( unused_bits_idx, 1 ) && GT_16( bits, BIT_SAVING_LOW_THR ) )
		{
		unused_bits_idx = 0;
		unusedbitsFlag = 1;
		move16();
		move16();
		}
		ELSE IF( unused_bits_idx == 0 && GT_16( bits, BIT_SAVING_LOW_THR ) )
		{
		unused_bits_idx = 1;
		unusedbitsFlag = -1;
		move16();
		move16();
		}
		}

		j = unused_bits_idx;
		move16();
		/Encode Unused Bit Unary Codeword /
		IF( j > 0 )
		{
		/* write the unary code */
		push_indice( hBstr, nq_ind, sub( shl_sat( 1, j ), 1 ), j );
		}

		IF( nq[i] != 0 )
		{
		/* write the stop bit */
		push_indice( hBstr, nq_ind, 0, 1 );
		}

		/Compute AVQ code book number from unused Bits /
		bit_tmp = add( unusedbitsFlag, unused_bits_idx );
		/nq_est = (int16_t)ceil(0.2f (bits - 5 * (unusedbitsFlag + unused_bits_idx)));*/
		nq_est = mult( 6554, sub( bits, add( shl( bit_tmp, 2 ), bit_tmp ) ) );
		//assert( (int16_t) ceil( 0.2f * ( bits - 5 * ( unusedbitsFlag + unused_bits_idx ) ) ) == nq_est );

		if ( EQ_16( nq_est, 1 ) )
		{
		nq_est = 0;
		move16();
		}
		bits = sub( bits, overflow );

		bits = sub( bits, j );

		if ( nq_est != 0 )
		{
		bits = sub( bits, 1 );
		}
		nq[i] = nq_est;
		move16();

		/* write codebook indices (rank I and event. Voronoi index kv) */
		wrte_cv_ivas( hBstr, nq[i], i_ind, kv_ind, I[i], &kv[i * 8], &bits );

		bits = sub( bits, dummy_bits );

		if ( NE_16( bitsMod, 4 ) )
		{
		bits = add( bits, bitsMod );
		}
		}
		*nb_bits = bits;
		move16();

		FOR( i = 0; i < Nsv; i++ )
		{
		nq_out[i] = nq[i];
		move16();
		}

		return;
		}

		/-------------------------------------------------------------------
		* Function AVQ_cod_lpc_fx() *
		@@ -715,3 +1112,63 @@ static void wrte_cv(
		move16();
		return;
		}

		static void wrte_cv_ivas(
		BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
		const Word16 nq, /* i : AVQ nq index */
		const Word16 i_ind, /* i : Base Bitstream index */
		const Word16 kv_ind, /* i : Vornoi Bitstream index */
		UWord16 I, /* o : rank I code book index */
		Word16 kv[], /* o : Vornoi index kv */
		Word16 nbits / i/o: bits */
		)
		{
		int16_t pos, j;
		int16_t bits, nq4;

		bits = *nbits;
		move16();

		/* write codebook indices (rank I and event. Voronoi index kv) */
		IF( nq == 0 ) /* Q0 */
		{
		/* nothing to write */
		}
		ELSE IF( LT_16( nq, 5 ) ) /* Q2, Q3, Q4 */
		{
		nq4 = shl( nq, 2 );
		push_indice( hBstr, i_ind, I, nq4 );
		bits = sub( bits, nq4 );
		}
		ELSE IF( EQ_16( s_and( nq, 1 ), 0 ) ) /* Q4 + Voronoi extensions r=1,2,3,... */
		{
		push_indice( hBstr, i_ind, I, 4 * 4 );
		bits = sub( bits, 4 * 4 );
		/pos = (int16_t)(nq / 2 - 2);/ /* Voronoi order determination */
		pos = sub( shr( nq, 1 ), 2 );
		FOR( j = 0; j < 8; j++ )
		{
		push_indice( hBstr, kv_ind, kv[j], pos );
		}

		bits = sub( bits, shl( pos, 3 ) );
		}
		ELSE /* Q3 + Voronoi extensions r=1,2,3,... */
		{
		push_indice( hBstr, i_ind, I, 4 * 3 );
		bits = sub( bits, 4 * 3 );

		/pos = (int16_t)(nq / 2 - 1);/ /* Voronoi order determination */
		pos = sub( shr( nq, 1 ), 1 );
		FOR( j = 0; j < 8; j++ )
		{
		push_indice( hBstr, kv_ind, kv[j], pos );
		}

		bits = sub( bits, shl( pos, 3 ) );
		}

		*nbits = bits;
		move16();
		return;
		}

lib_enc/cod4t64_fast.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -1570,7 +1570,7 @@ void acelp_fast_fx(
		set16_fx( code, 0, L_subfr );
		FOR( q = 0; q < nb_pulse; q++ )
		{
		code[m_max[q]] = add( code[m_max[q]], s_max[q] ); // Q0
		code[m_max[q]] = add( code[m_max[q]], shl(s_max[q], Q9) ); // Q9
		move16();
		}
		test();

lib_enc/cod4t64_fx.c

+415 −1

File changed.

Preview size limit exceeded, changes collapsed.

lib_enc/corr_xh_fx.c

+12 −12

Original line number	Diff line number	Diff line
		@@ -88,24 +88,24 @@ void corr_xh_ivas_fx(
		const Word16 L_subfr /* i : length of the subframe */
		)
		{
		Word16 i, j;
		Word32 s;
		Word32 y32[2 * L_SUBFR];
		Word16 i, j, scale;
		Word64 s64;

		Word16 shift = add(norm_s(h[0]), 1);
		scale = sub(sub(15, shift), 2);
		FOR(i = 0; i < L_subfr; i++)
		{
		s = 0;
		move32();
		s64 = 0;
		move16();
		FOR(j = i; j < L_subfr; j++)
		{
		s = L_add( s, shl( mult( x[j], h[j - i] ), shift ) ); // Q_new - 1
		s64 = W_mac0_16_16(s64, x[j], h[j - i]); // Q_new - 1 + 15 - shift
		}

		y32[i] = s; // Q_new - 1
		move32();
		y[i] = extract_l(W_extract_l(W_shr(s64, scale))); // Q_new + 1
		move16();
		}
		Copy_Scale_sig32_16( y32, y, L_subfr, 18 ); // Q_new + 1

		return;

		}