WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavcodec/aaccoder.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* AAC coefficients encoder
		3	* Copyright (C) 2008-2009 Konstantin Shishkov
		4	*
		5	* This file is part of FFmpeg.
		6	*
		7	* FFmpeg is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Lesser General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2.1 of the License, or (at your option) any later version.
		11	*
		12	* FFmpeg is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Lesser General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Lesser General Public
		18	* License along with FFmpeg; if not, write to the Free Software
		19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		20	*/
		21
		22	/**
		23	* @file
		24	* AAC coefficients encoder
		25	*/
		26
		27	/***********************************
		28	* TODOs:
		29	* speedup quantizer selection
		30	* add sane pulse detection
		31	***********************************/
		32
		33	#include "libavutil/libm.h" // brought forward to work around cygwin header breakage
		34
		35	#include
		36	#include "libavutil/mathematics.h"
		37	#include "avcodec.h"
		38	#include "put_bits.h"
		39	#include "aac.h"
		40	#include "aacenc.h"
		41	#include "aactab.h"
		42
		43	/** bits needed to code codebook run value for long windows */
		44	static const uint8_t run_value_bits_long[64] = {
		45	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
		46	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10,
		47	10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
		48	10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
		49	};
		50
		51	/** bits needed to code codebook run value for short windows */
		52	static const uint8_t run_value_bits_short[16] = {
		53	3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
		54	};
		55
		56	static const uint8_t *run_value_bits[2] = {
		57	run_value_bits_long, run_value_bits_short
		58	};
		59
		60
		61	/**
		62	* Quantize one coefficient.
		63	* @return absolute value of the quantized coefficient
		64	* @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
		65	*/
		66	static av_always_inline int quant(float coef, const float Q)
		67	{
		68	float a = coef * Q;
		69	return sqrtf(a * sqrtf(a)) + 0.4054;
		70	}
		71
		72	static void quantize_bands(int out, const float in, const float *scaled,
		73	int size, float Q34, int is_signed, int maxval)
		74	{
		75	int i;
		76	double qc;
		77	for (i = 0; i < size; i++) {
		78	qc = scaled[i] * Q34;
		79	out[i] = (int)FFMIN(qc + 0.4054, (double)maxval);
		80	if (is_signed && in[i] < 0.0f) {
		81	out[i] = -out[i];
		82	}
		83	}
		84	}
		85
		86	static void abs_pow34_v(float out, const float in, const int size)
		87	{
		88	#ifndef USE_REALLY_FULL_SEARCH
		89	int i;
		90	for (i = 0; i < size; i++) {
		91	float a = fabsf(in[i]);
		92	out[i] = sqrtf(a * sqrtf(a));
		93	}
		94	#endif /* USE_REALLY_FULL_SEARCH */
		95	}
		96
		97	static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17};
		98	static const uint8_t aac_cb_maxval[12] = {0, 1, 1, 2, 2, 4, 4, 7, 7, 12, 12, 16};
		99
		100	/**
		101	* Calculate rate distortion cost for quantizing with given codebook
		102	*
		103	* @return quantization distortion
		104	*/
		105	static av_always_inline float quantize_and_encode_band_cost_template(
		106	struct AACEncContext *s,
		107	PutBitContext pb, const float in,
		108	const float *scaled, int size, int scale_idx,
		109	int cb, const float lambda, const float uplim,
		110	int *bits, int BT_ZERO, int BT_UNSIGNED,
		111	int BT_PAIR, int BT_ESC)
		112	{
		113	const int q_idx = POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512;
		114	const float Q = ff_aac_pow2sf_tab [q_idx];
		115	const float Q34 = ff_aac_pow34sf_tab[q_idx];
		116	const float IQ = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
		117	const float CLIPPED_ESCAPE = 165140.0f*IQ;
		118	int i, j;
		119	float cost = 0;
		120	const int dim = BT_PAIR ? 2 : 4;
		121	int resbits = 0;
		122	const int range = aac_cb_range[cb];
		123	const int maxval = aac_cb_maxval[cb];
		124	int off;
		125
		126	if (BT_ZERO) {
		127	for (i = 0; i < size; i++)
		128	cost += in[i]*in[i];
		129	if (bits)
		130	*bits = 0;
		131	return cost * lambda;
		132	}
		133	if (!scaled) {
		134	abs_pow34_v(s->scoefs, in, size);
		135	scaled = s->scoefs;
		136	}
		137	quantize_bands(s->qcoefs, in, scaled, size, Q34, !BT_UNSIGNED, maxval);
		138	if (BT_UNSIGNED) {
		139	off = 0;
		140	} else {
		141	off = maxval;
		142	}
		143	for (i = 0; i < size; i += dim) {
		144	const float *vec;
		145	int *quants = s->qcoefs + i;
		146	int curidx = 0;
		147	int curbits;
		148	float rd = 0.0f;
		149	for (j = 0; j < dim; j++) {
		150	curidx *= range;
		151	curidx += quants[j] + off;
		152	}
		153	curbits = ff_aac_spectral_bits[cb-1][curidx];
		154	vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
		155	if (BT_UNSIGNED) {
		156	for (j = 0; j < dim; j++) {
		157	float t = fabsf(in[i+j]);
		158	float di;
		159	if (BT_ESC && vec[j] == 64.0f) { //FIXME: slow
		160	if (t >= CLIPPED_ESCAPE) {
		161	di = t - CLIPPED_ESCAPE;
		162	curbits += 21;
		163	} else {
		164	int c = av_clip(quant(t, Q), 0, 8191);
		165	di = t - ccbrtf(c)IQ;
		166	curbits += av_log2(c)*2 - 4 + 1;
		167	}
		168	} else {
		169	di = t - vec[j]*IQ;
		170	}
		171	if (vec[j] != 0.0f)
		172	curbits++;
		173	rd += di*di;
		174	}
		175	} else {
		176	for (j = 0; j < dim; j++) {
		177	float di = in[i+j] - vec[j]*IQ;
		178	rd += di*di;
		179	}
		180	}
		181	cost += rd * lambda + curbits;
		182	resbits += curbits;
		183	if (cost >= uplim)
		184	return uplim;
		185	if (pb) {
		186	put_bits(pb, ff_aac_spectral_bits[cb-1][curidx], ff_aac_spectral_codes[cb-1][curidx]);
		187	if (BT_UNSIGNED)
		188	for (j = 0; j < dim; j++)
		189	if (ff_aac_codebook_vectors[cb-1][curidx*dim+j] != 0.0f)
		190	put_bits(pb, 1, in[i+j] < 0.0f);
		191	if (BT_ESC) {
		192	for (j = 0; j < 2; j++) {
		193	if (ff_aac_codebook_vectors[cb-1][curidx*2+j] == 64.0f) {
		194	int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
		195	int len = av_log2(coef);
		196
		197	put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
		198	put_bits(pb, len, coef & ((1 << len) - 1));
		199	}
		200	}
		201	}
		202	}
		203	}
		204
		205	if (bits)
		206	*bits = resbits;
		207	return cost;
		208	}
		209
		210	#define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC) \
		211	static float quantize_and_encode_band_cost_ ## NAME( \
		212	struct AACEncContext *s, \
		213	PutBitContext pb, const float in, \
		214	const float *scaled, int size, int scale_idx, \
		215	int cb, const float lambda, const float uplim, \
		216	int *bits) { \
		217	return quantize_and_encode_band_cost_template( \
		218	s, pb, in, scaled, size, scale_idx, \
		219	BT_ESC ? ESC_BT : cb, lambda, uplim, bits, \
		220	BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC); \
		221	}
		222
		223	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO, 1, 0, 0, 0)
		224	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0)
		225	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0)
		226	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0)
		227	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0)
		228	QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC, 0, 1, 1, 1)
		229
		230	static float (*const quantize_and_encode_band_cost_arr[])(
		231	struct AACEncContext *s,
		232	PutBitContext pb, const float in,
		233	const float *scaled, int size, int scale_idx,
		234	int cb, const float lambda, const float uplim,
		235	int *bits) = {
		236	quantize_and_encode_band_cost_ZERO,
		237	quantize_and_encode_band_cost_SQUAD,
		238	quantize_and_encode_band_cost_SQUAD,
		239	quantize_and_encode_band_cost_UQUAD,
		240	quantize_and_encode_band_cost_UQUAD,
		241	quantize_and_encode_band_cost_SPAIR,
		242	quantize_and_encode_band_cost_SPAIR,
		243	quantize_and_encode_band_cost_UPAIR,
		244	quantize_and_encode_band_cost_UPAIR,
		245	quantize_and_encode_band_cost_UPAIR,
		246	quantize_and_encode_band_cost_UPAIR,
		247	quantize_and_encode_band_cost_ESC,
		248	};
		249
		250	#define quantize_and_encode_band_cost( \
		251	s, pb, in, scaled, size, scale_idx, cb, \
		252	lambda, uplim, bits) \
		253	quantize_and_encode_band_cost_arr[cb]( \
		254	s, pb, in, scaled, size, scale_idx, cb, \
		255	lambda, uplim, bits)
		256
		257	static float quantize_band_cost(struct AACEncContext s, const float in,
		258	const float *scaled, int size, int scale_idx,
		259	int cb, const float lambda, const float uplim,
		260	int *bits)
		261	{
		262	return quantize_and_encode_band_cost(s, NULL, in, scaled, size, scale_idx,
		263	cb, lambda, uplim, bits);
		264	}
		265
		266	static void quantize_and_encode_band(struct AACEncContext s, PutBitContext pb,
		267	const float *in, int size, int scale_idx,
		268	int cb, const float lambda)
		269	{
		270	quantize_and_encode_band_cost(s, pb, in, NULL, size, scale_idx, cb, lambda,
		271	INFINITY, NULL);
		272	}
		273
		274	static float find_max_val(int group_len, int swb_size, const float *scaled) {
		275	float maxval = 0.0f;
		276	int w2, i;
		277	for (w2 = 0; w2 < group_len; w2++) {
		278	for (i = 0; i < swb_size; i++) {
		279	maxval = FFMAX(maxval, scaled[w2*128+i]);
		280	}
		281	}
		282	return maxval;
		283	}
		284
		285	static int find_min_book(float maxval, int sf) {
		286	float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
		287	float Q34 = sqrtf(Q * sqrtf(Q));
		288	int qmaxval, cb;
		289	qmaxval = maxval * Q34 + 0.4054f;
		290	if (qmaxval == 0) cb = 0;
		291	else if (qmaxval == 1) cb = 1;
		292	else if (qmaxval == 2) cb = 3;
		293	else if (qmaxval <= 4) cb = 5;
		294	else if (qmaxval <= 7) cb = 7;
		295	else if (qmaxval <= 12) cb = 9;
		296	else cb = 11;
		297	return cb;
		298	}
		299
		300	/**
		301	* structure used in optimal codebook search
		302	*/
		303	typedef struct BandCodingPath {
		304	int prev_idx; ///< pointer to the previous path point
		305	float cost; ///< path cost
		306	int run;
		307	} BandCodingPath;
		308
		309	/**
		310	* Encode band info for single window group bands.
		311	*/
		312	static void encode_window_bands_info(AACEncContext s, SingleChannelElement sce,
		313	int win, int group_len, const float lambda)
		314	{
		315	BandCodingPath path[120][12];
		316	int w, swb, cb, start, size;
		317	int i, j;
		318	const int max_sfb = sce->ics.max_sfb;
		319	const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
		320	const int run_esc = (1 << run_bits) - 1;
		321	int idx, ppos, count;
		322	int stackrun[120], stackcb[120], stack_len;
		323	float next_minrd = INFINITY;
		324	int next_mincb = 0;
		325
		326	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
		327	start = win*128;
		328	for (cb = 0; cb < 12; cb++) {
		329	path[0][cb].cost = 0.0f;
		330	path[0][cb].prev_idx = -1;
		331	path[0][cb].run = 0;
		332	}
		333	for (swb = 0; swb < max_sfb; swb++) {
		334	size = sce->ics.swb_sizes[swb];
		335	if (sce->zeroes[win*16 + swb]) {
		336	for (cb = 0; cb < 12; cb++) {
		337	path[swb+1][cb].prev_idx = cb;
		338	path[swb+1][cb].cost = path[swb][cb].cost;
		339	path[swb+1][cb].run = path[swb][cb].run + 1;
		340	}
		341	} else {
		342	float minrd = next_minrd;
		343	int mincb = next_mincb;
		344	next_minrd = INFINITY;
		345	next_mincb = 0;
		346	for (cb = 0; cb < 12; cb++) {
		347	float cost_stay_here, cost_get_here;
		348	float rd = 0.0f;
		349	for (w = 0; w < group_len; w++) {
		350	FFPsyBand band = &s->psy.ch[s->cur_channel].psy_bands[(win+w)16+swb];
		351	rd += quantize_band_cost(s, sce->coeffs + start + w*128,
		352	s->scoefs + start + w*128, size,
		353	sce->sf_idx[(win+w)*16+swb], cb,
		354	lambda / band->threshold, INFINITY, NULL);
		355	}
		356	cost_stay_here = path[swb][cb].cost + rd;
		357	cost_get_here = minrd + rd + run_bits + 4;
		358	if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
		359	!= run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
		360	cost_stay_here += run_bits;
		361	if (cost_get_here < cost_stay_here) {
		362	path[swb+1][cb].prev_idx = mincb;
		363	path[swb+1][cb].cost = cost_get_here;
		364	path[swb+1][cb].run = 1;
		365	} else {
		366	path[swb+1][cb].prev_idx = cb;
		367	path[swb+1][cb].cost = cost_stay_here;
		368	path[swb+1][cb].run = path[swb][cb].run + 1;
		369	}
		370	if (path[swb+1][cb].cost < next_minrd) {
		371	next_minrd = path[swb+1][cb].cost;
		372	next_mincb = cb;
		373	}
		374	}
		375	}
		376	start += sce->ics.swb_sizes[swb];
		377	}
		378
		379	//convert resulting path from backward-linked list
		380	stack_len = 0;
		381	idx = 0;
		382	for (cb = 1; cb < 12; cb++)
		383	if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
		384	idx = cb;
		385	ppos = max_sfb;
		386	while (ppos > 0) {
		387	cb = idx;
		388	stackrun[stack_len] = path[ppos][cb].run;
		389	stackcb [stack_len] = cb;
		390	idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
		391	ppos -= path[ppos][cb].run;
		392	stack_len++;
		393	}
		394	//perform actual band info encoding
		395	start = 0;
		396	for (i = stack_len - 1; i >= 0; i--) {
		397	put_bits(&s->pb, 4, stackcb[i]);
		398	count = stackrun[i];
		399	memset(sce->zeroes + win*16 + start, !stackcb[i], count);
		400	//XXX: memset when band_type is also uint8_t
		401	for (j = 0; j < count; j++) {
		402	sce->band_type[win*16 + start] = stackcb[i];
		403	start++;
		404	}
		405	while (count >= run_esc) {
		406	put_bits(&s->pb, run_bits, run_esc);
		407	count -= run_esc;
		408	}
		409	put_bits(&s->pb, run_bits, count);
		410	}
		411	}
		412
		413	static void codebook_trellis_rate(AACEncContext s, SingleChannelElement sce,
		414	int win, int group_len, const float lambda)
		415	{
		416	BandCodingPath path[120][12];
		417	int w, swb, cb, start, size;
		418	int i, j;
		419	const int max_sfb = sce->ics.max_sfb;
		420	const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
		421	const int run_esc = (1 << run_bits) - 1;
		422	int idx, ppos, count;
		423	int stackrun[120], stackcb[120], stack_len;
		424	float next_minbits = INFINITY;
		425	int next_mincb = 0;
		426
		427	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
		428	start = win*128;
		429	for (cb = 0; cb < 12; cb++) {
		430	path[0][cb].cost = run_bits+4;
		431	path[0][cb].prev_idx = -1;
		432	path[0][cb].run = 0;
		433	}
		434	for (swb = 0; swb < max_sfb; swb++) {
		435	size = sce->ics.swb_sizes[swb];
		436	if (sce->zeroes[win*16 + swb]) {
		437	float cost_stay_here = path[swb][0].cost;
		438	float cost_get_here = next_minbits + run_bits + 4;
		439	if ( run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]
		440	!= run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])
		441	cost_stay_here += run_bits;
		442	if (cost_get_here < cost_stay_here) {
		443	path[swb+1][0].prev_idx = next_mincb;
		444	path[swb+1][0].cost = cost_get_here;
		445	path[swb+1][0].run = 1;
		446	} else {
		447	path[swb+1][0].prev_idx = 0;
		448	path[swb+1][0].cost = cost_stay_here;
		449	path[swb+1][0].run = path[swb][0].run + 1;
		450	}
		451	next_minbits = path[swb+1][0].cost;
		452	next_mincb = 0;
		453	for (cb = 1; cb < 12; cb++) {
		454	path[swb+1][cb].cost = 61450;
		455	path[swb+1][cb].prev_idx = -1;
		456	path[swb+1][cb].run = 0;
		457	}
		458	} else {
		459	float minbits = next_minbits;
		460	int mincb = next_mincb;
		461	int startcb = sce->band_type[win*16+swb];
		462	next_minbits = INFINITY;
		463	next_mincb = 0;
		464	for (cb = 0; cb < startcb; cb++) {
		465	path[swb+1][cb].cost = 61450;
		466	path[swb+1][cb].prev_idx = -1;
		467	path[swb+1][cb].run = 0;
		468	}
		469	for (cb = startcb; cb < 12; cb++) {
		470	float cost_stay_here, cost_get_here;
		471	float bits = 0.0f;
		472	for (w = 0; w < group_len; w++) {
		473	bits += quantize_band_cost(s, sce->coeffs + start + w*128,
		474	s->scoefs + start + w*128, size,
		475	sce->sf_idx[(win+w)*16+swb], cb,
		476	0, INFINITY, NULL);
		477	}
		478	cost_stay_here = path[swb][cb].cost + bits;
		479	cost_get_here = minbits + bits + run_bits + 4;
		480	if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
		481	!= run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
		482	cost_stay_here += run_bits;
		483	if (cost_get_here < cost_stay_here) {
		484	path[swb+1][cb].prev_idx = mincb;
		485	path[swb+1][cb].cost = cost_get_here;
		486	path[swb+1][cb].run = 1;
		487	} else {
		488	path[swb+1][cb].prev_idx = cb;
		489	path[swb+1][cb].cost = cost_stay_here;
		490	path[swb+1][cb].run = path[swb][cb].run + 1;
		491	}
		492	if (path[swb+1][cb].cost < next_minbits) {
		493	next_minbits = path[swb+1][cb].cost;
		494	next_mincb = cb;
		495	}
		496	}
		497	}
		498	start += sce->ics.swb_sizes[swb];
		499	}
		500
		501	//convert resulting path from backward-linked list
		502	stack_len = 0;
		503	idx = 0;
		504	for (cb = 1; cb < 12; cb++)
		505	if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
		506	idx = cb;
		507	ppos = max_sfb;
		508	while (ppos > 0) {
		509	av_assert1(idx >= 0);
		510	cb = idx;
		511	stackrun[stack_len] = path[ppos][cb].run;
		512	stackcb [stack_len] = cb;
		513	idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
		514	ppos -= path[ppos][cb].run;
		515	stack_len++;
		516	}
		517	//perform actual band info encoding
		518	start = 0;
		519	for (i = stack_len - 1; i >= 0; i--) {
		520	put_bits(&s->pb, 4, stackcb[i]);
		521	count = stackrun[i];
		522	memset(sce->zeroes + win*16 + start, !stackcb[i], count);
		523	//XXX: memset when band_type is also uint8_t
		524	for (j = 0; j < count; j++) {
		525	sce->band_type[win*16 + start] = stackcb[i];
		526	start++;
		527	}
		528	while (count >= run_esc) {
		529	put_bits(&s->pb, run_bits, run_esc);
		530	count -= run_esc;
		531	}
		532	put_bits(&s->pb, run_bits, count);
		533	}
		534	}
		535
		536	/** Return the minimum scalefactor where the quantized coef does not clip. */
		537	static av_always_inline uint8_t coef2minsf(float coef) {
		538	return av_clip_uint8(log2f(coef)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
		539	}
		540
		541	/** Return the maximum scalefactor where the quantized coef is not zero. */
		542	static av_always_inline uint8_t coef2maxsf(float coef) {
		543	return av_clip_uint8(log2f(coef)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512);
		544	}
		545
		546	typedef struct TrellisPath {
		547	float cost;
		548	int prev;
		549	} TrellisPath;
		550
		551	#define TRELLIS_STAGES 121
		552	#define TRELLIS_STATES (SCALE_MAX_DIFF+1)
		553
		554	static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s,
		555	SingleChannelElement *sce,
		556	const float lambda)
		557	{
		558	int q, w, w2, g, start = 0;
		559	int i, j;
		560	int idx;
		561	TrellisPath paths[TRELLIS_STAGES][TRELLIS_STATES];
		562	int bandaddr[TRELLIS_STAGES];
		563	int minq;
		564	float mincost;
		565	float q0f = FLT_MAX, q1f = 0.0f, qnrgf = 0.0f;
		566	int q0, q1, qcnt = 0;
		567
		568	for (i = 0; i < 1024; i++) {
		569	float t = fabsf(sce->coeffs[i]);
		570	if (t > 0.0f) {
		571	q0f = FFMIN(q0f, t);
		572	q1f = FFMAX(q1f, t);
		573	qnrgf += t*t;
		574	qcnt++;
		575	}
		576	}
		577
		578	if (!qcnt) {
		579	memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
		580	memset(sce->zeroes, 1, sizeof(sce->zeroes));
		581	return;
		582	}
		583
		584	//minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
		585	q0 = coef2minsf(q0f);
		586	//maximum scalefactor index is when maximum coefficient after quantizing is still not zero
		587	q1 = coef2maxsf(q1f);
		588	if (q1 - q0 > 60) {
		589	int q0low = q0;
		590	int q1high = q1;
		591	//minimum scalefactor index is when maximum nonzero coefficient after quantizing is not clipped
		592	int qnrg = av_clip_uint8(log2f(sqrtf(qnrgf/qcnt))*4 - 31 + SCALE_ONE_POS - SCALE_DIV_512);
		593	q1 = qnrg + 30;
		594	q0 = qnrg - 30;
		595	if (q0 < q0low) {
		596	q1 += q0low - q0;
		597	q0 = q0low;
		598	} else if (q1 > q1high) {
		599	q0 -= q1 - q1high;
		600	q1 = q1high;
		601	}
		602	}
		603
		604	for (i = 0; i < TRELLIS_STATES; i++) {
		605	paths[0][i].cost = 0.0f;
		606	paths[0][i].prev = -1;
		607	}
		608	for (j = 1; j < TRELLIS_STAGES; j++) {
		609	for (i = 0; i < TRELLIS_STATES; i++) {
		610	paths[j][i].cost = INFINITY;
		611	paths[j][i].prev = -2;
		612	}
		613	}
		614	idx = 1;
		615	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
		616	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		617	start = w*128;
		618	for (g = 0; g < sce->ics.num_swb; g++) {
		619	const float *coefs = sce->coeffs + start;
		620	float qmin, qmax;
		621	int nz = 0;
		622
		623	bandaddr[idx] = w * 16 + g;
		624	qmin = INT_MAX;
		625	qmax = 0.0f;
		626	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		627	FFPsyBand band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)16+g];
		628	if (band->energy <= band->threshold \|\| band->threshold == 0.0f) {
		629	sce->zeroes[(w+w2)*16+g] = 1;
		630	continue;
		631	}
		632	sce->zeroes[(w+w2)*16+g] = 0;
		633	nz = 1;
		634	for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
		635	float t = fabsf(coefs[w2*128+i]);
		636	if (t > 0.0f)
		637	qmin = FFMIN(qmin, t);
		638	qmax = FFMAX(qmax, t);
		639	}
		640	}
		641	if (nz) {
		642	int minscale, maxscale;
		643	float minrd = INFINITY;
		644	float maxval;
		645	//minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
		646	minscale = coef2minsf(qmin);
		647	//maximum scalefactor index is when maximum coefficient after quantizing is still not zero
		648	maxscale = coef2maxsf(qmax);
		649	minscale = av_clip(minscale - q0, 0, TRELLIS_STATES - 1);
		650	maxscale = av_clip(maxscale - q0, 0, TRELLIS_STATES);
		651	maxval = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], s->scoefs+start);
		652	for (q = minscale; q < maxscale; q++) {
		653	float dist = 0;
		654	int cb = find_min_book(maxval, sce->sf_idx[w*16+g]);
		655	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		656	FFPsyBand band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)16+g];
		657	dist += quantize_band_cost(s, coefs + w2128, s->scoefs + start + w2128, sce->ics.swb_sizes[g],
		658	q + q0, cb, lambda / band->threshold, INFINITY, NULL);
		659	}
		660	minrd = FFMIN(minrd, dist);
		661
		662	for (i = 0; i < q1 - q0; i++) {
		663	float cost;
		664	cost = paths[idx - 1][i].cost + dist
		665	+ ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
		666	if (cost < paths[idx][q].cost) {
		667	paths[idx][q].cost = cost;
		668	paths[idx][q].prev = i;
		669	}
		670	}
		671	}
		672	} else {
		673	for (q = 0; q < q1 - q0; q++) {
		674	paths[idx][q].cost = paths[idx - 1][q].cost + 1;
		675	paths[idx][q].prev = q;
		676	}
		677	}
		678	sce->zeroes[w*16+g] = !nz;
		679	start += sce->ics.swb_sizes[g];
		680	idx++;
		681	}
		682	}
		683	idx--;
		684	mincost = paths[idx][0].cost;
		685	minq = 0;
		686	for (i = 1; i < TRELLIS_STATES; i++) {
		687	if (paths[idx][i].cost < mincost) {
		688	mincost = paths[idx][i].cost;
		689	minq = i;
		690	}
		691	}
		692	while (idx) {
		693	sce->sf_idx[bandaddr[idx]] = minq + q0;
		694	minq = paths[idx][minq].prev;
		695	idx--;
		696	}
		697	//set the same quantizers inside window groups
		698	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
		699	for (g = 0; g < sce->ics.num_swb; g++)
		700	for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
		701	sce->sf_idx[(w+w2)16+g] = sce->sf_idx[w16+g];
		702	}
		703
		704	/**
		705	* two-loop quantizers search taken from ISO 13818-7 Appendix C
		706	*/
		707	static void search_for_quantizers_twoloop(AVCodecContext *avctx,
		708	AACEncContext *s,
		709	SingleChannelElement *sce,
		710	const float lambda)
		711	{
		712	int start = 0, i, w, w2, g;
		713	int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);
		714	float dists[128] = { 0 }, uplims[128];
		715	float maxvals[128];
		716	int fflag, minscaler;
		717	int its = 0;
		718	int allz = 0;
		719	float minthr = INFINITY;
		720
		721	// for values above this the decoder might end up in an endless loop
		722	// due to always having more bits than what can be encoded.
		723	destbits = FFMIN(destbits, 5800);
		724	//XXX: some heuristic to determine initial quantizers will reduce search time
		725	//determine zero bands and upper limits
		726	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		727	for (g = 0; g < sce->ics.num_swb; g++) {
		728	int nz = 0;
		729	float uplim = 0.0f;
		730	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		731	FFPsyBand band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)16+g];
		732	uplim += band->threshold;
		733	if (band->energy <= band->threshold \|\| band->threshold == 0.0f) {
		734	sce->zeroes[(w+w2)*16+g] = 1;
		735	continue;
		736	}
		737	nz = 1;
		738	}
		739	uplims[w16+g] = uplim 512;
		740	sce->zeroes[w*16+g] = !nz;
		741	if (nz)
		742	minthr = FFMIN(minthr, uplim);
		743	allz \|= nz;
		744	}
		745	}
		746	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		747	for (g = 0; g < sce->ics.num_swb; g++) {
		748	if (sce->zeroes[w*16+g]) {
		749	sce->sf_idx[w*16+g] = SCALE_ONE_POS;
		750	continue;
		751	}
		752	sce->sf_idx[w16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w16+g]/minthr)*4,59);
		753	}
		754	}
		755
		756	if (!allz)
		757	return;
		758	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
		759
		760	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		761	start = w*128;
		762	for (g = 0; g < sce->ics.num_swb; g++) {
		763	const float *scaled = s->scoefs + start;
		764	maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);
		765	start += sce->ics.swb_sizes[g];
		766	}
		767	}
		768
		769	//perform two-loop search
		770	//outer loop - improve quality
		771	do {
		772	int tbits, qstep;
		773	minscaler = sce->sf_idx[0];
		774	//inner loop - quantize spectrum to fit into given number of bits
		775	qstep = its ? 1 : 32;
		776	do {
		777	int prev = -1;
		778	tbits = 0;
		779	fflag = 0;
		780	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		781	start = w*128;
		782	for (g = 0; g < sce->ics.num_swb; g++) {
		783	const float *coefs = sce->coeffs + start;
		784	const float *scaled = s->scoefs + start;
		785	int bits = 0;
		786	int cb;
		787	float dist = 0.0f;
		788
		789	if (sce->zeroes[w16+g] \|\| sce->sf_idx[w16+g] >= 218) {
		790	start += sce->ics.swb_sizes[g];
		791	continue;
		792	}
		793	minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
		794	cb = find_min_book(maxvals[w16+g], sce->sf_idx[w16+g]);
		795	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		796	int b;
		797	dist += quantize_band_cost(s, coefs + w2*128,
		798	scaled + w2*128,
		799	sce->ics.swb_sizes[g],
		800	sce->sf_idx[w*16+g],
		801	cb,
		802	1.0f,
		803	INFINITY,
		804	&b);
		805	bits += b;
		806	}
		807	dists[w*16+g] = dist - bits;
		808	if (prev != -1) {
		809	bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
		810	}
		811	tbits += bits;
		812	start += sce->ics.swb_sizes[g];
		813	prev = sce->sf_idx[w*16+g];
		814	}
		815	}
		816	if (tbits > destbits) {
		817	for (i = 0; i < 128; i++)
		818	if (sce->sf_idx[i] < 218 - qstep)
		819	sce->sf_idx[i] += qstep;
		820	} else {
		821	for (i = 0; i < 128; i++)
		822	if (sce->sf_idx[i] > 60 - qstep)
		823	sce->sf_idx[i] -= qstep;
		824	}
		825	qstep >>= 1;
		826	if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)
		827	qstep = 1;
		828	} while (qstep);
		829
		830	fflag = 0;
		831	minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
		832	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		833	for (g = 0; g < sce->ics.num_swb; g++) {
		834	int prevsc = sce->sf_idx[w*16+g];
		835	if (dists[w16+g] > uplims[w16+g] && sce->sf_idx[w*16+g] > 60) {
		836	if (find_min_book(maxvals[w16+g], sce->sf_idx[w16+g]-1))
		837	sce->sf_idx[w*16+g]--;
		838	else //Try to make sure there is some energy in every band
		839	sce->sf_idx[w*16+g]-=2;
		840	}
		841	sce->sf_idx[w16+g] = av_clip(sce->sf_idx[w16+g], minscaler, minscaler + SCALE_MAX_DIFF);
		842	sce->sf_idx[w16+g] = FFMIN(sce->sf_idx[w16+g], 219);
		843	if (sce->sf_idx[w*16+g] != prevsc)
		844	fflag = 1;
		845	sce->band_type[w16+g] = find_min_book(maxvals[w16+g], sce->sf_idx[w*16+g]);
		846	}
		847	}
		848	its++;
		849	} while (fflag && its < 10);
		850	}
		851
		852	static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s,
		853	SingleChannelElement *sce,
		854	const float lambda)
		855	{
		856	int start = 0, i, w, w2, g;
		857	float uplim[128], maxq[128];
		858	int minq, maxsf;
		859	float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
		860	int last = 0, lastband = 0, curband = 0;
		861	float avg_energy = 0.0;
		862	if (sce->ics.num_windows == 1) {
		863	start = 0;
		864	for (i = 0; i < 1024; i++) {
		865	if (i - start >= sce->ics.swb_sizes[curband]) {
		866	start += sce->ics.swb_sizes[curband];
		867	curband++;
		868	}
		869	if (sce->coeffs[i]) {
		870	avg_energy += sce->coeffs[i] * sce->coeffs[i];
		871	last = i;
		872	lastband = curband;
		873	}
		874	}
		875	} else {
		876	for (w = 0; w < 8; w++) {
		877	const float coeffs = sce->coeffs + w128;
		878	curband = start = 0;
		879	for (i = 0; i < 128; i++) {
		880	if (i - start >= sce->ics.swb_sizes[curband]) {
		881	start += sce->ics.swb_sizes[curband];
		882	curband++;
		883	}
		884	if (coeffs[i]) {
		885	avg_energy += coeffs[i] * coeffs[i];
		886	last = FFMAX(last, i);
		887	lastband = FFMAX(lastband, curband);
		888	}
		889	}
		890	}
		891	}
		892	last++;
		893	avg_energy /= last;
		894	if (avg_energy == 0.0f) {
		895	for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
		896	sce->sf_idx[i] = SCALE_ONE_POS;
		897	return;
		898	}
		899	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		900	start = w*128;
		901	for (g = 0; g < sce->ics.num_swb; g++) {
		902	float *coefs = sce->coeffs + start;
		903	const int size = sce->ics.swb_sizes[g];
		904	int start2 = start, end2 = start + size, peakpos = start;
		905	float maxval = -1, thr = 0.0f, t;
		906	maxq[w*16+g] = 0.0f;
		907	if (g > lastband) {
		908	maxq[w*16+g] = 0.0f;
		909	start += size;
		910	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
		911	memset(coefs + w2128, 0, sizeof(coefs[0])size);
		912	continue;
		913	}
		914	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		915	for (i = 0; i < size; i++) {
		916	float t = coefs[w2128+i]coefs[w2*128+i];
		917	maxq[w16+g] = FFMAX(maxq[w16+g], fabsf(coefs[w2*128 + i]));
		918	thr += t;
		919	if (sce->ics.num_windows == 1 && maxval < t) {
		920	maxval = t;
		921	peakpos = start+i;
		922	}
		923	}
		924	}
		925	if (sce->ics.num_windows == 1) {
		926	start2 = FFMAX(peakpos - 2, start2);
		927	end2 = FFMIN(peakpos + 3, end2);
		928	} else {
		929	start2 -= start;
		930	end2 -= start;
		931	}
		932	start += size;
		933	thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);
		934	t = 1.0 - (1.0 * start2 / last);
		935	uplim[w16+g] = distfact / (1.4 thr + ttt + 0.075);
		936	}
		937	}
		938	memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
		939	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
		940	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		941	start = w*128;
		942	for (g = 0; g < sce->ics.num_swb; g++) {
		943	const float *coefs = sce->coeffs + start;
		944	const float *scaled = s->scoefs + start;
		945	const int size = sce->ics.swb_sizes[g];
		946	int scf, prev_scf, step;
		947	int min_scf = -1, max_scf = 256;
		948	float curdiff;
		949	if (maxq[w*16+g] < 21.544) {
		950	sce->zeroes[w*16+g] = 1;
		951	start += size;
		952	continue;
		953	}
		954	sce->zeroes[w*16+g] = 0;
		955	scf = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2f(1/maxq[w16+g])16/3, 60, 218);
		956	step = 16;
		957	for (;;) {
		958	float dist = 0.0f;
		959	int quant_max;
		960
		961	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		962	int b;
		963	dist += quantize_band_cost(s, coefs + w2*128,
		964	scaled + w2*128,
		965	sce->ics.swb_sizes[g],
		966	scf,
		967	ESC_BT,
		968	lambda,
		969	INFINITY,
		970	&b);
		971	dist -= b;
		972	}
		973	dist *= 1.0f / 512.0f / lambda;
		974	quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[POW_SF2_ZERO - scf + SCALE_ONE_POS - SCALE_DIV_512]);
		975	if (quant_max >= 8191) { // too much, return to the previous quantizer
		976	sce->sf_idx[w*16+g] = prev_scf;
		977	break;
		978	}
		979	prev_scf = scf;
		980	curdiff = fabsf(dist - uplim[w*16+g]);
		981	if (curdiff <= 1.0f)
		982	step = 0;
		983	else
		984	step = log2f(curdiff);
		985	if (dist > uplim[w*16+g])
		986	step = -step;
		987	scf += step;
		988	scf = av_clip_uint8(scf);
		989	step = scf - prev_scf;
		990	if (FFABS(step) <= 1 \|\| (step > 0 && scf >= max_scf) \|\| (step < 0 && scf <= min_scf)) {
		991	sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf);
		992	break;
		993	}
		994	if (step > 0)
		995	min_scf = prev_scf;
		996	else
		997	max_scf = prev_scf;
		998	}
		999	start += size;
		1000	}
		1001	}
		1002	minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
		1003	for (i = 1; i < 128; i++) {
		1004	if (!sce->sf_idx[i])
		1005	sce->sf_idx[i] = sce->sf_idx[i-1];
		1006	else
		1007	minq = FFMIN(minq, sce->sf_idx[i]);
		1008	}
		1009	if (minq == INT_MAX)
		1010	minq = 0;
		1011	minq = FFMIN(minq, SCALE_MAX_POS);
		1012	maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
		1013	for (i = 126; i >= 0; i--) {
		1014	if (!sce->sf_idx[i])
		1015	sce->sf_idx[i] = sce->sf_idx[i+1];
		1016	sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
		1017	}
		1018	}
		1019
		1020	static void search_for_quantizers_fast(AVCodecContext avctx, AACEncContext s,
		1021	SingleChannelElement *sce,
		1022	const float lambda)
		1023	{
		1024	int i, w, w2, g;
		1025	int minq = 255;
		1026
		1027	memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
		1028	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
		1029	for (g = 0; g < sce->ics.num_swb; g++) {
		1030	for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
		1031	FFPsyBand band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)16+g];
		1032	if (band->energy <= band->threshold) {
		1033	sce->sf_idx[(w+w2)*16+g] = 218;
		1034	sce->zeroes[(w+w2)*16+g] = 1;
		1035	} else {
		1036	sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold), 80, 218);
		1037	sce->zeroes[(w+w2)*16+g] = 0;
		1038	}
		1039	minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);
		1040	}
		1041	}
		1042	}
		1043	for (i = 0; i < 128; i++) {
		1044	sce->sf_idx[i] = 140;
		1045	//av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
		1046	}
		1047	//set the same quantizers inside window groups
		1048	for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
		1049	for (g = 0; g < sce->ics.num_swb; g++)
		1050	for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
		1051	sce->sf_idx[(w+w2)16+g] = sce->sf_idx[w16+g];
		1052	}
		1053
		1054	static void search_for_ms(AACEncContext s, ChannelElement cpe,
		1055	const float lambda)
		1056	{
		1057	int start = 0, i, w, w2, g;
		1058	float M[128], S[128];
		1059	float L34 = s->scoefs, R34 = s->scoefs + 128, M34 = s->scoefs + 1282, S34 = s->scoefs + 1283;
		1060	SingleChannelElement *sce0 = &cpe->ch[0];
		1061	SingleChannelElement *sce1 = &cpe->ch[1];
		1062	if (!cpe->common_window)
		1063	return;
		1064	for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
		1065	for (g = 0; g < sce0->ics.num_swb; g++) {
		1066	if (!cpe->ch[0].zeroes[w16+g] && !cpe->ch[1].zeroes[w16+g]) {
		1067	float dist1 = 0.0f, dist2 = 0.0f;
		1068	for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
		1069	FFPsyBand band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)16+g];
		1070	FFPsyBand band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)16+g];
		1071	float minthr = FFMIN(band0->threshold, band1->threshold);
		1072	float maxthr = FFMAX(band0->threshold, band1->threshold);
		1073	for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
		1074	M[i] = (sce0->coeffs[start+w2*128+i]
		1075	+ sce1->coeffs[start+w2128+i]) 0.5;
		1076	S[i] = M[i]
		1077	- sce1->coeffs[start+w2*128+i];
		1078	}
		1079	abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
		1080	abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
		1081	abs_pow34_v(M34, M, sce0->ics.swb_sizes[g]);
		1082	abs_pow34_v(S34, S, sce0->ics.swb_sizes[g]);
		1083	dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,
		1084	L34,
		1085	sce0->ics.swb_sizes[g],
		1086	sce0->sf_idx[(w+w2)*16+g],
		1087	sce0->band_type[(w+w2)*16+g],
		1088	lambda / band0->threshold, INFINITY, NULL);
		1089	dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,
		1090	R34,
		1091	sce1->ics.swb_sizes[g],
		1092	sce1->sf_idx[(w+w2)*16+g],
		1093	sce1->band_type[(w+w2)*16+g],
		1094	lambda / band1->threshold, INFINITY, NULL);
		1095	dist2 += quantize_band_cost(s, M,
		1096	M34,
		1097	sce0->ics.swb_sizes[g],
		1098	sce0->sf_idx[(w+w2)*16+g],
		1099	sce0->band_type[(w+w2)*16+g],
		1100	lambda / maxthr, INFINITY, NULL);
		1101	dist2 += quantize_band_cost(s, S,
		1102	S34,
		1103	sce1->ics.swb_sizes[g],
		1104	sce1->sf_idx[(w+w2)*16+g],
		1105	sce1->band_type[(w+w2)*16+g],
		1106	lambda / minthr, INFINITY, NULL);
		1107	}
		1108	cpe->ms_mask[w*16+g] = dist2 < dist1;
		1109	}
		1110	start += sce0->ics.swb_sizes[g];
		1111	}
		1112	}
		1113	}
		1114
		1115	AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {
		1116	[AAC_CODER_FAAC] = {
		1117	search_for_quantizers_faac,
		1118	encode_window_bands_info,
		1119	quantize_and_encode_band,
		1120	search_for_ms,
		1121	},
		1122	[AAC_CODER_ANMR] = {
		1123	search_for_quantizers_anmr,
		1124	encode_window_bands_info,
		1125	quantize_and_encode_band,
		1126	search_for_ms,
		1127	},
		1128	[AAC_CODER_TWOLOOP] = {
		1129	search_for_quantizers_twoloop,
		1130	codebook_trellis_rate,
		1131	quantize_and_encode_band,
		1132	search_for_ms,
		1133	},
		1134	[AAC_CODER_FAST] = {
		1135	search_for_quantizers_fast,
		1136	encode_window_bands_info,
		1137	quantize_and_encode_band,
		1138	search_for_ms,
		1139	},
		1140	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavcodec/aaccoder.c – Rev 4349