Mercurial > libavcodec.hg
comparison aaccoder.c @ 10210:47048ee7db4e libavcodec
aacenc: Multiple distortion by lambda after it's summed and not each individual
term before.
author | alexc |
---|---|
date | Mon, 21 Sep 2009 03:50:59 +0000 |
parents | bc939146f2e1 |
children | 337e5592f985 |
comparison
equal
deleted
inserted
replaced
10209:bc939146f2e1 | 10210:47048ee7db4e |
---|---|
119 int offs[4]; | 119 int offs[4]; |
120 #endif /* USE_REALLY_FULL_SEARCH */ | 120 #endif /* USE_REALLY_FULL_SEARCH */ |
121 | 121 |
122 if (!cb) { | 122 if (!cb) { |
123 for (i = 0; i < size; i++) | 123 for (i = 0; i < size; i++) |
124 cost += in[i]*in[i]*lambda; | 124 cost += in[i]*in[i]; |
125 if (bits) | 125 if (bits) |
126 *bits = 0; | 126 *bits = 0; |
127 return cost; | 127 return cost * lambda; |
128 } | 128 } |
129 #ifndef USE_REALLY_FULL_SEARCH | 129 #ifndef USE_REALLY_FULL_SEARCH |
130 offs[0] = 1; | 130 offs[0] = 1; |
131 for (i = 1; i < dim; i++) | 131 for (i = 1; i < dim; i++) |
132 offs[i] = offs[i-1]*range; | 132 offs[i] = offs[i-1]*range; |
139 const float *vec; | 139 const float *vec; |
140 #ifndef USE_REALLY_FULL_SEARCH | 140 #ifndef USE_REALLY_FULL_SEARCH |
141 int (*quants)[2] = &s->qcoefs[i]; | 141 int (*quants)[2] = &s->qcoefs[i]; |
142 mincost = 0.0f; | 142 mincost = 0.0f; |
143 for (j = 0; j < dim; j++) | 143 for (j = 0; j < dim; j++) |
144 mincost += in[i+j]*in[i+j]*lambda; | 144 mincost += in[i+j]*in[i+j]; |
145 minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; | 145 minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; |
146 minbits = ff_aac_spectral_bits[cb-1][minidx]; | 146 minbits = ff_aac_spectral_bits[cb-1][minidx]; |
147 mincost += minbits; | 147 mincost = mincost * lambda + minbits; |
148 for (j = 0; j < (1<<dim); j++) { | 148 for (j = 0; j < (1<<dim); j++) { |
149 float rd = 0.0f; | 149 float rd = 0.0f; |
150 int curbits; | 150 int curbits; |
151 int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; | 151 int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; |
152 int same = 0; | 152 int same = 0; |
190 } else { | 190 } else { |
191 di = t - vec[k]*IQ; | 191 di = t - vec[k]*IQ; |
192 } | 192 } |
193 if (vec[k] != 0.0f) | 193 if (vec[k] != 0.0f) |
194 curbits++; | 194 curbits++; |
195 rd += di*di*lambda; | 195 rd += di*di; |
196 } | 196 } |
197 } else { | 197 } else { |
198 for (k = 0; k < dim; k++) { | 198 for (k = 0; k < dim; k++) { |
199 float di = in[i+k] - vec[k]*IQ; | 199 float di = in[i+k] - vec[k]*IQ; |
200 rd += di*di*lambda; | 200 rd += di*di; |
201 } | 201 } |
202 } | 202 } |
203 rd += curbits; | 203 rd = rd * lambda + curbits; |
204 if (rd < mincost) { | 204 if (rd < mincost) { |
205 mincost = rd; | 205 mincost = rd; |
206 minidx = j; | 206 minidx = j; |
207 minbits = curbits; | 207 minbits = curbits; |
208 } | 208 } |
253 const float *vec; | 253 const float *vec; |
254 #ifndef USE_REALLY_FULL_SEARCH | 254 #ifndef USE_REALLY_FULL_SEARCH |
255 int (*quants)[2] = &s->qcoefs[i]; | 255 int (*quants)[2] = &s->qcoefs[i]; |
256 mincost = 0.0f; | 256 mincost = 0.0f; |
257 for (j = 0; j < dim; j++) | 257 for (j = 0; j < dim; j++) |
258 mincost += in[i+j]*in[i+j]*lambda; | 258 mincost += in[i+j]*in[i+j]; |
259 minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; | 259 minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; |
260 minbits = ff_aac_spectral_bits[cb-1][minidx]; | 260 minbits = ff_aac_spectral_bits[cb-1][minidx]; |
261 mincost += minbits; | 261 mincost = mincost * lambda + minbits; |
262 for (j = 0; j < (1<<dim); j++) { | 262 for (j = 0; j < (1<<dim); j++) { |
263 float rd = 0.0f; | 263 float rd = 0.0f; |
264 int curbits; | 264 int curbits; |
265 int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; | 265 int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40; |
266 int same = 0; | 266 int same = 0; |
305 } else { | 305 } else { |
306 di = t - vec[k]*IQ; | 306 di = t - vec[k]*IQ; |
307 } | 307 } |
308 if (vec[k] != 0.0f) | 308 if (vec[k] != 0.0f) |
309 curbits++; | 309 curbits++; |
310 rd += di*di*lambda; | 310 rd += di*di; |
311 } | 311 } |
312 } else { | 312 } else { |
313 for (k = 0; k < dim; k++) { | 313 for (k = 0; k < dim; k++) { |
314 float di = in[i+k] - vec[k]*IQ; | 314 float di = in[i+k] - vec[k]*IQ; |
315 rd += di*di*lambda; | 315 rd += di*di; |
316 } | 316 } |
317 } | 317 } |
318 rd += curbits; | 318 rd = rd * lambda + curbits; |
319 if (rd < mincost) { | 319 if (rd < mincost) { |
320 mincost = rd; | 320 mincost = rd; |
321 minidx = curidx; | 321 minidx = curidx; |
322 minbits = curbits; | 322 minbits = curbits; |
323 } | 323 } |