Mercurial > libavcodec.hg
comparison ac3.c @ 6003:608c8e9ac412 libavcodec
cosmetics: rename ac3 bit allocation variables
author | jbr |
---|---|
date | Sun, 09 Dec 2007 03:23:04 +0000 |
parents | 29635f7c3d9c |
children | 48759bfbd073 |
comparison
equal
deleted
inserted
replaced
6002:29635f7c3d9c | 6003:608c8e9ac412 |
---|---|
26 | 26 |
27 #include "avcodec.h" | 27 #include "avcodec.h" |
28 #include "ac3.h" | 28 #include "ac3.h" |
29 #include "bitstream.h" | 29 #include "bitstream.h" |
30 | 30 |
31 static uint8_t bndtab[51]; | 31 static uint8_t band_start_tab[51]; |
32 static uint8_t masktab[253]; | 32 static uint8_t bin_to_band_tab[253]; |
33 | 33 |
34 static inline int calc_lowcomp1(int a, int b0, int b1, int c) | 34 static inline int calc_lowcomp1(int a, int b0, int b1, int c) |
35 { | 35 { |
36 if ((b0 + 256) == b1) { | 36 if ((b0 + 256) == b1) { |
37 a = c; | 37 a = c; |
51 return FFMAX(a - 128, 0); | 51 return FFMAX(a - 128, 0); |
52 } | 52 } |
53 } | 53 } |
54 | 54 |
55 void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, | 55 void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, |
56 int16_t *bndpsd) | 56 int16_t *band_psd) |
57 { | 57 { |
58 int bin, i, j, k, end1, v; | 58 int bin, i, j, k, end1, v; |
59 | 59 |
60 /* exponent mapping to PSD */ | 60 /* exponent mapping to PSD */ |
61 for(bin=start;bin<end;bin++) { | 61 for(bin=start;bin<end;bin++) { |
62 psd[bin]=(3072 - (exp[bin] << 7)); | 62 psd[bin]=(3072 - (exp[bin] << 7)); |
63 } | 63 } |
64 | 64 |
65 /* PSD integration */ | 65 /* PSD integration */ |
66 j=start; | 66 j=start; |
67 k=masktab[start]; | 67 k=bin_to_band_tab[start]; |
68 do { | 68 do { |
69 v=psd[j]; | 69 v=psd[j]; |
70 j++; | 70 j++; |
71 end1 = FFMIN(bndtab[k+1], end); | 71 end1 = FFMIN(band_start_tab[k+1], end); |
72 for(i=j;i<end1;i++) { | 72 for(i=j;i<end1;i++) { |
73 /* logadd */ | 73 /* logadd */ |
74 int adr = FFMIN(FFABS(v - psd[j]) >> 1, 255); | 74 int adr = FFMIN(FFABS(v - psd[j]) >> 1, 255); |
75 v = FFMAX(v, psd[j]) + ff_ac3_log_add_tab[adr]; | 75 v = FFMAX(v, psd[j]) + ff_ac3_log_add_tab[adr]; |
76 j++; | 76 j++; |
77 } | 77 } |
78 bndpsd[k]=v; | 78 band_psd[k]=v; |
79 k++; | 79 k++; |
80 } while (end > bndtab[k]); | 80 } while (end > band_start_tab[k]); |
81 } | 81 } |
82 | 82 |
83 void ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *bndpsd, | 83 void ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, |
84 int start, int end, int fgain, int is_lfe, | 84 int start, int end, int fast_gain, int is_lfe, |
85 int deltbae, int deltnseg, uint8_t *deltoffst, | 85 int dba_mode, int dba_nsegs, uint8_t *dba_offsets, |
86 uint8_t *deltlen, uint8_t *deltba, | 86 uint8_t *dba_lengths, uint8_t *dba_values, |
87 int16_t *mask) | 87 int16_t *mask) |
88 { | 88 { |
89 int16_t excite[50]; /* excitation */ | 89 int16_t excite[50]; /* excitation */ |
90 int bin, k; | 90 int bin, k; |
91 int bndstrt, bndend, begin, end1, tmp; | 91 int bndstrt, bndend, begin, end1, tmp; |
92 int lowcomp, fastleak, slowleak; | 92 int lowcomp, fastleak, slowleak; |
93 | 93 |
94 /* excitation function */ | 94 /* excitation function */ |
95 bndstrt = masktab[start]; | 95 bndstrt = bin_to_band_tab[start]; |
96 bndend = masktab[end-1] + 1; | 96 bndend = bin_to_band_tab[end-1] + 1; |
97 | 97 |
98 if (bndstrt == 0) { | 98 if (bndstrt == 0) { |
99 lowcomp = 0; | 99 lowcomp = 0; |
100 lowcomp = calc_lowcomp1(lowcomp, bndpsd[0], bndpsd[1], 384); | 100 lowcomp = calc_lowcomp1(lowcomp, band_psd[0], band_psd[1], 384); |
101 excite[0] = bndpsd[0] - fgain - lowcomp; | 101 excite[0] = band_psd[0] - fast_gain - lowcomp; |
102 lowcomp = calc_lowcomp1(lowcomp, bndpsd[1], bndpsd[2], 384); | 102 lowcomp = calc_lowcomp1(lowcomp, band_psd[1], band_psd[2], 384); |
103 excite[1] = bndpsd[1] - fgain - lowcomp; | 103 excite[1] = band_psd[1] - fast_gain - lowcomp; |
104 begin = 7; | 104 begin = 7; |
105 for (bin = 2; bin < 7; bin++) { | 105 for (bin = 2; bin < 7; bin++) { |
106 if (!(is_lfe && bin == 6)) | 106 if (!(is_lfe && bin == 6)) |
107 lowcomp = calc_lowcomp1(lowcomp, bndpsd[bin], bndpsd[bin+1], 384); | 107 lowcomp = calc_lowcomp1(lowcomp, band_psd[bin], band_psd[bin+1], 384); |
108 fastleak = bndpsd[bin] - fgain; | 108 fastleak = band_psd[bin] - fast_gain; |
109 slowleak = bndpsd[bin] - s->sgain; | 109 slowleak = band_psd[bin] - s->slow_gain; |
110 excite[bin] = fastleak - lowcomp; | 110 excite[bin] = fastleak - lowcomp; |
111 if (!(is_lfe && bin == 6)) { | 111 if (!(is_lfe && bin == 6)) { |
112 if (bndpsd[bin] <= bndpsd[bin+1]) { | 112 if (band_psd[bin] <= band_psd[bin+1]) { |
113 begin = bin + 1; | 113 begin = bin + 1; |
114 break; | 114 break; |
115 } | 115 } |
116 } | 116 } |
117 } | 117 } |
119 end1=bndend; | 119 end1=bndend; |
120 if (end1 > 22) end1=22; | 120 if (end1 > 22) end1=22; |
121 | 121 |
122 for (bin = begin; bin < end1; bin++) { | 122 for (bin = begin; bin < end1; bin++) { |
123 if (!(is_lfe && bin == 6)) | 123 if (!(is_lfe && bin == 6)) |
124 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin); | 124 lowcomp = calc_lowcomp(lowcomp, band_psd[bin], band_psd[bin+1], bin); |
125 | 125 |
126 fastleak = FFMAX(fastleak - s->fdecay, bndpsd[bin] - fgain); | 126 fastleak = FFMAX(fastleak - s->fast_decay, band_psd[bin] - fast_gain); |
127 slowleak = FFMAX(slowleak - s->sdecay, bndpsd[bin] - s->sgain); | 127 slowleak = FFMAX(slowleak - s->slow_decay, band_psd[bin] - s->slow_gain); |
128 excite[bin] = FFMAX(fastleak - lowcomp, slowleak); | 128 excite[bin] = FFMAX(fastleak - lowcomp, slowleak); |
129 } | 129 } |
130 begin = 22; | 130 begin = 22; |
131 } else { | 131 } else { |
132 /* coupling channel */ | 132 /* coupling channel */ |
133 begin = bndstrt; | 133 begin = bndstrt; |
134 | 134 |
135 fastleak = (s->cplfleak << 8) + 768; | 135 fastleak = (s->cpl_fast_leak << 8) + 768; |
136 slowleak = (s->cplsleak << 8) + 768; | 136 slowleak = (s->cpl_slow_leak << 8) + 768; |
137 } | 137 } |
138 | 138 |
139 for (bin = begin; bin < bndend; bin++) { | 139 for (bin = begin; bin < bndend; bin++) { |
140 fastleak = FFMAX(fastleak - s->fdecay, bndpsd[bin] - fgain); | 140 fastleak = FFMAX(fastleak - s->fast_decay, band_psd[bin] - fast_gain); |
141 slowleak = FFMAX(slowleak - s->sdecay, bndpsd[bin] - s->sgain); | 141 slowleak = FFMAX(slowleak - s->slow_decay, band_psd[bin] - s->slow_gain); |
142 excite[bin] = FFMAX(fastleak, slowleak); | 142 excite[bin] = FFMAX(fastleak, slowleak); |
143 } | 143 } |
144 | 144 |
145 /* compute masking curve */ | 145 /* compute masking curve */ |
146 | 146 |
147 for (bin = bndstrt; bin < bndend; bin++) { | 147 for (bin = bndstrt; bin < bndend; bin++) { |
148 tmp = s->dbknee - bndpsd[bin]; | 148 tmp = s->db_per_bit - band_psd[bin]; |
149 if (tmp > 0) { | 149 if (tmp > 0) { |
150 excite[bin] += tmp >> 2; | 150 excite[bin] += tmp >> 2; |
151 } | 151 } |
152 mask[bin] = FFMAX(ff_ac3_hearing_threshold_tab[bin >> s->halfratecod][s->fscod], excite[bin]); | 152 mask[bin] = FFMAX(ff_ac3_hearing_threshold_tab[bin >> s->sr_shift][s->sr_code], excite[bin]); |
153 } | 153 } |
154 | 154 |
155 /* delta bit allocation */ | 155 /* delta bit allocation */ |
156 | 156 |
157 if (deltbae == DBA_REUSE || deltbae == DBA_NEW) { | 157 if (dba_mode == DBA_REUSE || dba_mode == DBA_NEW) { |
158 int band, seg, delta; | 158 int band, seg, delta; |
159 band = 0; | 159 band = 0; |
160 for (seg = 0; seg < deltnseg; seg++) { | 160 for (seg = 0; seg < dba_nsegs; seg++) { |
161 band += deltoffst[seg]; | 161 band += dba_offsets[seg]; |
162 if (deltba[seg] >= 4) { | 162 if (dba_values[seg] >= 4) { |
163 delta = (deltba[seg] - 3) << 7; | 163 delta = (dba_values[seg] - 3) << 7; |
164 } else { | 164 } else { |
165 delta = (deltba[seg] - 4) << 7; | 165 delta = (dba_values[seg] - 4) << 7; |
166 } | 166 } |
167 for (k = 0; k < deltlen[seg]; k++) { | 167 for (k = 0; k < dba_lengths[seg]; k++) { |
168 mask[band] += delta; | 168 mask[band] += delta; |
169 band++; | 169 band++; |
170 } | 170 } |
171 } | 171 } |
172 } | 172 } |
173 } | 173 } |
174 | 174 |
175 void ff_ac3_bit_alloc_calc_bap(int16_t *mask, int16_t *psd, int start, int end, | 175 void ff_ac3_bit_alloc_calc_bap(int16_t *mask, int16_t *psd, int start, int end, |
176 int snroffset, int floor, uint8_t *bap) | 176 int snr_offset, int floor, uint8_t *bap) |
177 { | 177 { |
178 int i, j, k, end1, v, address; | 178 int i, j, k, end1, v, address; |
179 | 179 |
180 /* special case, if snroffset is -960, set all bap's to zero */ | 180 /* special case, if snr offset is -960, set all bap's to zero */ |
181 if(snroffset == -960) { | 181 if(snr_offset == -960) { |
182 memset(bap, 0, 256); | 182 memset(bap, 0, 256); |
183 return; | 183 return; |
184 } | 184 } |
185 | 185 |
186 i = start; | 186 i = start; |
187 j = masktab[start]; | 187 j = bin_to_band_tab[start]; |
188 do { | 188 do { |
189 v = (FFMAX(mask[j] - snroffset - floor, 0) & 0x1FE0) + floor; | 189 v = (FFMAX(mask[j] - snr_offset - floor, 0) & 0x1FE0) + floor; |
190 end1 = FFMIN(bndtab[j] + ff_ac3_critical_band_size_tab[j], end); | 190 end1 = FFMIN(band_start_tab[j] + ff_ac3_critical_band_size_tab[j], end); |
191 for (k = i; k < end1; k++) { | 191 for (k = i; k < end1; k++) { |
192 address = av_clip((psd[i] - v) >> 5, 0, 63); | 192 address = av_clip((psd[i] - v) >> 5, 0, 63); |
193 bap[i] = ff_ac3_bap_tab[address]; | 193 bap[i] = ff_ac3_bap_tab[address]; |
194 i++; | 194 i++; |
195 } | 195 } |
196 } while (end > bndtab[j++]); | 196 } while (end > band_start_tab[j++]); |
197 } | 197 } |
198 | 198 |
199 /* AC3 bit allocation. The algorithm is the one described in the AC3 | 199 /* AC3 bit allocation. The algorithm is the one described in the AC3 |
200 spec. */ | 200 spec. */ |
201 void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap, | 201 void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap, |
202 int8_t *exp, int start, int end, | 202 int8_t *exp, int start, int end, |
203 int snroffset, int fgain, int is_lfe, | 203 int snr_offset, int fast_gain, int is_lfe, |
204 int deltbae,int deltnseg, | 204 int dba_mode, int dba_nsegs, |
205 uint8_t *deltoffst, uint8_t *deltlen, | 205 uint8_t *dba_offsets, uint8_t *dba_lengths, |
206 uint8_t *deltba) | 206 uint8_t *dba_values) |
207 { | 207 { |
208 int16_t psd[256]; /* scaled exponents */ | 208 int16_t psd[256]; /* scaled exponents */ |
209 int16_t bndpsd[50]; /* interpolated exponents */ | 209 int16_t band_psd[50]; /* interpolated exponents */ |
210 int16_t mask[50]; /* masking value */ | 210 int16_t mask[50]; /* masking value */ |
211 | 211 |
212 ff_ac3_bit_alloc_calc_psd(exp, start, end, psd, bndpsd); | 212 ff_ac3_bit_alloc_calc_psd(exp, start, end, psd, band_psd); |
213 | 213 |
214 ff_ac3_bit_alloc_calc_mask(s, bndpsd, start, end, fgain, is_lfe, | 214 ff_ac3_bit_alloc_calc_mask(s, band_psd, start, end, fast_gain, is_lfe, |
215 deltbae, deltnseg, deltoffst, deltlen, deltba, | 215 dba_mode, dba_nsegs, dba_offsets, dba_lengths, dba_values, |
216 mask); | 216 mask); |
217 | 217 |
218 ff_ac3_bit_alloc_calc_bap(mask, psd, start, end, snroffset, s->floor, bap); | 218 ff_ac3_bit_alloc_calc_bap(mask, psd, start, end, snr_offset, s->floor, bap); |
219 } | 219 } |
220 | 220 |
221 /** | 221 /** |
222 * Initializes some tables. | 222 * Initializes some tables. |
223 * note: This function must remain thread safe because it is called by the | 223 * note: This function must remain thread safe because it is called by the |
228 int i, j, k, l, v; | 228 int i, j, k, l, v; |
229 /* compute bndtab and masktab from bandsz */ | 229 /* compute bndtab and masktab from bandsz */ |
230 k = 0; | 230 k = 0; |
231 l = 0; | 231 l = 0; |
232 for(i=0;i<50;i++) { | 232 for(i=0;i<50;i++) { |
233 bndtab[i] = l; | 233 band_start_tab[i] = l; |
234 v = ff_ac3_critical_band_size_tab[i]; | 234 v = ff_ac3_critical_band_size_tab[i]; |
235 for(j=0;j<v;j++) masktab[k++]=i; | 235 for(j=0;j<v;j++) bin_to_band_tab[k++]=i; |
236 l += v; | 236 l += v; |
237 } | 237 } |
238 bndtab[50] = l; | 238 band_start_tab[50] = l; |
239 } | 239 } |