Cosmetics: Pretty print the AAC encoder.

Originally committed as revision 19376 to svn://svn.ffmpeg.org/ffmpeg/trunk

Alex Converse committed 17 years ago

Commit fd257dc1 parent 78e65cd6 files · +288 −288Browse files

Unified · Split

6 files

libavcodec/aaccoder.c +169 −169
libavcodec/aacenc.c +72 −72
libavcodec/aacenc.h +2 −2
libavcodec/aacpsy.c +27 −27
libavcodec/psymodel.c +11 −11
libavcodec/psymodel.h +7 −7

@@ -119,18 +119,18 @@ static float quantize_band_cost(struct AACEncContext s, const float in, const · 118 unmodified lines
119	119	int offs[4];
120	120	#endif /* USE_REALLY_FULL_SEARCH */
121	121
122		− if(!cb){
123		− for(i = 0; i < size; i++)
	122	+ if (!cb) {
	123	+ for (i = 0; i < size; i++)
124	124	cost += in[i]in[i]lambda;
125	125	return cost;
126	126	}
127	127	#ifndef USE_REALLY_FULL_SEARCH
128	128	offs[0] = 1;
129		− for(i = 1; i < dim; i++)
	129	+ for (i = 1; i < dim; i++)
130	130	offs[i] = offs[i-1]*range;
131	131	quantize_bands(s->qcoefs, in, scaled, size, Q34, !IS_CODEBOOK_UNSIGNED(cb), maxval);
132	132	#endif /* USE_REALLY_FULL_SEARCH */
133		− for(i = 0; i < size; i += dim){
	133	+ for (i = 0; i < size; i += dim) {
134	134	float mincost;
135	135	int minidx = 0;
136	136	int minbits = 0;
@@ -138,69 +138,69 @@ static float quantize_band_cost(struct AACEncContext s, const float in, const · 1 unmodified line
138	138	#ifndef USE_REALLY_FULL_SEARCH
139	139	int (*quants)[2] = &s->qcoefs[i];
140	140	mincost = 0.0f;
141		− for(j = 0; j < dim; j++){
	141	+ for (j = 0; j < dim; j++) {
142	142	mincost += in[i+j]in[i+j]lambda;
143	143	}
144	144	minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
145	145	minbits = ff_aac_spectral_bits[cb-1][minidx];
146	146	mincost += minbits;
147		− for(j = 0; j < (1<<dim); j++){
	147	+ for (j = 0; j < (1<<dim); j++) {
148	148	float rd = 0.0f;
149	149	int curbits;
150	150	int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
151	151	int same = 0;
152		− for(k = 0; k < dim; k++){
153		− if((j & (1 << k)) && quants[k][0] == quants[k][1]){
	152	+ for (k = 0; k < dim; k++) {
	153	+ if ((j & (1 << k)) && quants[k][0] == quants[k][1]) {
154	154	same = 1;
155	155	break;
156	156	}
157	157	}
158		− if(same)
	158	+ if (same)
159	159	continue;
160		− for(k = 0; k < dim; k++)
	160	+ for (k = 0; k < dim; k++)
161	161	curidx += quants[k][!!(j & (1 << k))] * offs[dim - 1 - k];
162	162	curbits = ff_aac_spectral_bits[cb-1][curidx];
163	163	vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
164	164	#else
165	165	mincost = INFINITY;
166	166	vec = ff_aac_codebook_vectors[cb-1];
167		− for(j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim){
	167	+ for (j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim) {
168	168	float rd = 0.0f;
169	169	int curbits = ff_aac_spectral_bits[cb-1][j];
170	170	#endif /* USE_REALLY_FULL_SEARCH */
171		− if(IS_CODEBOOK_UNSIGNED(cb)){
172		− for(k = 0; k < dim; k++){
	171	+ if (IS_CODEBOOK_UNSIGNED(cb)) {
	172	+ for (k = 0; k < dim; k++) {
173	173	float t = fabsf(in[i+k]);
174	174	float di;
175	175	//do not code with escape sequence small values
176		− if(vec[k] == 64.0f && t < 39.0f*IQ){
	176	+ if (vec[k] == 64.0f && t < 39.0f*IQ) {
177	177	rd = INFINITY;
178	178	break;
179	179	}
180		− if(vec[k] == 64.0f){//FIXME: slow
	180	+ if (vec[k] == 64.0f) {//FIXME: slow
181	181	if (t >= CLIPPED_ESCAPE) {
182	182	di = t - CLIPPED_ESCAPE;
183	183	curbits += 21;
184		− }else{
	184	+ } else {
185	185	int c = av_clip(quant(t, Q), 0, 8191);
186	186	di = t - ccbrt(c)IQ;
187	187	curbits += av_log2(c)*2 - 4 + 1;
188	188	}
189		− }else{
	189	+ } else {
190	190	di = t - vec[k]*IQ;
191	191	}
192		− if(vec[k] != 0.0f)
	192	+ if (vec[k] != 0.0f)
193	193	curbits++;
194	194	rd += didilambda;
195	195	}
196		− }else{
197		− for(k = 0; k < dim; k++){
	196	+ } else {
	197	+ for (k = 0; k < dim; k++) {
198	198	float di = in[i+k] - vec[k]*IQ;
199	199	rd += didilambda;
200	200	}
201	201	}
202	202	rd += curbits;
203		− if(rd < mincost){
	203	+ if (rd < mincost) {
204	204	mincost = rd;
205	205	minidx = j;
206	206	minbits = curbits;
@@ -208,11 +208,11 @@ static float quantize_band_cost(struct AACEncContext s, const float in, const · 1 unmodified line
208	208	}
209	209	cost += mincost;
210	210	resbits += minbits;
211		− if(cost >= uplim)
	211	+ if (cost >= uplim)
212	212	return uplim;
213	213	}
214	214
215		− if(bits)
	215	+ if (bits)
216	216	*bits = resbits;
217	217	return cost;
218	218	}
@@ -234,17 +234,17 @@ static void quantize_and_encode_band(struct AACEncContext s, PutBitContext pb, · 15 unmodified lines
234	234	#endif /* USE_REALLY_FULL_SEARCH */
235	235
236	236	//START_TIMER
237		− if(!cb)
	237	+ if (!cb)
238	238	return;
239	239
240	240	#ifndef USE_REALLY_FULL_SEARCH
241	241	offs[0] = 1;
242		− for(i = 1; i < dim; i++)
	242	+ for (i = 1; i < dim; i++)
243	243	offs[i] = offs[i-1]*range;
244	244	abs_pow34_v(scaled, in, size);
245	245	quantize_bands(s->qcoefs, in, scaled, size, Q34, !IS_CODEBOOK_UNSIGNED(cb), maxval);
246	246	#endif /* USE_REALLY_FULL_SEARCH */
247		− for(i = 0; i < size; i += dim){
	247	+ for (i = 0; i < size; i += dim) {
248	248	float mincost;
249	249	int minidx = 0;
250	250	int minbits = 0;
@@ -252,83 +252,83 @@ static void quantize_and_encode_band(struct AACEncContext s, PutBitContext pb, · 1 unmodified line
252	252	#ifndef USE_REALLY_FULL_SEARCH
253	253	int (*quants)[2] = &s->qcoefs[i];
254	254	mincost = 0.0f;
255		− for(j = 0; j < dim; j++){
	255	+ for (j = 0; j < dim; j++) {
256	256	mincost += in[i+j]in[i+j]lambda;
257	257	}
258	258	minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
259	259	minbits = ff_aac_spectral_bits[cb-1][minidx];
260	260	mincost += minbits;
261		− for(j = 0; j < (1<<dim); j++){
	261	+ for (j = 0; j < (1<<dim); j++) {
262	262	float rd = 0.0f;
263	263	int curbits;
264	264	int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
265	265	int same = 0;
266		− for(k = 0; k < dim; k++){
267		− if((j & (1 << k)) && quants[k][0] == quants[k][1]){
	266	+ for (k = 0; k < dim; k++) {
	267	+ if ((j & (1 << k)) && quants[k][0] == quants[k][1]) {
268	268	same = 1;
269	269	break;
270	270	}
271	271	}
272		− if(same)
	272	+ if (same)
273	273	continue;
274		− for(k = 0; k < dim; k++)
	274	+ for (k = 0; k < dim; k++)
275	275	curidx += quants[k][!!(j & (1 << k))] * offs[dim - 1 - k];
276	276	curbits = ff_aac_spectral_bits[cb-1][curidx];
277	277	vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
278	278	#else
279	279	vec = ff_aac_codebook_vectors[cb-1];
280	280	mincost = INFINITY;
281		− for(j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim){
	281	+ for (j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim) {
282	282	float rd = 0.0f;
283	283	int curbits = ff_aac_spectral_bits[cb-1][j];
284	284	int curidx = j;
285	285	#endif /* USE_REALLY_FULL_SEARCH */
286		− if(IS_CODEBOOK_UNSIGNED(cb)){
287		− for(k = 0; k < dim; k++){
	286	+ if (IS_CODEBOOK_UNSIGNED(cb)) {
	287	+ for (k = 0; k < dim; k++) {
288	288	float t = fabsf(in[i+k]);
289	289	float di;
290	290	//do not code with escape sequence small values
291		− if(vec[k] == 64.0f && t < 39.0f*IQ){
	291	+ if (vec[k] == 64.0f && t < 39.0f*IQ) {
292	292	rd = INFINITY;
293	293	break;
294	294	}
295		− if(vec[k] == 64.0f){//FIXME: slow
	295	+ if (vec[k] == 64.0f) {//FIXME: slow
296	296	if (t >= CLIPPED_ESCAPE) {
297	297	di = t - CLIPPED_ESCAPE;
298	298	curbits += 21;
299		− }else{
	299	+ } else {
300	300	int c = av_clip(quant(t, Q), 0, 8191);
301	301	di = t - ccbrt(c)IQ;
302	302	curbits += av_log2(c)*2 - 4 + 1;
303	303	}
304		− }else{
	304	+ } else {
305	305	di = t - vec[k]*IQ;
306	306	}
307		− if(vec[k] != 0.0f)
	307	+ if (vec[k] != 0.0f)
308	308	curbits++;
309	309	rd += didilambda;
310	310	}
311		− }else{
312		− for(k = 0; k < dim; k++){
	311	+ } else {
	312	+ for (k = 0; k < dim; k++) {
313	313	float di = in[i+k] - vec[k]*IQ;
314	314	rd += didilambda;
315	315	}
316	316	}
317	317	rd += curbits;
318		− if(rd < mincost){
	318	+ if (rd < mincost) {
319	319	mincost = rd;
320	320	minidx = curidx;
321	321	minbits = curbits;
322	322	}
323	323	}
324	324	put_bits(pb, ff_aac_spectral_bits[cb-1][minidx], ff_aac_spectral_codes[cb-1][minidx]);
325		− if(IS_CODEBOOK_UNSIGNED(cb))
326		− for(j = 0; j < dim; j++)
327		− if(ff_aac_codebook_vectors[cb-1][minidx*dim+j] != 0.0f)
	325	+ if (IS_CODEBOOK_UNSIGNED(cb))
	326	+ for (j = 0; j < dim; j++)
	327	+ if (ff_aac_codebook_vectors[cb-1][minidx*dim+j] != 0.0f)
328	328	put_bits(pb, 1, in[i+j] < 0.0f);
329		− if(cb == ESC_BT){
330		− for(j = 0; j < 2; j++){
331		− if(ff_aac_codebook_vectors[cb-1][minidx*2+j] == 64.0f){
	329	+ if (cb == ESC_BT) {
	330	+ for (j = 0; j < 2; j++) {
	331	+ if (ff_aac_codebook_vectors[cb-1][minidx*2+j] == 64.0f) {
332	332	int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
333	333	int len = av_log2(coef);
334	334
@@ -370,29 +370,29 @@ static void encode_window_bands_info(AACEncContext s, SingleChannelElement sce · 35 unmodified lines
370	370
371	371	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
372	372	start = win*128;
373		− for(cb = 0; cb < 12; cb++){
	373	+ for (cb = 0; cb < 12; cb++) {
374	374	path[0][cb].cost = 0.0f;
375	375	path[0][cb].prev_idx = -1;
376	376	path[0][cb].run = 0;
377	377	}
378		− for(swb = 0; swb < max_sfb; swb++){
	378	+ for (swb = 0; swb < max_sfb; swb++) {
379	379	start2 = start;
380	380	size = sce->ics.swb_sizes[swb];
381		− if(sce->zeroes[win*16 + swb]){
382		− for(cb = 0; cb < 12; cb++){
	381	+ if (sce->zeroes[win*16 + swb]) {
	382	+ for (cb = 0; cb < 12; cb++) {
383	383	path[swb+1][cb].prev_idx = cb;
384	384	path[swb+1][cb].cost = path[swb][cb].cost;
385	385	path[swb+1][cb].run = path[swb][cb].run + 1;
386	386	}
387		− }else{
	387	+ } else {
388	388	float minrd = next_minrd;
389	389	int mincb = next_mincb;
390	390	next_minrd = INFINITY;
391	391	next_mincb = 0;
392		− for(cb = 0; cb < 12; cb++){
	392	+ for (cb = 0; cb < 12; cb++) {
393	393	float cost_stay_here, cost_get_here;
394	394	float rd = 0.0f;
395		− for(w = 0; w < group_len; w++){
	395	+ for (w = 0; w < group_len; w++) {
396	396	FFPsyBand band = &s->psy.psy_bands[s->cur_channelPSY_MAX_BANDS+(win+w)*16+swb];
397	397	rd += quantize_band_cost(s, sce->coeffs + start + w*128,
398	398	s->scoefs + start + w*128, size,
@@ -401,7 +401,7 @@ static void encode_window_bands_info(AACEncContext s, SingleChannelElement sce · 2 unmodified lines
401	401	}
402	402	cost_stay_here = path[swb][cb].cost + rd;
403	403	cost_get_here = minrd + rd + run_bits + 4;
404		− if( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
	404	+ if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
405	405	!= run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
406	406	cost_stay_here += run_bits;
407	407	if (cost_get_here < cost_stay_here) {
@@ -425,12 +425,12 @@ static void encode_window_bands_info(AACEncContext s, SingleChannelElement sce · 17 unmodified lines
425	425	//convert resulting path from backward-linked list
426	426	stack_len = 0;
427	427	idx = 0;
428		− for(cb = 1; cb < 12; cb++){
429		− if(path[max_sfb][cb].cost < path[max_sfb][idx].cost)
	428	+ for (cb = 1; cb < 12; cb++) {
	429	+ if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
430	430	idx = cb;
431	431	}
432	432	ppos = max_sfb;
433		− while(ppos > 0){
	433	+ while(ppos > 0) {
434	434	cb = idx;
435	435	stackrun[stack_len] = path[ppos][cb].run;
436	436	stackcb [stack_len] = cb;
@@ -440,16 +440,16 @@ static void encode_window_bands_info(AACEncContext s, SingleChannelElement sce · 3 unmodified lines
440	440	}
441	441	//perform actual band info encoding
442	442	start = 0;
443		− for(i = stack_len - 1; i >= 0; i--){
	443	+ for (i = stack_len - 1; i >= 0; i--) {
444	444	put_bits(&s->pb, 4, stackcb[i]);
445	445	count = stackrun[i];
446	446	memset(sce->zeroes + win*16 + start, !stackcb[i], count);
447	447	//XXX: memset when band_type is also uint8_t
448		− for(j = 0; j < count; j++){
	448	+ for (j = 0; j < count; j++) {
449	449	sce->band_type[win*16 + start] = stackcb[i];
450	450	start++;
451	451	}
452		− while(count >= run_esc){
	452	+ while(count >= run_esc) {
453	453	put_bits(&s->pb, run_bits, run_esc);
454	454	count -= run_esc;
455	455	}
@@ -482,13 +482,13 @@ static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s, · 26 unmodified lines
482	482	int minq;
483	483	float mincost;
484	484
485		− for(i = 0; i < 256; i++){
	485	+ for (i = 0; i < 256; i++) {
486	486	paths[i].cost = 0.0f;
487	487	paths[i].prev = -1;
488	488	paths[i].min_val = i;
489	489	paths[i].max_val = i;
490	490	}
491		− for(i = 256; i < 256*121; i++){
	491	+ for (i = 256; i < 256*121; i++) {
492	492	paths[i].cost = INFINITY;
493	493	paths[i].prev = -2;
494	494	paths[i].min_val = INT_MAX;
@@ -496,9 +496,9 @@ static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s, · 1 unmodified line
496	496	}
497	497	idx = 256;
498	498	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
499		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	499	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
500	500	start = w*128;
501		− for(g = 0; g < sce->ics.num_swb; g++){
	501	+ for (g = 0; g < sce->ics.num_swb; g++) {
502	502	const float *coefs = sce->coeffs + start;
503	503	float qmin, qmax;
504	504	int nz = 0;
@@ -506,53 +506,53 @@ static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s, · 1 unmodified line
506	506	bandaddr[idx >> 8] = w*16+g;
507	507	qmin = INT_MAX;
508	508	qmax = 0.0f;
509		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	509	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
510	510	FFPsyBand band = &s->psy.psy_bands[s->cur_channelPSY_MAX_BANDS+(w+w2)*16+g];
511		− if(band->energy <= band->threshold \|\| band->threshold == 0.0f){
	511	+ if (band->energy <= band->threshold \|\| band->threshold == 0.0f) {
512	512	sce->zeroes[(w+w2)*16+g] = 1;
513	513	continue;
514	514	}
515	515	sce->zeroes[(w+w2)*16+g] = 0;
516	516	nz = 1;
517		− for(i = 0; i < sce->ics.swb_sizes[g]; i++){
	517	+ for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
518	518	float t = fabsf(coefs[w2*128+i]);
519		− if(t > 0.0f) qmin = fminf(qmin, t);
	519	+ if (t > 0.0f) qmin = fminf(qmin, t);
520	520	qmax = fmaxf(qmax, t);
521	521	}
522	522	}
523		− if(nz){
	523	+ if (nz) {
524	524	int minscale, maxscale;
525	525	float minrd = INFINITY;
526	526	//minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
527	527	minscale = av_clip_uint8(log2(qmin)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
528	528	//maximum scalefactor index is when maximum coefficient after quantizing is still not zero
529	529	maxscale = av_clip_uint8(log2(qmax)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512);
530		− for(q = minscale; q < maxscale; q++){
	530	+ for (q = minscale; q < maxscale; q++) {
531	531	float dists[12], dist;
532	532	memset(dists, 0, sizeof(dists));
533		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	533	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
534	534	FFPsyBand band = &s->psy.psy_bands[s->cur_channelPSY_MAX_BANDS+(w+w2)*16+g];
535	535	int cb;
536		− for(cb = 0; cb <= ESC_BT; cb++){
	536	+ for (cb = 0; cb <= ESC_BT; cb++) {
537	537	dists[cb] += quantize_band_cost(s, coefs + w2128, s->scoefs + start + w2128, sce->ics.swb_sizes[g],
538	538	q, cb, lambda / band->threshold, INFINITY, NULL);
539	539	}
540	540	}
541	541	dist = dists[0];
542		− for(i = 1; i <= ESC_BT; i++)
	542	+ for (i = 1; i <= ESC_BT; i++)
543	543	dist = fminf(dist, dists[i]);
544	544	minrd = fminf(minrd, dist);
545	545
546		− for(i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++){
	546	+ for (i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++) {
547	547	float cost;
548	548	int minv, maxv;
549		− if(isinf(paths[idx - 256 + i].cost))
	549	+ if (isinf(paths[idx - 256 + i].cost))
550	550	continue;
551	551	cost = paths[idx - 256 + i].cost + dist
552	552	+ ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
553	553	minv = FFMIN(paths[idx - 256 + i].min_val, q);
554	554	maxv = FFMAX(paths[idx - 256 + i].max_val, q);
555		− if(cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF){
	555	+ if (cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF) {
556	556	paths[idx + q].cost = cost;
557	557	paths[idx + q].prev = idx - 256 + i;
558	558	paths[idx + q].min_val = minv;
@@ -560,24 +560,24 @@ static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s, · 1 unmodified line
560	560	}
561	561	}
562	562	}
563		− }else{
564		− for(q = 0; q < 256; q++){
565		− if(!isinf(paths[idx - 256 + q].cost)){
	563	+ } else {
	564	+ for (q = 0; q < 256; q++) {
	565	+ if (!isinf(paths[idx - 256 + q].cost)) {
566	566	paths[idx + q].cost = paths[idx - 256 + q].cost + 1;
567	567	paths[idx + q].prev = idx - 256 + q;
568	568	paths[idx + q].min_val = FFMIN(paths[idx - 256 + q].min_val, q);
569	569	paths[idx + q].max_val = FFMAX(paths[idx - 256 + q].max_val, q);
570	570	continue;
571	571	}
572		− for(i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++){
	572	+ for (i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++) {
573	573	float cost;
574	574	int minv, maxv;
575		− if(isinf(paths[idx - 256 + i].cost))
	575	+ if (isinf(paths[idx - 256 + i].cost))
576	576	continue;
577	577	cost = paths[idx - 256 + i].cost + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
578	578	minv = FFMIN(paths[idx - 256 + i].min_val, q);
579	579	maxv = FFMAX(paths[idx - 256 + i].max_val, q);
580		− if(cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF){
	580	+ if (cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF) {
581	581	paths[idx + q].cost = cost;
582	582	paths[idx + q].prev = idx - 256 + i;
583	583	paths[idx + q].min_val = minv;
@@ -594,20 +594,20 @@ static void search_for_quantizers_anmr(AVCodecContext avctx, AACEncContext s, · 10 unmodified lines
594	594	idx -= 256;
595	595	mincost = paths[idx].cost;
596	596	minq = idx;
597		− for(i = 1; i < 256; i++){
598		− if(paths[idx + i].cost < mincost){
	597	+ for (i = 1; i < 256; i++) {
	598	+ if (paths[idx + i].cost < mincost) {
599	599	mincost = paths[idx + i].cost;
600	600	minq = idx + i;
601	601	}
602	602	}
603		− while(minq >= 256){
	603	+ while(minq >= 256) {
604	604	sce->sf_idx[bandaddr[minq>>8]] = minq & 0xFF;
605	605	minq = paths[minq].prev;
606	606	}
607	607	//set the same quantizers inside window groups
608		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
609		− for(g = 0; g < sce->ics.num_swb; g++)
610		− for(w2 = 1; w2 < sce->ics.group_len[w]; w2++)
	608	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
	609	+ for (g = 0; g < sce->ics.num_swb; g++)
	610	+ for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
611	611	sce->sf_idx[(w+w2)16+g] = sce->sf_idx[w16+g];
612	612	}
613	613
@@ -628,14 +628,14 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 14 unmodified lines
628	628	//XXX: some heuristic to determine initial quantizers will reduce search time
629	629	memset(dists, 0, sizeof(dists));
630	630	//determine zero bands and upper limits
631		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
632		− for(g = 0; g < sce->ics.num_swb; g++){
	631	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
	632	+ for (g = 0; g < sce->ics.num_swb; g++) {
633	633	int nz = 0;
634	634	float uplim = 0.0f;
635		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	635	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
636	636	FFPsyBand band = &s->psy.psy_bands[s->cur_channelPSY_MAX_BANDS+(w+w2)*16+g];
637	637	uplim += band->threshold;
638		− if(band->energy <= band->threshold \|\| band->threshold == 0.0f){
	638	+ if (band->energy <= band->threshold \|\| band->threshold == 0.0f) {
639	639	sce->zeroes[(w+w2)*16+g] = 1;
640	640	continue;
641	641	}
@@ -643,14 +643,14 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 1 unmodified line
643	643	}
644	644	uplims[w16+g] = uplim 512;
645	645	sce->zeroes[w*16+g] = !nz;
646		− if(nz)
	646	+ if (nz)
647	647	minthr = fminf(minthr, uplim);
648	648	allz = FFMAX(allz, nz);
649	649	}
650	650	}
651		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
652		− for(g = 0; g < sce->ics.num_swb; g++){
653		− if(sce->zeroes[w*16+g]){
	651	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
	652	+ for (g = 0; g < sce->ics.num_swb; g++) {
	653	+ if (sce->zeroes[w*16+g]) {
654	654	sce->sf_idx[w*16+g] = SCALE_ONE_POS;
655	655	continue;
656	656	}
@@ -658,7 +658,7 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 1 unmodified line
658	658	}
659	659	}
660	660
661		− if(!allz)
	661	+ if (!allz)
662	662	return;
663	663	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
664	664	//perform two-loop search
@@ -672,9 +672,9 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 7 unmodified lines
672	672	int prev = -1;
673	673	tbits = 0;
674	674	fflag = 0;
675		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	675	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
676	676	start = w*128;
677		− for(g = 0; g < sce->ics.num_swb; g++){
	677	+ for (g = 0; g < sce->ics.num_swb; g++) {
678	678	const float *coefs = sce->coeffs + start;
679	679	const float *scaled = s->scoefs + start;
680	680	int bits = 0;
@@ -682,13 +682,13 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 1 unmodified line
682	682	float mindist = INFINITY;
683	683	int minbits = 0;
684	684
685		− if(sce->zeroes[w16+g] \|\| sce->sf_idx[w16+g] >= 218)
	685	+ if (sce->zeroes[w16+g] \|\| sce->sf_idx[w16+g] >= 218)
686	686	continue;
687	687	minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
688		− for(cb = 0; cb <= ESC_BT; cb++){
	688	+ for (cb = 0; cb <= ESC_BT; cb++) {
689	689	float dist = 0.0f;
690	690	int bb = 0;
691		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	691	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
692	692	int b;
693	693	dist += quantize_band_cost(s, coefs + w2*128,
694	694	scaled + w2*128,
@@ -700,14 +700,14 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 5 unmodified lines
700	700	&b);
701	701	bb += b;
702	702	}
703		− if(dist < mindist){
	703	+ if (dist < mindist) {
704	704	mindist = dist;
705	705	minbits = bb;
706	706	}
707	707	}
708	708	dists[w*16+g] = mindist - minbits;
709	709	bits = minbits;
710		− if(prev != -1){
	710	+ if (prev != -1) {
711	711	bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
712	712	}
713	713	tbits += bits;
@@ -715,36 +715,36 @@ static void search_for_quantizers_twoloop(AVCodecContext avctx, AACEncContext · 1 unmodified line
715	715	prev = sce->sf_idx[w*16+g];
716	716	}
717	717	}
718		− if(tbits > destbits){
719		− for(i = 0; i < 128; i++){
720		− if(sce->sf_idx[i] < 218 - qstep){
	718	+ if (tbits > destbits) {
	719	+ for (i = 0; i < 128; i++) {
	720	+ if (sce->sf_idx[i] < 218 - qstep) {
721	721	sce->sf_idx[i] += qstep;
722	722	}
723	723	}
724		− }else{
725		− for(i = 0; i < 128; i++){
726		− if(sce->sf_idx[i] > 60 - qstep){
	724	+ } else {
	725	+ for (i = 0; i < 128; i++) {
	726	+ if (sce->sf_idx[i] > 60 - qstep) {
727	727	sce->sf_idx[i] -= qstep;
728	728	}
729	729	}
730	730	}
731	731	qstep >>= 1;
732		− if(!qstep && tbits > destbits*1.02)
	732	+ if (!qstep && tbits > destbits*1.02)
733	733	qstep = 1;
734		− if(sce->sf_idx[0] >= 217)break;
	734	+ if (sce->sf_idx[0] >= 217)break;
735	735	}while(qstep);
736	736
737	737	fflag = 0;
738	738	minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
739		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	739	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
740	740	start = w*128;
741		− for(g = 0; g < sce->ics.num_swb; g++){
	741	+ for (g = 0; g < sce->ics.num_swb; g++) {
742	742	int prevsc = sce->sf_idx[w*16+g];
743		− if(dists[w16+g] > uplims[w16+g] && sce->sf_idx[w*16+g] > 60)
	743	+ if (dists[w16+g] > uplims[w16+g] && sce->sf_idx[w*16+g] > 60)
744	744	sce->sf_idx[w*16+g]--;
745	745	sce->sf_idx[w16+g] = av_clip(sce->sf_idx[w16+g], minscaler, minscaler + SCALE_MAX_DIFF);
746	746	sce->sf_idx[w16+g] = FFMIN(sce->sf_idx[w16+g], 219);
747		− if(sce->sf_idx[w*16+g] != prevsc)
	747	+ if (sce->sf_idx[w*16+g] != prevsc)
748	748	fflag = 1;
749	749	}
750	750	}
@@ -761,29 +761,29 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 10 unmodified lines
761	761	float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
762	762	int last = 0, lastband = 0, curband = 0;
763	763	float avg_energy = 0.0;
764		− if(sce->ics.num_windows == 1){
	764	+ if (sce->ics.num_windows == 1) {
765	765	start = 0;
766		− for(i = 0; i < 1024; i++){
767		− if(i - start >= sce->ics.swb_sizes[curband]){
	766	+ for (i = 0; i < 1024; i++) {
	767	+ if (i - start >= sce->ics.swb_sizes[curband]) {
768	768	start += sce->ics.swb_sizes[curband];
769	769	curband++;
770	770	}
771		− if(sce->coeffs[i]){
	771	+ if (sce->coeffs[i]) {
772	772	avg_energy += sce->coeffs[i] * sce->coeffs[i];
773	773	last = i;
774	774	lastband = curband;
775	775	}
776	776	}
777		− }else{
778		− for(w = 0; w < 8; w++){
	777	+ } else {
	778	+ for (w = 0; w < 8; w++) {
779	779	const float coeffs = sce->coeffs + w128;
780	780	start = 0;
781		− for(i = 0; i < 128; i++){
782		− if(i - start >= sce->ics.swb_sizes[curband]){
	781	+ for (i = 0; i < 128; i++) {
	782	+ if (i - start >= sce->ics.swb_sizes[curband]) {
783	783	start += sce->ics.swb_sizes[curband];
784	784	curband++;
785	785	}
786		− if(coeffs[i]){
	786	+ if (coeffs[i]) {
787	787	avg_energy += coeffs[i] * coeffs[i];
788	788	last = FFMAX(last, i);
789	789	lastband = FFMAX(lastband, curband);
@@ -793,41 +793,41 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 3 unmodified lines
793	793	}
794	794	last++;
795	795	avg_energy /= last;
796		− if(avg_energy == 0.0f){
797		− for(i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
	796	+ if (avg_energy == 0.0f) {
	797	+ for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
798	798	sce->sf_idx[i] = SCALE_ONE_POS;
799	799	return;
800	800	}
801		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	801	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
802	802	start = w*128;
803		− for(g = 0; g < sce->ics.num_swb; g++){
	803	+ for (g = 0; g < sce->ics.num_swb; g++) {
804	804	float *coefs = sce->coeffs + start;
805	805	const int size = sce->ics.swb_sizes[g];
806	806	int start2 = start, end2 = start + size, peakpos = start;
807	807	float maxval = -1, thr = 0.0f, t;
808	808	maxq[w*16+g] = 0.0f;
809		− if(g > lastband){
	809	+ if (g > lastband) {
810	810	maxq[w*16+g] = 0.0f;
811	811	start += size;
812		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++)
	812	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
813	813	memset(coefs + w2128, 0, sizeof(coefs[0])size);
814	814	continue;
815	815	}
816		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
817		− for(i = 0; i < size; i++){
	816	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
	817	+ for (i = 0; i < size; i++) {
818	818	float t = coefs[w2128+i]coefs[w2*128+i];
819	819	maxq[w16+g] = fmaxf(maxq[w16+g], fabsf(coefs[w2*128 + i]));
820	820	thr += t;
821		− if(sce->ics.num_windows == 1 && maxval < t){
	821	+ if (sce->ics.num_windows == 1 && maxval < t) {
822	822	maxval = t;
823	823	peakpos = start+i;
824	824	}
825	825	}
826	826	}
827		− if(sce->ics.num_windows == 1){
	827	+ if (sce->ics.num_windows == 1) {
828	828	start2 = FFMAX(peakpos - 2, start2);
829	829	end2 = FFMIN(peakpos + 3, end2);
830		− }else{
	830	+ } else {
831	831	start2 -= start;
832	832	end2 -= start;
833	833	}
@@ -839,16 +839,16 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 5 unmodified lines
839	839	}
840	840	memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
841	841	abs_pow34_v(s->scoefs, sce->coeffs, 1024);
842		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	842	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
843	843	start = w*128;
844		− for(g = 0; g < sce->ics.num_swb; g++){
	844	+ for (g = 0; g < sce->ics.num_swb; g++) {
845	845	const float *coefs = sce->coeffs + start;
846	846	const float *scaled = s->scoefs + start;
847	847	const int size = sce->ics.swb_sizes[g];
848	848	int scf, prev_scf, step;
849	849	int min_scf = 0, max_scf = 255;
850	850	float curdiff;
851		− if(maxq[w*16+g] < 21.544){
	851	+ if (maxq[w*16+g] < 21.544) {
852	852	sce->zeroes[w*16+g] = 1;
853	853	start += size;
854	854	continue;
@@ -856,11 +856,11 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 1 unmodified line
856	856	sce->zeroes[w*16+g] = 0;
857	857	scf = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2(1/maxq[w16+g])16/3, 60, 218);
858	858	step = 16;
859		− for(;;){
	859	+ for (;;) {
860	860	float dist = 0.0f;
861	861	int quant_max;
862	862
863		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	863	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
864	864	int b;
865	865	dist += quantize_band_cost(s, coefs + w2*128,
866	866	scaled + w2*128,
@@ -874,24 +874,24 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 7 unmodified lines
874	874	}
875	875	dist *= 1.0f/512.0f;
876	876	quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[200 - scf + SCALE_ONE_POS - SCALE_DIV_512]);
877		− if(quant_max >= 8191){ // too much, return to the previous quantizer
	877	+ if (quant_max >= 8191) { // too much, return to the previous quantizer
878	878	sce->sf_idx[w*16+g] = prev_scf;
879	879	break;
880	880	}
881	881	prev_scf = scf;
882	882	curdiff = fabsf(dist - uplim[w*16+g]);
883		− if(curdiff == 0.0f)
	883	+ if (curdiff == 0.0f)
884	884	step = 0;
885	885	else
886	886	step = fabsf(log2(curdiff));
887		− if(dist > uplim[w*16+g])
	887	+ if (dist > uplim[w*16+g])
888	888	step = -step;
889		− if(FFABS(step) <= 1 \|\| (step > 0 && scf >= max_scf) \|\| (step < 0 && scf <= min_scf)){
	889	+ if (FFABS(step) <= 1 \|\| (step > 0 && scf >= max_scf) \|\| (step < 0 && scf <= min_scf)) {
890	890	sce->sf_idx[w*16+g] = scf;
891	891	break;
892	892	}
893	893	scf += step;
894		− if(step > 0)
	894	+ if (step > 0)
895	895	min_scf = scf;
896	896	else
897	897	max_scf = scf;
@@ -900,17 +900,17 @@ static void search_for_quantizers_faac(AVCodecContext avctx, AACEncContext s, · 2 unmodified lines
900	900	}
901	901	}
902	902	minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
903		− for(i = 1; i < 128; i++){
904		− if(!sce->sf_idx[i])
	903	+ for (i = 1; i < 128; i++) {
	904	+ if (!sce->sf_idx[i])
905	905	sce->sf_idx[i] = sce->sf_idx[i-1];
906	906	else
907	907	minq = FFMIN(minq, sce->sf_idx[i]);
908	908	}
909		− if(minq == INT_MAX) minq = 0;
	909	+ if (minq == INT_MAX) minq = 0;
910	910	minq = FFMIN(minq, SCALE_MAX_POS);
911	911	maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
912		− for(i = 126; i >= 0; i--){
913		− if(!sce->sf_idx[i])
	912	+ for (i = 126; i >= 0; i--) {
	913	+ if (!sce->sf_idx[i])
914	914	sce->sf_idx[i] = sce->sf_idx[i+1];
915	915	sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
916	916	}
@@ -923,15 +923,15 @@ static void search_for_quantizers_fast(AVCodecContext avctx, AACEncContext s, · 6 unmodified lines
923	923	int minq = 255;
924	924
925	925	memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
926		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	926	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
927	927	start = w*128;
928		− for(g = 0; g < sce->ics.num_swb; g++){
929		− for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
	928	+ for (g = 0; g < sce->ics.num_swb; g++) {
	929	+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
930	930	FFPsyBand band = &s->psy.psy_bands[s->cur_channelPSY_MAX_BANDS+(w+w2)*16+g];
931		− if(band->energy <= band->threshold){
	931	+ if (band->energy <= band->threshold) {
932	932	sce->sf_idx[(w+w2)*16+g] = 218;
933	933	sce->zeroes[(w+w2)*16+g] = 1;
934		− }else{
	934	+ } else {
935	935	sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2(band->threshold), 80, 218);
936	936	sce->zeroes[(w+w2)*16+g] = 0;
937	937	}
@@ -939,13 +939,13 @@ static void search_for_quantizers_fast(AVCodecContext avctx, AACEncContext s, · 1 unmodified line
939	939	}
940	940	}
941	941	}
942		− for(i = 0; i < 128; i++){
	942	+ for (i = 0; i < 128; i++) {
943	943	sce->sf_idx[i] = 140;//av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
944	944	}
945	945	//set the same quantizers inside window groups
946		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
947		− for(g = 0; g < sce->ics.num_swb; g++)
948		− for(w2 = 1; w2 < sce->ics.group_len[w]; w2++)
	946	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
	947	+ for (g = 0; g < sce->ics.num_swb; g++)
	948	+ for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
949	949	sce->sf_idx[(w+w2)16+g] = sce->sf_idx[w16+g];
950	950	}
951	951
@@ -956,18 +956,18 @@ static void search_for_ms(AACEncContext s, ChannelElement cpe, const float lam · 4 unmodified lines
956	956	float L34 = s->scoefs, R34 = s->scoefs + 128, M34 = s->scoefs + 1282, S34 = s->scoefs + 1283;
957	957	SingleChannelElement *sce0 = &cpe->ch[0];
958	958	SingleChannelElement *sce1 = &cpe->ch[1];
959		− if(!cpe->common_window)
	959	+ if (!cpe->common_window)
960	960	return;
961		− for(w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]){
962		− for(g = 0; g < sce0->ics.num_swb; g++){
963		− if(!cpe->ch[0].zeroes[w16+g] && !cpe->ch[1].zeroes[w16+g]){
	961	+ for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
	962	+ for (g = 0; g < sce0->ics.num_swb; g++) {
	963	+ if (!cpe->ch[0].zeroes[w16+g] && !cpe->ch[1].zeroes[w16+g]) {
964	964	float dist1 = 0.0f, dist2 = 0.0f;
965		− for(w2 = 0; w2 < sce0->ics.group_len[w]; w2++){
	965	+ for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
966	966	FFPsyBand band0 = &s->psy.psy_bands[(s->cur_channel+0)PSY_MAX_BANDS+(w+w2)*16+g];
967	967	FFPsyBand band1 = &s->psy.psy_bands[(s->cur_channel+1)PSY_MAX_BANDS+(w+w2)*16+g];
968	968	float minthr = fminf(band0->threshold, band1->threshold);
969	969	float maxthr = fmaxf(band0->threshold, band1->threshold);
970		− for(i = 0; i < sce0->ics.swb_sizes[g]; i++){
	970	+ for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
971	971	M[i] = (sce0->coeffs[start+w2*128+i]
972	972	+ sce1->coeffs[start+w2128+i])0.5;
973	973	S[i] = sce0->coeffs[start+w2*128+i]

libavcodec/aacenc.c+72−72

@@ -159,14 +159,14 @@ static av_cold int aac_encode_init(AVCodecContext *avctx) · 158 unmodified lines
159	159
160	160	avctx->frame_size = 1024;
161	161
162		− for(i = 0; i < 16; i++)
163		− if(avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
	162	+ for (i = 0; i < 16; i++)
	163	+ if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
164	164	break;
165		− if(i == 16){
	165	+ if (i == 16) {
166	166	av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);
167	167	return -1;
168	168	}
169		− if(avctx->channels > 6){
	169	+ if (avctx->channels > 6) {
170	170	av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n", avctx->channels);
171	171	return -1;
172	172	}
@@ -218,35 +218,35 @@ static void apply_window_and_mdct(AVCodecContext avctx, AACEncContext s, · 45 unmodified lines
218	218
219	219	if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
220	220	memcpy(s->output, sce->saved, sizeof(float)*1024);
221		− if(sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE){
	221	+ if (sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE) {
222	222	memset(s->output, 0, sizeof(s->output[0]) * 448);
223		− for(i = 448; i < 576; i++)
	223	+ for (i = 448; i < 576; i++)
224	224	s->output[i] = sce->saved[i] * pwindow[i - 448];
225		− for(i = 576; i < 704; i++)
	225	+ for (i = 576; i < 704; i++)
226	226	s->output[i] = sce->saved[i];
227	227	}
228		− if(sce->ics.window_sequence[0] != LONG_START_SEQUENCE){
	228	+ if (sce->ics.window_sequence[0] != LONG_START_SEQUENCE) {
229	229	j = channel;
230		− for (i = 0; i < 1024; i++, j += avctx->channels){
	230	+ for (i = 0; i < 1024; i++, j += avctx->channels) {
231	231	s->output[i+1024] = audio[j] * lwindow[1024 - i - 1];
232	232	sce->saved[i] = audio[j] * lwindow[i];
233	233	}
234		− }else{
	234	+ } else {
235	235	j = channel;
236		− for(i = 0; i < 448; i++, j += avctx->channels)
	236	+ for (i = 0; i < 448; i++, j += avctx->channels)
237	237	s->output[i+1024] = audio[j];
238		− for(i = 448; i < 576; i++, j += avctx->channels)
	238	+ for (i = 448; i < 576; i++, j += avctx->channels)
239	239	s->output[i+1024] = audio[j] * swindow[576 - i - 1];
240	240	memset(s->output+1024+576, 0, sizeof(s->output[0]) * 448);
241	241	j = channel;
242		− for(i = 0; i < 1024; i++, j += avctx->channels)
	242	+ for (i = 0; i < 1024; i++, j += avctx->channels)
243	243	sce->saved[i] = audio[j];
244	244	}
245	245	ff_mdct_calc(&s->mdct1024, sce->coeffs, s->output);
246		− }else{
	246	+ } else {
247	247	j = channel;
248	248	for (k = 0; k < 1024; k += 128) {
249		− for(i = 448 + k; i < 448 + k + 256; i++)
	249	+ for (i = 448 + k; i < 448 + k + 256; i++)
250	250	s->output[i - 448 - k] = (i < 1024)
251	251	? sce->saved[i]
252	252	: audio[channel + (i-1024)*avctx->channels];
@@ -255,7 +255,7 @@ static void apply_window_and_mdct(AVCodecContext avctx, AACEncContext s, · 2 unmodified lines
255	255	ff_mdct_calc(&s->mdct128, sce->coeffs + k, s->output);
256	256	}
257	257	j = channel;
258		− for(i = 0; i < 1024; i++, j += avctx->channels)
	258	+ for (i = 0; i < 1024; i++, j += avctx->channels)
259	259	sce->saved[i] = audio[j];
260	260	}
261	261	}
@@ -271,12 +271,12 @@ static void put_ics_info(AACEncContext s, IndividualChannelStream info) · 9 unmodified lines
271	271	put_bits(&s->pb, 1, 0); // ics_reserved bit
272	272	put_bits(&s->pb, 2, info->window_sequence[0]);
273	273	put_bits(&s->pb, 1, info->use_kb_window[0]);
274		− if(info->window_sequence[0] != EIGHT_SHORT_SEQUENCE){
	274	+ if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
275	275	put_bits(&s->pb, 6, info->max_sfb);
276	276	put_bits(&s->pb, 1, 0); // no prediction
277		− }else{
	277	+ } else {
278	278	put_bits(&s->pb, 4, info->max_sfb);
279		− for(w = 1; w < 8; w++){
	279	+ for (w = 1; w < 8; w++) {
280	280	put_bits(&s->pb, 1, !info->group_len[w]);
281	281	}
282	282	}
@@ -291,9 +291,9 @@ static void encode_ms_info(PutBitContext pb, ChannelElement cpe) · 8 unmodified lines
291	291	int i, w;
292	292
293	293	put_bits(pb, 2, cpe->ms_mode);
294		− if(cpe->ms_mode == 1){
295		− for(w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w]){
296		− for(i = 0; i < cpe->ch[0].ics.max_sfb; i++)
	294	+ if (cpe->ms_mode == 1) {
	295	+ for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w]) {
	296	+ for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
297	297	put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
298	298	}
299	299	}
@@ -307,34 +307,34 @@ static void adjust_frame_information(AACEncContext apc, ChannelElement cpe, in · 7 unmodified lines
307	307	int i, w, w2, g, ch;
308	308	int start, sum, maxsfb, cmaxsfb;
309	309
310		− for(ch = 0; ch < chans; ch++){
	310	+ for (ch = 0; ch < chans; ch++) {
311	311	IndividualChannelStream *ics = &cpe->ch[ch].ics;
312	312	start = 0;
313	313	maxsfb = 0;
314	314	cpe->ch[ch].pulse.num_pulse = 0;
315		− for(w = 0; w < ics->num_windows*16; w += 16){
316		− for(g = 0; g < ics->num_swb; g++){
	315	+ for (w = 0; w < ics->num_windows*16; w += 16) {
	316	+ for (g = 0; g < ics->num_swb; g++) {
317	317	sum = 0;
318	318	//apply M/S
319		− if(!ch && cpe->ms_mask[w + g]){
320		− for(i = 0; i < ics->swb_sizes[g]; i++){
	319	+ if (!ch && cpe->ms_mask[w + g]) {
	320	+ for (i = 0; i < ics->swb_sizes[g]; i++) {
321	321	cpe->ch[0].coeffs[start+i] = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) / 2.0;
322	322	cpe->ch[1].coeffs[start+i] = cpe->ch[0].coeffs[start+i] - cpe->ch[1].coeffs[start+i];
323	323	}
324	324	}
325	325	start += ics->swb_sizes[g];
326	326	}
327		− for(cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w+cmaxsfb-1]; cmaxsfb--);
	327	+ for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w+cmaxsfb-1]; cmaxsfb--);
328	328	maxsfb = FFMAX(maxsfb, cmaxsfb);
329	329	}
330	330	ics->max_sfb = maxsfb;
331	331
332	332	//adjust zero bands for window groups
333		− for(w = 0; w < ics->num_windows; w += ics->group_len[w]){
334		− for(g = 0; g < ics->max_sfb; g++){
	333	+ for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
	334	+ for (g = 0; g < ics->max_sfb; g++) {
335	335	i = 1;
336		− for(w2 = w; w2 < w + ics->group_len[w]; w2++){
337		− if(!cpe->ch[ch].zeroes[w2*16 + g]){
	336	+ for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
	337	+ if (!cpe->ch[ch].zeroes[w2*16 + g]) {
338	338	i = 0;
339	339	break;
340	340	}
@@ -344,16 +344,16 @@ static void adjust_frame_information(AACEncContext apc, ChannelElement cpe, in · 3 unmodified lines
344	344	}
345	345	}
346	346
347		− if(chans > 1 && cpe->common_window){
	347	+ if (chans > 1 && cpe->common_window) {
348	348	IndividualChannelStream *ics0 = &cpe->ch[0].ics;
349	349	IndividualChannelStream *ics1 = &cpe->ch[1].ics;
350	350	int msc = 0;
351	351	ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
352	352	ics1->max_sfb = ics0->max_sfb;
353		− for(w = 0; w < ics0->num_windows*16; w += 16)
354		− for(i = 0; i < ics0->max_sfb; i++)
355		− if(cpe->ms_mask[w+i]) msc++;
356		− if(msc == 0 \|\| ics0->max_sfb == 0) cpe->ms_mode = 0;
	353	+ for (w = 0; w < ics0->num_windows*16; w += 16)
	354	+ for (i = 0; i < ics0->max_sfb; i++)
	355	+ if (cpe->ms_mask[w+i]) msc++;
	356	+ if (msc == 0 \|\| ics0->max_sfb == 0) cpe->ms_mode = 0;
357	357	else cpe->ms_mode = msc < ics0->max_sfb ? 1 : 2;
358	358	}
359	359	}
@@ -365,7 +365,7 @@ static void encode_band_info(AACEncContext s, SingleChannelElement sce) · 5 unmodified lines
365	365	{
366	366	int w;
367	367
368		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	368	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
369	369	s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
370	370	}
371	371	}
@@ -378,11 +378,11 @@ static void encode_scale_factors(AVCodecContext avctx, AACEncContext s, Single · 6 unmodified lines
378	378	int off = sce->sf_idx[0], diff;
379	379	int i, w;
380	380
381		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
382		− for(i = 0; i < sce->ics.max_sfb; i++){
383		− if(!sce->zeroes[w*16 + i]){
	381	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
	382	+ for (i = 0; i < sce->ics.max_sfb; i++) {
	383	+ if (!sce->zeroes[w*16 + i]) {
384	384	diff = sce->sf_idx[w*16 + i] - off + SCALE_DIFF_ZERO;
385		− if(diff < 0 \|\| diff > 120) av_log(avctx, AV_LOG_ERROR, "Scalefactor difference is too big to be coded\n");
	385	+ if (diff < 0 \|\| diff > 120) av_log(avctx, AV_LOG_ERROR, "Scalefactor difference is too big to be coded\n");
386	386	off = sce->sf_idx[w*16 + i];
387	387	put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
388	388	}
@@ -398,11 +398,11 @@ static void encode_pulses(AACEncContext s, Pulse pulse) · 9 unmodified lines
398	398	int i;
399	399
400	400	put_bits(&s->pb, 1, !!pulse->num_pulse);
401		− if(!pulse->num_pulse) return;
	401	+ if (!pulse->num_pulse) return;
402	402
403	403	put_bits(&s->pb, 2, pulse->num_pulse - 1);
404	404	put_bits(&s->pb, 6, pulse->start);
405		− for(i = 0; i < pulse->num_pulse; i++){
	405	+ for (i = 0; i < pulse->num_pulse; i++) {
406	406	put_bits(&s->pb, 5, pulse->pos[i]);
407	407	put_bits(&s->pb, 4, pulse->amp[i]);
408	408	}
@@ -415,14 +415,14 @@ static void encode_spectral_coeffs(AACEncContext s, SingleChannelElement sce) · 6 unmodified lines
415	415	{
416	416	int start, i, w, w2;
417	417
418		− for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
	418	+ for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
419	419	start = 0;
420		− for(i = 0; i < sce->ics.max_sfb; i++){
421		− if(sce->zeroes[w*16 + i]){
	420	+ for (i = 0; i < sce->ics.max_sfb; i++) {
	421	+ if (sce->zeroes[w*16 + i]) {
422	422	start += sce->ics.swb_sizes[i];
423	423	continue;
424	424	}
425		− for(w2 = w; w2 < w + sce->ics.group_len[w]; w2++){
	425	+ for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
426	426	s->coder->quantize_and_encode_band(s, &s->pb, sce->coeffs + start + w2*128,
427	427	sce->ics.swb_sizes[i],
428	428	sce->sf_idx[w*16 + i],
@@ -440,7 +440,7 @@ static void encode_spectral_coeffs(AACEncContext s, SingleChannelElement sce) · 11 unmodified lines
440	440	static int encode_individual_channel(AVCodecContext avctx, AACEncContext s, SingleChannelElement *sce, int common_window)
441	441	{
442	442	put_bits(&s->pb, 8, sce->sf_idx[0]);
443		− if(!common_window) put_ics_info(s, &sce->ics);
	443	+ if (!common_window) put_ics_info(s, &sce->ics);
444	444	encode_band_info(s, sce);
445	445	encode_scale_factors(avctx, s, sce);
446	446	encode_pulses(s, &sce->pulse);
@@ -460,12 +460,12 @@ static void put_bitstream_info(AVCodecContext avctx, AACEncContext s, const ch · 13 unmodified lines
460	460	namelen = strlen(name) + 2;
461	461	put_bits(&s->pb, 3, TYPE_FIL);
462	462	put_bits(&s->pb, 4, FFMIN(namelen, 15));
463		− if(namelen >= 15)
	463	+ if (namelen >= 15)
464	464	put_bits(&s->pb, 8, namelen - 16);
465	465	put_bits(&s->pb, 4, 0); //extension type - filler
466	466	padbits = 8 - (put_bits_count(&s->pb) & 7);
467	467	align_put_bits(&s->pb);
468		− for(i = 0; i < namelen - 2; i++)
	468	+ for (i = 0; i < namelen - 2; i++)
469	469	put_bits(&s->pb, 8, name[i]);
470	470	put_bits(&s->pb, 12 - padbits, 0);
471	471	}
@@ -480,15 +480,15 @@ static int aac_encode_frame(AVCodecContext *avctx, · 8 unmodified lines
480	480	const uint8_t *chan_map = aac_chan_configs[avctx->channels-1];
481	481	int chan_el_counter[4];
482	482
483		− if(s->last_frame)
	483	+ if (s->last_frame)
484	484	return 0;
485		− if(data){
486		− if(!s->psypp){
	485	+ if (data) {
	486	+ if (!s->psypp) {
487	487	memcpy(s->samples + 1024 * avctx->channels, data, 1024 * avctx->channels * sizeof(s->samples[0]));
488		− }else{
	488	+ } else {
489	489	start_ch = 0;
490	490	samples2 = s->samples + 1024 * avctx->channels;
491		− for(i = 0; i < chan_map[0]; i++){
	491	+ for (i = 0; i < chan_map[0]; i++) {
492	492	tag = chan_map[i+1];
493	493	chans = tag == TYPE_CPE ? 2 : 1;
494	494	ff_psy_preprocess(s->psypp, (uint16_t*)data + start_ch, samples2 + start_ch, start_ch, chans);
@@ -496,26 +496,26 @@ static int aac_encode_frame(AVCodecContext *avctx, · 1 unmodified line
496	496	}
497	497	}
498	498	}
499		− if(!avctx->frame_number){
	499	+ if (!avctx->frame_number) {
500	500	memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0]));
501	501	return 0;
502	502	}
503	503
504	504	init_put_bits(&s->pb, frame, buf_size*8);
505		− if((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)){
	505	+ if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)) {
506	506	put_bitstream_info(avctx, s, LIBAVCODEC_IDENT);
507	507	}
508	508	start_ch = 0;
509	509	memset(chan_el_counter, 0, sizeof(chan_el_counter));
510		− for(i = 0; i < chan_map[0]; i++){
	510	+ for (i = 0; i < chan_map[0]; i++) {
511	511	FFPsyWindowInfo wi[2];
512	512	tag = chan_map[i+1];
513	513	chans = tag == TYPE_CPE ? 2 : 1;
514	514	cpe = &s->cpe[i];
515	515	samples2 = samples + start_ch;
516	516	la = samples2 + 1024 * avctx->channels + start_ch;
517		− if(!data) la = NULL;
518		− for(j = 0; j < chans; j++){
	517	+ if (!data) la = NULL;
	518	+ for (j = 0; j < chans; j++) {
519	519	IndividualChannelStream *ics = &cpe->ch[j].ics;
520	520	int k;
521	521	wi[j] = ff_psy_suggest_window(&s->psy, samples2, la, start_ch + j, ics->window_sequence[0]);
@@ -526,7 +526,7 @@ static int aac_encode_frame(AVCodecContext *avctx, · 4 unmodified lines
526	526	ics->num_windows = wi[j].num_windows;
527	527	ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
528	528	ics->num_swb = s->psy.num_bands[ics->num_windows == 8];
529		− for(k = 0; k < ics->num_windows; k++)
	529	+ for (k = 0; k < ics->num_windows; k++)
530	530	ics->group_len[k] = wi[j].grouping[k];
531	531
532	532	s->cur_channel = start_ch + j;
@@ -534,31 +534,31 @@ static int aac_encode_frame(AVCodecContext *avctx, · 1 unmodified line
534	534	s->coder->search_for_quantizers(avctx, s, &cpe->ch[j], s->lambda);
535	535	}
536	536	cpe->common_window = 0;
537		− if(chans > 1
	537	+ if (chans > 1
538	538	&& wi[0].window_type[0] == wi[1].window_type[0]
539		− && wi[0].window_shape == wi[1].window_shape){
	539	+ && wi[0].window_shape == wi[1].window_shape) {
540	540
541	541	cpe->common_window = 1;
542		− for(j = 0; j < wi[0].num_windows; j++){
543		− if(wi[0].grouping[j] != wi[1].grouping[j]){
	542	+ for (j = 0; j < wi[0].num_windows; j++) {
	543	+ if (wi[0].grouping[j] != wi[1].grouping[j]) {
544	544	cpe->common_window = 0;
545	545	break;
546	546	}
547	547	}
548	548	}
549		− if(cpe->common_window && s->coder->search_for_ms)
	549	+ if (cpe->common_window && s->coder->search_for_ms)
550	550	s->coder->search_for_ms(s, cpe, s->lambda);
551	551	adjust_frame_information(s, cpe, chans);
552	552	put_bits(&s->pb, 3, tag);
553	553	put_bits(&s->pb, 4, chan_el_counter[tag]++);
554		− if(chans == 2){
	554	+ if (chans == 2) {
555	555	put_bits(&s->pb, 1, cpe->common_window);
556		− if(cpe->common_window){
	556	+ if (cpe->common_window) {
557	557	put_ics_info(s, &cpe->ch[0].ics);
558	558	encode_ms_info(&s->pb, cpe);
559	559	}
560	560	}
561		− for(j = 0; j < chans; j++){
	561	+ for (j = 0; j < chans; j++) {
562	562	s->cur_channel = start_ch + j;
563	563	ff_psy_set_band_info(&s->psy, s->cur_channel, cpe->ch[j].coeffs, &wi[j]);
564	564	encode_individual_channel(avctx, s, &cpe->ch[j], cpe->common_window);
@@ -571,7 +571,7 @@ static int aac_encode_frame(AVCodecContext *avctx, · 6 unmodified lines
571	571	avctx->frame_bits = put_bits_count(&s->pb);
572	572
573	573	// rate control stuff
574		− if(!(avctx->flags & CODEC_FLAG_QSCALE)){
	574	+ if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
575	575	float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
576	576	s->lambda *= ratio;
577	577	}
@@ -580,7 +580,7 @@ static int aac_encode_frame(AVCodecContext *avctx, · 2 unmodified lines
580	580	av_log(avctx, AV_LOG_ERROR, "input buffer violation %d > %d.\n", avctx->frame_bits, 6144*avctx->channels);
581	581	}
582	582
583		− if(!data)
	583	+ if (!data)
584	584	s->last_frame = 1;
585	585	memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0]));
586	586	return put_bits_count(&s->pb)>>3;

libavcodec/aacenc.h+2−2

@@ -32,7 +32,7 @@ · 31 unmodified lines
32	32
33	33	struct AACEncContext;
34	34
35		−typedef struct AACCoefficientsEncoder{
	35	+typedef struct AACCoefficientsEncoder {
36	36	void (search_for_quantizers)(AVCodecContext avctx, struct AACEncContext *s,
37	37	SingleChannelElement *sce, const float lambda);
38	38	void (encode_window_bands_info)(struct AACEncContext s, SingleChannelElement *sce,
@@ -40,7 +40,7 @@ typedef struct AACCoefficientsEncoder{ · 1 unmodified line
40	40	void (quantize_and_encode_band)(struct AACEncContext s, PutBitContext pb, const float in, int size,
41	41	int scale_idx, int cb, const float lambda);
42	42	void (search_for_ms)(struct AACEncContext s, ChannelElement *cpe, const float lambda);
43		−}AACCoefficientsEncoder;
	43	+} AACCoefficientsEncoder;
44	44
45	45	extern AACCoefficientsEncoder ff_aac_coders[];
46	46

libavcodec/aacpsy.c+27−27

@@ -112,7 +112,7 @@ static av_cold float ath(float f, float add) · 111 unmodified lines
112	112	+ (0.6 + 0.04 * add) * 0.001 * f * f * f * f;
113	113	}
114	114
115		−static av_cold int psy_3gpp_init(FFPsyContext *ctx){
	115	+static av_cold int psy_3gpp_init(FFPsyContext *ctx) {
116	116	Psy3gppContext *pctx;
117	117	float barks[1024];
118	118	int i, j, g, start;
@@ -121,26 +121,26 @@ static av_cold int psy_3gpp_init(FFPsyContext *ctx){ · 2 unmodified lines
121	121	ctx->model_priv_data = av_mallocz(sizeof(Psy3gppContext));
122	122	pctx = (Psy3gppContext*) ctx->model_priv_data;
123	123
124		− for(i = 0; i < 1024; i++)
	124	+ for (i = 0; i < 1024; i++)
125	125	barks[i] = calc_bark(i * ctx->avctx->sample_rate / 2048.0);
126	126	minath = ath(3410, ATH_ADD);
127		− for(j = 0; j < 2; j++){
	127	+ for (j = 0; j < 2; j++) {
128	128	Psy3gppCoeffs *coeffs = &pctx->psy_coef[j];
129	129	i = 0;
130	130	prev = 0.0;
131		− for(g = 0; g < ctx->num_bands[j]; g++){
	131	+ for (g = 0; g < ctx->num_bands[j]; g++) {
132	132	i += ctx->bands[j][g];
133	133	coeffs->barks[g] = (barks[i - 1] + prev) / 2.0;
134	134	prev = barks[i - 1];
135	135	}
136		− for(g = 0; g < ctx->num_bands[j] - 1; g++){
	136	+ for (g = 0; g < ctx->num_bands[j] - 1; g++) {
137	137	coeffs->spread_low[g] = pow(10.0, -(coeffs->barks[g+1] - coeffs->barks[g]) * PSY_3GPP_SPREAD_LOW);
138	138	coeffs->spread_hi [g] = pow(10.0, -(coeffs->barks[g+1] - coeffs->barks[g]) * PSY_3GPP_SPREAD_HI);
139	139	}
140	140	start = 0;
141		− for(g = 0; g < ctx->num_bands[j]; g++){
	141	+ for (g = 0; g < ctx->num_bands[j]; g++) {
142	142	minscale = ath(ctx->avctx->sample_rate * start / 1024.0, ATH_ADD);
143		− for(i = 1; i < ctx->bands[j][g]; i++){
	143	+ for (i = 1; i < ctx->bands[j][g]; i++) {
144	144	minscale = fminf(minscale, ath(ctx->avctx->sample_rate * (start + i) / 1024.0 / 2.0, ATH_ADD));
145	145	}
146	146	coeffs->ath[g] = minscale - minath;
@@ -189,21 +189,21 @@ static FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx, · 42 unmodified lines
189	189	FFPsyWindowInfo wi;
190	190
191	191	memset(&wi, 0, sizeof(wi));
192		− if(la){
	192	+ if (la) {
193	193	float s[8], v;
194	194	int switch_to_eight = 0;
195	195	float sum = 0.0, sum2 = 0.0;
196	196	int attack_n = 0;
197		− for(i = 0; i < 8; i++){
198		− for(j = 0; j < 128; j++){
	197	+ for (i = 0; i < 8; i++) {
	198	+ for (j = 0; j < 128; j++) {
199	199	v = iir_filter(audio[(i128+j)ctx->avctx->channels], pch->iir_state);
200	200	sum += v*v;
201	201	}
202	202	s[i] = sum;
203	203	sum2 += sum;
204	204	}
205		− for(i = 0; i < 8; i++){
206		− if(s[i] > pch->win_energy * attack_ratio){
	205	+ for (i = 0; i < 8; i++) {
	206	+ if (s[i] > pch->win_energy * attack_ratio) {
207	207	attack_n = i + 1;
208	208	switch_to_eight = 1;
209	209	break;
@@ -212,7 +212,7 @@ static FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx, · 2 unmodified lines
212	212	pch->win_energy = pch->win_energy*7/8 + sum2/64;
213	213
214	214	wi.window_type[1] = prev_type;
215		− switch(prev_type){
	215	+ switch (prev_type) {
216	216	case ONLY_LONG_SEQUENCE:
217	217	wi.window_type[0] = switch_to_eight ? LONG_START_SEQUENCE : ONLY_LONG_SEQUENCE;
218	218	break;
@@ -229,21 +229,21 @@ static FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx, · 10 unmodified lines
229	229	break;
230	230	}
231	231	pch->next_grouping = window_grouping[attack_n];
232		− }else{
233		− for(i = 0; i < 3; i++)
	232	+ } else {
	233	+ for (i = 0; i < 3; i++)
234	234	wi.window_type[i] = prev_type;
235	235	grouping = (prev_type == EIGHT_SHORT_SEQUENCE) ? window_grouping[0] : 0;
236	236	}
237	237
238	238	wi.window_shape = 1;
239		− if(wi.window_type[0] != EIGHT_SHORT_SEQUENCE){
	239	+ if (wi.window_type[0] != EIGHT_SHORT_SEQUENCE) {
240	240	wi.num_windows = 1;
241	241	wi.grouping[0] = 1;
242		− }else{
	242	+ } else {
243	243	int lastgrp = 0;
244	244	wi.num_windows = 8;
245		− for(i = 0; i < 8; i++){
246		− if(!((grouping >> i) & 1))
	245	+ for (i = 0; i < 8; i++) {
	246	+ if (!((grouping >> i) & 1))
247	247	lastgrp = i;
248	248	wi.grouping[lastgrp]++;
249	249	}
@@ -267,11 +267,11 @@ static void psy_3gpp_analyze(FFPsyContext ctx, int channel, const float coefs, · 17 unmodified lines
267	267	Psy3gppCoeffs *coeffs = &pctx->psy_coef[wi->num_windows == 8];
268	268
269	269	//calculate energies, initial thresholds and related values - 5.4.2 "Threshold Calculation"
270		− for(w = 0; w < wi->num_windows*16; w += 16){
271		− for(g = 0; g < num_bands; g++){
	270	+ for (w = 0; w < wi->num_windows*16; w += 16) {
	271	+ for (g = 0; g < num_bands; g++) {
272	272	Psy3gppBand *band = &pch->band[w+g];
273	273	band->energy = 0.0f;
274		− for(i = 0; i < band_sizes[g]; i++)
	274	+ for (i = 0; i < band_sizes[g]; i++)
275	275	band->energy += coefs[start+i] * coefs[start+i];
276	276	band->energy = 1.0f / (512512);
277	277	band->thr = band->energy * 0.001258925f;
@@ -281,17 +281,17 @@ static void psy_3gpp_analyze(FFPsyContext ctx, int channel, const float coefs, · 3 unmodified lines
281	281	}
282	282	}
283	283	//modify thresholds - spread, threshold in quiet - 5.4.3 "Spreaded Energy Calculation"
284		− for(w = 0; w < wi->num_windows*16; w += 16){
	284	+ for (w = 0; w < wi->num_windows*16; w += 16) {
285	285	Psy3gppBand *band = &pch->band[w];
286		− for(g = 1; g < num_bands; g++){
	286	+ for (g = 1; g < num_bands; g++) {
287	287	band[g].thr = FFMAX(band[g].thr, band[g-1].thr * coeffs->spread_low[g-1]);
288	288	}
289		− for(g = num_bands - 2; g >= 0; g--){
	289	+ for (g = num_bands - 2; g >= 0; g--) {
290	290	band[g].thr = FFMAX(band[g].thr, band[g+1].thr * coeffs->spread_hi [g]);
291	291	}
292		− for(g = 0; g < num_bands; g++){
	292	+ for (g = 0; g < num_bands; g++) {
293	293	band[g].thr_quiet = FFMAX(band[g].thr, coeffs->ath[g]);
294		− if(wi->num_windows != 8 && wi->window_type[1] != EIGHT_SHORT_SEQUENCE){
	294	+ if (wi->num_windows != 8 && wi->window_type[1] != EIGHT_SHORT_SEQUENCE) {
295	295	band[g].thr_quiet = fmaxf(PSY_3GPP_RPEMIN*band[g].thr_quiet,
296	296	fminf(band[g].thr_quiet,
297	297	PSY_3GPP_RPELEV*pch->prev_band[w+g].thr_quiet));

libavcodec/psymodel.c+11−11

@@ -35,12 +35,12 @@ av_cold int ff_psy_init(FFPsyContext ctx, AVCodecContext avctx, · 34 unmodified lines
35	35	ctx->num_bands = av_malloc (sizeof(ctx->num_bands[0]) * num_lens);
36	36	memcpy(ctx->bands, bands, sizeof(ctx->bands[0]) * num_lens);
37	37	memcpy(ctx->num_bands, num_bands, sizeof(ctx->num_bands[0]) * num_lens);
38		− switch(ctx->avctx->codec_id){
	38	+ switch (ctx->avctx->codec_id) {
39	39	case CODEC_ID_AAC:
40	40	ctx->model = &ff_aac_psy_model;
41	41	break;
42	42	}
43		− if(ctx->model->init)
	43	+ if (ctx->model->init)
44	44	return ctx->model->init(ctx);
45	45	return 0;
46	46	}
@@ -60,7 +60,7 @@ void ff_psy_set_band_info(FFPsyContext *ctx, int channel, · 13 unmodified lines
60	60
61	61	av_cold void ff_psy_end(FFPsyContext *ctx)
62	62	{
63		− if(ctx->model->end)
	63	+ if (ctx->model->end)
64	64	ctx->model->end(ctx);
65	65	av_freep(&ctx->bands);
66	66	av_freep(&ctx->num_bands);
@@ -84,16 +84,16 @@ av_cold struct FFPsyPreprocessContext* ff_psy_preprocess_init(AVCodecContext *av · 17 unmodified lines
84	84	ctx = av_mallocz(sizeof(FFPsyPreprocessContext));
85	85	ctx->avctx = avctx;
86	86
87		− if(avctx->flags & CODEC_FLAG_QSCALE)
	87	+ if (avctx->flags & CODEC_FLAG_QSCALE)
88	88	cutoff_coeff = 1.0f / av_clip(1 + avctx->global_quality / FF_QUALITY_SCALE, 1, 8);
89	89	else
90	90	cutoff_coeff = avctx->bit_rate / (4.0f * avctx->sample_rate * avctx->channels);
91	91
92	92	ctx->fcoeffs = ff_iir_filter_init_coeffs(FF_FILTER_TYPE_BUTTERWORTH, FF_FILTER_MODE_LOWPASS,
93	93	FILT_ORDER, cutoff_coeff, 0.0, 0.0);
94		− if(ctx->fcoeffs){
	94	+ if (ctx->fcoeffs) {
95	95	ctx->fstate = av_mallocz(sizeof(ctx->fstate[0]) * avctx->channels);
96		− for(i = 0; i < avctx->channels; i++)
	96	+ for (i = 0; i < avctx->channels; i++)
97	97	ctx->fstate[i] = ff_iir_filter_init_state(FILT_ORDER);
98	98	}
99	99	return ctx;
@@ -104,15 +104,15 @@ void ff_psy_preprocess(struct FFPsyPreprocessContext *ctx, · 4 unmodified lines
104	104	int tag, int channels)
105	105	{
106	106	int ch, i;
107		− if(ctx->fstate){
108		− for(ch = 0; ch < channels; ch++){
	107	+ if (ctx->fstate) {
	108	+ for (ch = 0; ch < channels; ch++) {
109	109	ff_iir_filter(ctx->fcoeffs, ctx->fstate[tag+ch], ctx->avctx->frame_size,
110	110	audio + ch, ctx->avctx->channels,
111	111	dest + ch, ctx->avctx->channels);
112	112	}
113		− }else{
114		− for(ch = 0; ch < channels; ch++){
115		− for(i = 0; i < ctx->avctx->frame_size; i++)
	113	+ } else {
	114	+ for (ch = 0; ch < channels; ch++) {
	115	+ for (i = 0; i < ctx->avctx->frame_size; i++)
116	116	dest[ictx->avctx->channels + ch] = audio[ictx->avctx->channels + ch];
117	117	}
118	118	}

libavcodec/psymodel.h+7−7

@@ -30,29 +30,29 @@ · 29 unmodified lines
30	30	/**
31	31	* single band psychoacoustic information
32	32	*/
33		−typedef struct FFPsyBand{
	33	+typedef struct FFPsyBand {
34	34	int bits;
35	35	float energy;
36	36	float threshold;
37	37	float distortion;
38	38	float perceptual_weight;
39		−}FFPsyBand;
	39	+} FFPsyBand;
40	40
41	41	/**
42	42	* windowing related information
43	43	*/
44		−typedef struct FFPsyWindowInfo{
	44	+typedef struct FFPsyWindowInfo {
45	45	int window_type[3]; ///< window type (short/long/transitional, etc.) - current, previous and next
46	46	int window_shape; ///< window shape (sine/KBD/whatever)
47	47	int num_windows; ///< number of windows in a frame
48	48	int grouping[8]; ///< window grouping (for e.g. AAC)
49	49	int *window_sizes; ///< sequence of window sizes inside one frame (for eg. WMA)
50		−}FFPsyWindowInfo;
	50	+} FFPsyWindowInfo;
51	51
52	52	/**
53	53	* context used by psychoacoustic model
54	54	*/
55		−typedef struct FFPsyContext{
	55	+typedef struct FFPsyContext {
56	56	AVCodecContext *avctx; ///< encoder context
57	57	const struct FFPsyModel *model; ///< encoder-specific model functions
58	58
@@ -63,7 +63,7 @@ typedef struct FFPsyContext{ · 4 unmodified lines
63	63	int num_lens; ///< number of scalefactor band sets
64	64
65	65	void* model_priv_data; ///< psychoacoustic model implementation private data
66		−}FFPsyContext;
	66	+} FFPsyContext;
67	67
68	68	/**
69	69	* codec-specific psychoacoustic model implementation
@@ -74,7 +74,7 @@ typedef struct FFPsyModel { · 4 unmodified lines
74	74	FFPsyWindowInfo (window)(FFPsyContext ctx, const int16_t audio, const int16_t la, int channel, int prev_type);
75	75	void (analyze)(FFPsyContext ctx, int channel, const float coeffs, FFPsyWindowInfo wi);
76	76	void (end) (FFPsyContext apc);
77		−}FFPsyModel;
	77	+} FFPsyModel;
78	78
79	79	/**
80	80	* Initialize psychoacoustic model.

Cosmetics: Pretty print the AAC encoder.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code