Merge branch 'enc_funcs_fxd_converted' into 'main' (e64601da) · Commits · SA4 / Audio / IVAS BASOP

lib_com/bitstream.c

+249 −0

Original line number	Diff line number	Diff line
		@@ -159,6 +159,138 @@ Word16 rate2EVSmode_float(
		* Re-allocate the list of indices
		-------------------------------------------------------------------/

		#ifdef IVAS_FLOAT_FIXED
		ivas_error ind_list_realloc(
		INDICE_HANDLE old_ind_list, /* i : pointer to the beginning of the old buffer of indices */
		const Word16 max_num_indices, /* i : new maximum number of allowed indices in the list */
		Encoder_Struct st_ivas / i : IVAS encoder structure */
		)
		{
		Word16 i, n, ch, n_channels, ind_list_pos, is_metadata, ivas_max_num_indices;
		INDICE_HANDLE new_ind_list;
		BSTR_ENC_HANDLE hBstr;

		IF( st_ivas == NULL )
		{
		return IVAS_ERR_OK;
		}

		/* get the pointer to the beginning of the old buffer of indices (either metadata or core coders) */
		IF( old_ind_list == st_ivas->ind_list_metadata )
		{
		is_metadata = 1;
		ivas_max_num_indices = st_ivas->ivas_max_num_indices_metadata;
		}
		ELSE
		{
		is_metadata = 0;
		ivas_max_num_indices = st_ivas->ivas_max_num_indices;
		}
		move16();
		move16();

		/* allocate new buffer of indices */
		IF( ( new_ind_list = (INDICE_HANDLE) malloc( max_num_indices * sizeof( Indice ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for buffer of indices!\n" ) );
		}

		/* move indices from the old list to the new list */
		FOR( i = 0; i < s_min( max_num_indices, ivas_max_num_indices ); i++ )
		{
		IF( GT_16( old_ind_list[i].nb_bits, -1 ) )
		{
		new_ind_list[i].id = old_ind_list[i].id;
		new_ind_list[i].value = old_ind_list[i].value;
		move16();
		move16();
		}
		new_ind_list[i].nb_bits = old_ind_list[i].nb_bits;
		move16();
		}

		/* reset nb_bits of all other indices to -1 */
		FOR( ; i < max_num_indices; i++ )
		{
		new_ind_list[i].nb_bits = -1;
		move16();
		}

		/* update parameters in all SCE elements */
		FOR( n = 0; n < st_ivas->nSCE; n++ )
		{
		/* get the pointer to hBstr */
		IF( is_metadata )
		{
		hBstr = st_ivas->hSCE[n]->hMetaData;
		}
		ELSE
		{
		hBstr = st_ivas->hSCE[n]->hCoreCoder[0]->hBstr;
		}

		IF( hBstr != NULL )
		{
		/* get the current position inside the old list */
		ind_list_pos = (Word16) ( hBstr->ind_list - old_ind_list );

		/* set pointers in the new list */
		*( hBstr->ivas_ind_list_zero ) = new_ind_list;
		hBstr->ind_list = &new_ind_list[ind_list_pos];

		/* set the new maximum number of indices */
		*( hBstr->ivas_max_num_indices ) = max_num_indices;
		move16();
		}
		}

		/* update parameters in all CPE elements */
		FOR( n = 0; n < st_ivas->nCPE; n++ )
		{
		/* get the pointer to hBstr */
		IF( is_metadata )
		{
		n_channels = 1;
		}
		ELSE
		{
		n_channels = CPE_CHANNELS;
		}
		move16();

		FOR( ch = 0; ch < n_channels; ch++ )
		{
		IF( is_metadata )
		{
		hBstr = st_ivas->hCPE[n]->hMetaData;
		}
		ELSE
		{
		hBstr = st_ivas->hCPE[n]->hCoreCoder[ch]->hBstr;
		}

		IF( hBstr != NULL )
		{
		/* get the current position inside the old list */
		ind_list_pos = (Word16) ( hBstr->ind_list - old_ind_list );

		/* set pointers in the new list */
		*( hBstr->ivas_ind_list_zero ) = new_ind_list;
		hBstr->ind_list = &new_ind_list[ind_list_pos];

		/* set the new maximum number of indices */
		*( hBstr->ivas_max_num_indices ) = max_num_indices;
		move16();
		}
		}
		}

		/* free the old list */
		free( old_ind_list );

		return IVAS_ERR_OK;
		}
		#else
		ivas_error ind_list_realloc(
		INDICE_HANDLE old_ind_list, /* i : pointer to the beginning of the old buffer of indices */
		const int16_t max_num_indices, /* i : new maximum number of allowed indices in the list */
		@@ -280,6 +412,7 @@ ivas_error ind_list_realloc(

		return IVAS_ERR_OK;
		}
		#endif // IVAS_FLOAT_FIXED


		/-----------------------------------------------------------------------
		@@ -1267,6 +1400,61 @@ void move_indices(
		* Check, if we will not overwrite an existing indice -> adjust the location
		-------------------------------------------------------------------/

		#ifdef IVAS_FLOAT_FIXED
		ivas_error check_ind_list_limits(
		BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
		)
		{
		Indice ivas_ind_list_zero, ivas_ind_list_last;
		ivas_error error;

		error = IVAS_ERR_OK;
		move32();
		ivas_ind_list_zero = *( hBstr->ivas_ind_list_zero );

		/* check, if the maximum number of indices has been reached and re-allocate the buffer */
		/* the re-allocation can be avoided by increasing the limits in get_ivas_max_num_indices() or get_ivas_max_num_indices_metadata() */
		IF( GE_16( (Word16) ( &hBstr->ind_list[hBstr->nb_ind_tot] - ivas_ind_list_zero ), *( hBstr->ivas_max_num_indices ) ) )
		{

		/* reallocate the buffer of indices with increased limit */
		IF( ( error = ind_list_realloc( hBstr->ivas_ind_list_zero, ( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES, hBstr->st_ivas ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		}

		/* check, if we will not overwrite an existing indice */
		IF( hBstr->ind_list[hBstr->nb_ind_tot].nb_bits > 0 )
		{
		IF( hBstr->nb_ind_tot == 0 )
		{
		/* move the pointer to the next available empty slot */
		ivas_ind_list_last = &ivas_ind_list_zero[*( hBstr->ivas_max_num_indices )];
		WHILE( hBstr->ind_list[0].nb_bits > 0 && hBstr->ind_list < ivas_ind_list_last )
		{
		hBstr->ind_list++;
		}

		IF( hBstr->ind_list >= ivas_ind_list_last )
		{

		/* no available empty slot -> need to re-allocate the buffer */
		IF( ( error = ind_list_realloc( hBstr->ivas_ind_list_zero, ( hBstr->ivas_max_num_indices ) + STEP_MAX_NUM_INDICES, hBstr->st_ivas ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		}
		}
		ELSE
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Buffer of indices corrupted in frame %d! Attempt to overwrite indice ID = %d (value: %d, bits: %d)!\n", hBstr->ind_list[hBstr->nb_ind_tot].id, hBstr->ind_list[hBstr->nb_ind_tot].value, hBstr->ind_list[hBstr->nb_ind_tot].nb_bits );
		}
		}

		return error;
		}
		#else
		ivas_error check_ind_list_limits(
		BSTR_ENC_HANDLE hBstr /* i/o: encoder bitstream handle */
		)
		@@ -1319,6 +1507,7 @@ ivas_error check_ind_list_limits(

		return error;
		}
		#endif // IVAS_FLOAT_FIXED


		/-------------------------------------------------------------------
		@@ -1327,6 +1516,65 @@ ivas_error check_ind_list_limits(
		* Push a new indice into the buffer
		-------------------------------------------------------------------/

		#ifdef IVAS_FLOAT_FIXED
		ivas_error push_indice(
		BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
		Word16 id, /* i : ID of the indice */
		UWord16 value, /* i : value of the quantized indice */
		Word16 nb_bits /* i : number of bits used to quantize the indice */
		)
		{
		Word16 i;
		Word16 j;
		ivas_error error;

		error = IVAS_ERR_OK;
		move32();

		/* check the limits of the list of indices */
		IF( ( error = check_ind_list_limits( hBstr ) ) != IVAS_ERR_OK )
		{
		return IVAS_ERROR( error, "Error occured in push_indice() while re-allocating the list of indices (frame %d) !\n" );
		}

		/* find the location in the list of indices based on ID */
		i = hBstr->nb_ind_tot;
		move16();
		WHILE( i > 0 && LT_16( id, hBstr->ind_list[i - 1].id ) )
		{
		i = sub( i, 1 );
		}

		/* shift indices, if the new ID is to be written somewhere inside the list */
		IF( i < hBstr->nb_ind_tot )
		{
		FOR( j = hBstr->nb_ind_tot; j > i; j-- )
		{
		hBstr->ind_list[j].id = hBstr->ind_list[j - 1].id;
		hBstr->ind_list[j].nb_bits = hBstr->ind_list[j - 1].nb_bits;
		hBstr->ind_list[j].value = hBstr->ind_list[j - 1].value;
		move16();
		move16();
		move16();
		}
		}


		/* store the new indice in the list */
		hBstr->ind_list[i].id = id;
		hBstr->ind_list[i].value = value;
		hBstr->ind_list[i].nb_bits = nb_bits;
		move16();
		move16();
		move16();

		/* updates */
		hBstr->nb_ind_tot = add( hBstr->nb_ind_tot, 1 );
		hBstr->nb_bits_tot = add( hBstr->nb_bits_tot, nb_bits );

		return error;
		}
		#else
		ivas_error push_indice(
		BSTR_ENC_HANDLE hBstr, /* i/o: encoder bitstream handle */
		int16_t id, /* i : ID of the indice */
		@@ -1377,6 +1625,7 @@ ivas_error push_indice(

		return error;
		}
		#endif // IVAS_FLOAT_FIXED

		/-------------------------------------------------------------------
		* push_next_indice()

lib_com/bitstream_fx.c

+38 −38

Original line number	Diff line number	Diff line
		@@ -280,23 +280,23 @@ void push_indice_fx(
		/* new indice - find an empty slot in the list */
		i = id;
		move16();
		WHILE( NE_16( hBstr->ind_list_fx[i].nb_bits, -1 ) )
		WHILE( NE_16( hBstr->ind_list[i].nb_bits, -1 ) )
		{
		i = add( i, 1 );
		}
		}

		/* store the values in the list */
		hBstr->ind_list_fx[i].value = value;
		hBstr->ind_list[i].value = value;
		move16();
		hBstr->ind_list_fx[i].nb_bits = nb_bits;
		hBstr->ind_list[i].nb_bits = nb_bits;
		move16();

		/* updates */
		hBstr->next_ind_fx = add( i, 1 );
		hBstr->last_ind_fx = id;
		move16();
		hBstr->nb_bits_tot_fx = add( hBstr->nb_bits_tot_fx, nb_bits );
		hBstr->nb_bits_tot = add( hBstr->nb_bits_tot, nb_bits );

		return;
		}
		@@ -314,15 +314,15 @@ void push_next_indice_fx(
		{

		/* store the values in the list */
		hBstr->ind_list_fx[hBstr->next_ind_fx].value = value;
		hBstr->ind_list[hBstr->next_ind_fx].value = value;
		move16();
		hBstr->ind_list_fx[hBstr->next_ind_fx].nb_bits = nb_bits;
		hBstr->ind_list[hBstr->next_ind_fx].nb_bits = nb_bits;
		move16();
		hBstr->next_ind_fx = add( hBstr->next_ind_fx, 1 );


		/* update the total number of bits already written */
		hBstr->nb_bits_tot_fx = add( hBstr->nb_bits_tot_fx, nb_bits );
		hBstr->nb_bits_tot = add( hBstr->nb_bits_tot, nb_bits );

		return;
		}
		@@ -343,7 +343,7 @@ void push_next_bits_fx(
		Word16 i, nb_bits_m15;
		Indice *ptr;

		ptr = &hBstr->ind_list_fx[hBstr->next_ind_fx];
		ptr = &hBstr->ind_list[hBstr->next_ind_fx];
		nb_bits_m15 = sub( nb_bits, 15 );
		i = 0;
		move16();
		@@ -374,8 +374,8 @@ void push_next_bits_fx(
		++ptr;
		}
		}
		hBstr->next_ind_fx = (Word16) ( ptr - hBstr->ind_list_fx );
		hBstr->nb_bits_tot_fx = add( hBstr->nb_bits_tot_fx, nb_bits );
		hBstr->next_ind_fx = (Word16) ( ptr - hBstr->ind_list );
		hBstr->nb_bits_tot = add( hBstr->nb_bits_tot, nb_bits );
		}

		/-------------------------------------------------------------------
		@@ -532,7 +532,7 @@ void reset_indices_enc_fx(
		{
		Word16 i;

		hBstr->nb_bits_tot_fx = 0;
		hBstr->nb_bits_tot = 0;
		move16();
		hBstr->next_ind_fx = 0;
		move16();
		@@ -541,7 +541,7 @@ void reset_indices_enc_fx(

		FOR( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		hBstr->ind_list_fx[i].nb_bits = -1;
		hBstr->ind_list[i].nb_bits = -1;
		move16();
		}

		@@ -596,7 +596,7 @@ void write_indices_fx(
		stream[i] = 0;
		}
		*pt_stream++ = (Word16) SYNC_GOOD_FRAME;
		*pt_stream++ = hBstr->nb_bits_tot_fx;
		*pt_stream++ = hBstr->nb_bits_tot;

		/----------------------------------------------------------------
		* Bitstream packing (conversion of individual indices into a serial stream)
		@@ -605,15 +605,15 @@ void write_indices_fx(

		for ( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		if ( hBstr->ind_list_fx[i].nb_bits != -1 )
		if ( hBstr->ind_list[i].nb_bits != -1 )
		{
		/* mask from MSB to LSB */
		mask = 1 << ( hBstr->ind_list_fx[i].nb_bits - 1 );
		mask = 1 << ( hBstr->ind_list[i].nb_bits - 1 );

		/* write bit by bit */
		for ( k = 0; k < hBstr->ind_list_fx[i].nb_bits; k++ )
		for ( k = 0; k < hBstr->ind_list[i].nb_bits; k++ )
		{
		if ( hBstr->ind_list_fx[i].value & mask )
		if ( hBstr->ind_list[i].value & mask )
		{
		*pt_stream++ = G192_BIN1;
		}
		@@ -631,7 +631,7 @@ void write_indices_fx(
		{
		/* Create and write ToC header */
		/* qbit always set to 1 on encoder side for AMRWBIO , no qbit in use for EVS, but set to 0(bad) */
		header = (UWord8) ( st_fx->Opt_AMR_WB << 5 \| st_fx->Opt_AMR_WB << 4 \| rate2EVSmode( hBstr->nb_bits_tot_fx * 50, &isAmrWb ) );
		header = (UWord8) ( st_fx->Opt_AMR_WB << 5 \| st_fx->Opt_AMR_WB << 4 \| rate2EVSmode( hBstr->nb_bits_tot * 50, &isAmrWb ) );
		fwrite( &header, sizeof( UWord8 ), 1, file );
		/* Write speech bits */
		fwrite( pFrame, sizeof( UWord8 ), ( pFrame_size + 7 ) >> 3, file );
		@@ -640,7 +640,7 @@ void write_indices_fx(
		/* Clearing of indices */
		FOR( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		hBstr->ind_list_fx[i].nb_bits = -1;
		hBstr->ind_list[i].nb_bits = -1;
		move16();
		}

		@@ -651,7 +651,7 @@ void write_indices_fx(
		fwrite( stream, sizeof( unsigned short ), 2 + stream[1], file );
		}
		/* reset index pointers */
		hBstr->nb_bits_tot_fx = 0;
		hBstr->nb_bits_tot = 0;
		hBstr->next_ind_fx = 0;
		hBstr->last_ind_fx = -1;

		@@ -690,7 +690,7 @@ void write_indices_buf_fx(
		}
		//*pt_stream++ = (Word16) SYNC_GOOD_FRAME;
		//*pt_stream++ = hBstr->nb_bits_tot_fx;
		*num_bits = hBstr->nb_bits_tot_fx;
		*num_bits = hBstr->nb_bits_tot;

		/----------------------------------------------------------------
		* Bitstream packing (conversion of individual indices into a serial stream)
		@@ -698,15 +698,15 @@ void write_indices_buf_fx(
		----------------------------------------------------------------/
		for ( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		if ( hBstr->ind_list_fx[i].nb_bits != -1 )
		if ( hBstr->ind_list[i].nb_bits != -1 )
		{
		/* mask from MSB to LSB */
		mask = 1 << ( hBstr->ind_list_fx[i].nb_bits - 1 );
		mask = 1 << ( hBstr->ind_list[i].nb_bits - 1 );

		/* write bit by bit */
		for ( k = 0; k < hBstr->ind_list_fx[i].nb_bits; k++ )
		for ( k = 0; k < hBstr->ind_list[i].nb_bits; k++ )
		{
		if ( hBstr->ind_list_fx[i].value & mask )
		if ( hBstr->ind_list[i].value & mask )
		{
		//*pt_stream++ = G192_BIN1;
		*pt_stream++ = 1;
		@@ -726,7 +726,7 @@ void write_indices_buf_fx(
		{
		/* Create and write ToC header */
		/* qbit always set to 1 on encoder side for AMRWBIO , no qbit in use for EVS, but set to 0(bad) */
		header = (UWord8) ( st_fx->Opt_AMR_WB << 5 \| st_fx->Opt_AMR_WB << 4 \| rate2EVSmode( hBstr->nb_bits_tot_fx * 50, &isAmrWb ) );
		header = (UWord8) ( st_fx->Opt_AMR_WB << 5 \| st_fx->Opt_AMR_WB << 4 \| rate2EVSmode( hBstr->nb_bits_tot * 50, &isAmrWb ) );
		// fwrite(&header, sizeof(UWord8), 1, file);
		memcpy( out_buf, &header, sizeof( UWord8 ) );
		*num_bits += sizeof( UWord8 );
		@@ -739,7 +739,7 @@ void write_indices_buf_fx(
		/* Clearing of indices */
		FOR( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		hBstr->ind_list_fx[i].nb_bits = -1;
		hBstr->ind_list[i].nb_bits = -1;
		move16();
		}

		@@ -755,7 +755,7 @@ void write_indices_buf_fx(
		//num_bits += sizeof( unsigned short ) ( 2 + stream[1] );
		}
		/* reset index pointers */
		hBstr->nb_bits_tot_fx = 0;
		hBstr->nb_bits_tot = 0;
		hBstr->next_ind_fx = 0;
		hBstr->last_ind_fx = -1;

		@@ -786,27 +786,27 @@ void indices_to_serial(
		if ( st_fx->Opt_AMR_WB )
		{
		cmi = rate2EVSmode( st_fx->total_brate, &isAmrWb );
		core_mode = rate2EVSmode( hBstr->nb_bits_tot_fx * 50, &isAmrWb );
		core_mode = rate2EVSmode( hBstr->nb_bits_tot * 50, &isAmrWb );

		j = 0;
		for ( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		if ( hBstr->ind_list_fx[i].nb_bits != -1 )
		if ( hBstr->ind_list[i].nb_bits != -1 )
		{
		/* mask from MSB to LSB */
		mask = 1 << ( hBstr->ind_list_fx[i].nb_bits - 1 );
		mask = 1 << ( hBstr->ind_list[i].nb_bits - 1 );

		/* temporarily save bit */
		for ( k = 0; k < hBstr->ind_list_fx[i].nb_bits; k++ )
		for ( k = 0; k < hBstr->ind_list[i].nb_bits; k++ )
		{
		amrwb_bits[j++] = ( hBstr->ind_list_fx[i].value & mask ) > 0;
		amrwb_bits[j++] = ( hBstr->ind_list[i].value & mask ) > 0;
		mask >>= 1;
		}
		}
		}
		}

		*pFrame_size = hBstr->nb_bits_tot_fx;
		*pFrame_size = hBstr->nb_bits_tot;

		/----------------------------------------------------------------
		* Bitstream packing (conversion of individual indices into a serial stream)
		@@ -814,13 +814,13 @@ void indices_to_serial(
		j = 0;
		for ( i = 0; i < MAX_NUM_INDICES; i++ )
		{
		if ( hBstr->ind_list_fx[i].nb_bits != -1 )
		if ( hBstr->ind_list[i].nb_bits != -1 )
		{
		/* mask from MSB to LSB */
		mask = 1 << ( hBstr->ind_list_fx[i].nb_bits - 1 );
		mask = 1 << ( hBstr->ind_list[i].nb_bits - 1 );

		/* write bit by bit */
		for ( k = 0; k < hBstr->ind_list_fx[i].nb_bits; k++ )
		for ( k = 0; k < hBstr->ind_list[i].nb_bits; k++ )
		{
		if ( st_fx->Opt_AMR_WB )
		{
		@@ -828,7 +828,7 @@ void indices_to_serial(
		}
		else
		{
		pack_bit( hBstr->ind_list_fx[i].value & mask, &pt_pFrame, &omask );
		pack_bit( hBstr->ind_list[i].value & mask, &pt_pFrame, &omask );
		j++;
		}
		mask >>= 1;

lib_com/cldfb.c

+29 −28

Original line number	Diff line number	Diff line
		@@ -1716,7 +1716,7 @@ ivas_error openCldfb_ivas_fx(
		return IVAS_ERR_OK;
		}

		ivas_error openCldfb_ivas_enc(
		ivas_error openCldfb_ivas(
		HANDLE_CLDFB_FILTER_BANK h_cldfb, / i/o: filter bank handle */
		CLDFB_TYPE type, /* i : analysis or synthesis */
		const int32_t sampling_rate, /* i : sampling rate */
		@@ -1734,25 +1734,17 @@ ivas_error openCldfb_ivas_enc(
		hs->type = type;
		hs->prototype = prototype;

		configureCldfb_ivas_enc( hs, sampling_rate );
		configureCldfb_ivas( hs, sampling_rate );
		hs->memory_flt = NULL;
		hs->memory_length = 0;

		if ( type == CLDFB_ANALYSIS )
		{
		buf_len = hs->p_filter_length - hs->no_channels;
		#ifdef IVAS_FLOAT_FIXED
		hs->FilterStates = (Word16 ) malloc( ( 9 + 16 ) CLDFB_getNumChannels( sampling_rate ) * sizeof( Word16 ) );
		hs->FilterStates_eg = 0;
		#endif
		}
		else
		{
		buf_len = hs->p_filter_length;
		#ifdef IVAS_FLOAT_FIXED
		hs->FilterStates = (Word16 ) malloc( 2 ( 9 + 16 ) * CLDFB_getNumChannels( sampling_rate ) * sizeof( Word16 ) );
		hs->FilterStates_eg = 0;
		#endif
		}

		if ( ( hs->cldfb_state = (float ) malloc( buf_len sizeof( float ) ) ) == NULL )
		@@ -1768,8 +1760,7 @@ ivas_error openCldfb_ivas_enc(
		hs->cldfb_state_length = buf_len; // Temporarily added to store the length of buffer
		hs->cldfb_size = buf_len; /for having original size at intermediatery conversion, will be removed on removing conversion/
		set32_fx( hs->cldfb_state_fx, 0, buf_len );
		set16_fx( hs->FilterStates, 0, i_mult( 9 + 16, hs->no_channels ) );
		set16_fx( hs->FilterStates_e, 0, sizeof( hs->FilterStates_e ) / sizeof( hs->FilterStates_e[0] ) );
		hs->Q_cldfb_state = Q11;
		#endif // IVAS_FLOAT_FIXED


		@@ -1777,6 +1768,7 @@ ivas_error openCldfb_ivas_enc(

		return IVAS_ERR_OK;
		}
		#else
		ivas_error openCldfb_ivas(
		HANDLE_CLDFB_FILTER_BANK h_cldfb, / i/o: filter bank handle */
		CLDFB_TYPE type, /* i : analysis or synthesis */
		@@ -1812,25 +1804,15 @@ ivas_error openCldfb_ivas(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for CLDFB" );
		}
		set_f( hs->cldfb_state, 0.0f, buf_len );
		#ifdef IVAS_FLOAT_FIXED
		if ( ( hs->cldfb_state_fx = (Word32 ) malloc( buf_len sizeof( Word32 ) ) ) == NULL )
		{
		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
		hs->cldfb_size = buf_len; /for having original size at intermediatery conversion, will be removed on removing conversion/
		set32_fx( hs->cldfb_state_fx, 0, buf_len );
		hs->Q_cldfb_state = Q11;
		#endif // IVAS_FLOAT_FIXED

		set_f( hs->cldfb_state, 0.0f, buf_len );

		*h_cldfb = hs;

		return IVAS_ERR_OK;
		}
		#else
		ivas_error openCldfb_ivas(
		#endif
		ivas_error openCldfb_ivas_enc(
		HANDLE_CLDFB_FILTER_BANK h_cldfb, / i/o: filter bank handle */
		CLDFB_TYPE type, /* i : analysis or synthesis */
		const int32_t sampling_rate, /* i : sampling rate */
		@@ -1848,31 +1830,50 @@ ivas_error openCldfb_ivas(
		hs->type = type;
		hs->prototype = prototype;

		configureCldfb_ivas( hs, sampling_rate );
		configureCldfb_ivas_enc( hs, sampling_rate );
		hs->memory_flt = NULL;
		hs->memory_length = 0;

		if ( type == CLDFB_ANALYSIS )
		{
		buf_len = hs->p_filter_length - hs->no_channels;
		#ifdef IVAS_FLOAT_FIXED
		hs->FilterStates = (Word16 ) malloc( ( 9 + 16 ) CLDFB_getNumChannels( sampling_rate ) * sizeof( Word16 ) );
		hs->FilterStates_eg = 0;
		#endif
		}
		else
		{
		buf_len = hs->p_filter_length;
		#ifdef IVAS_FLOAT_FIXED
		hs->FilterStates = (Word16 ) malloc( 2 ( 9 + 16 ) * CLDFB_getNumChannels( sampling_rate ) * sizeof( Word16 ) );
		hs->FilterStates_eg = 0;
		#endif
		}

		if ( ( hs->cldfb_state = (float ) malloc( buf_len sizeof( float ) ) ) == NULL )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for CLDFB" );
		}

		set_f( hs->cldfb_state, 0.0f, buf_len );
		#ifdef IVAS_FLOAT_FIXED
		if ( ( hs->cldfb_state_fx = (Word32 ) malloc( buf_len sizeof( Word32 ) ) ) == NULL )
		{
		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
		hs->cldfb_size = buf_len; /for having original size at intermediatery conversion, will be removed on removing conversion/
		set32_fx( hs->cldfb_state_fx, 0, buf_len );
		set16_fx( hs->FilterStates, 0, i_mult( 9 + 16, hs->no_channels ) );
		set16_fx( hs->FilterStates_e, 0, sizeof( hs->FilterStates_e ) / sizeof( hs->FilterStates_e[0] ) );
		#endif // IVAS_FLOAT_FIXED


		*h_cldfb = hs;

		return IVAS_ERR_OK;
		}
		#endif

		/-------------------------------------------------------------------
		* resampleCldfb_ivas()
		*

lib_com/float_to_fix_ops.c

+8 −9

Original line number	Diff line number	Diff line
		@@ -5,17 +5,17 @@
		#include "options.h"
		#include "prot.h"
		#include "prot_fx2.h"

		Word32 floatToFixed( float f, Word16 Q )
		{
		Word64 result_32;
		if ( f == 1.0f && Q == Q15 )
		return MAX16B;
		if ( f == 1.0f && Q == Q31 )
		return MAXVAL_WORD32;
		if ( Q < 0 )
		return (Word32) ( (float) ( f ) / (double) ( 1llu << ( -Q ) ) + ( f >= 0 ? 0.5 : -0.5 ) );
		result_32 = (Word64) ( (float) ( f ) / (double) ( 1llu << ( -Q ) ) + ( f >= 0 ? 0.5 : -0.5 ) );
		else
		{
		Word64 result_32;
		result_32 = (Word64) ( f * (double) ( 1llu << Q ) + ( f >= 0 ? 0.5 : -0.5 ) );
		if ( result_32 > MAX_32 )
		return MAX_32;
		@@ -23,7 +23,6 @@ Word32 floatToFixed( float f, Word16 Q )
		return MIN_32;
		return (Word32) result_32;
		}
		}

		float fixedToFloat( Word32 i, Word16 Q )
		{

lib_com/ivas_arith.c

+117 −2

File changed.

Preview size limit exceeded, changes collapsed.