Originally committed as revision 19376 to svn://svn.ffmpeg.org/ffmpeg/trunk
Showing the changes to libavcodec/aaccoder.c (1 of 6 files). Show all
Unified · Split
| @@ -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 - c*cbrt(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 += di*di*lambda; |
| 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 += di*di*lambda; |
| 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 - c*cbrt(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 += di*di*lambda; |
| 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 += di*di*lambda; |
| 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_channel*PSY_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_channel*PSY_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_channel*PSY_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 + w2*128, s->scoefs + start + w2*128, 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[w*16+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_channel*PSY_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[w*16+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[w*16+g] || sce->sf_idx[w*16+g] >= 218) | |
| 685 | + if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+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[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) | |
| 743 | + if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) | |
| 744 | 744 | sce->sf_idx[w*16+g]--; |
| 745 | 745 | sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF); |
| 746 | 746 | sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+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 + w*128; |
| 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 + w2*128, 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[w2*128+i]*coefs[w2*128+i]; |
| 819 | 819 | maxq[w*16+g] = fmaxf(maxq[w*16+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[w*16+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_channel*PSY_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[w*16+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 + 128*2, *S34 = s->scoefs + 128*3; |
| 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[w*16+g] && !cpe->ch[1].zeroes[w*16+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[w*16+g] && !cpe->ch[1].zeroes[w*16+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+w2*128+i])*0.5; |
| 973 | 973 | S[i] = sce0->coeffs[start+w2*128+i] |