ffmpeg / libavcodec / ra144.c @ 4fdb41a8
History  View  Annotate  Download (9.66 KB)
1 
/*


2 
* Real Audio 1.0 (14.4K)

3 
*

4 
* Copyright (c) 2008 Vitor Sessak

5 
* Copyright (c) 2003 Nick Kurshev

6 
* Based on public domain decoder at http://www.honeypot.net/audio

7 
*

8 
* This file is part of FFmpeg.

9 
*

10 
* FFmpeg is free software; you can redistribute it and/or

11 
* modify it under the terms of the GNU Lesser General Public

12 
* License as published by the Free Software Foundation; either

13 
* version 2.1 of the License, or (at your option) any later version.

14 
*

15 
* FFmpeg is distributed in the hope that it will be useful,

16 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

17 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

18 
* Lesser General Public License for more details.

19 
*

20 
* You should have received a copy of the GNU Lesser General Public

21 
* License along with FFmpeg; if not, write to the Free Software

22 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

23 
*/

24  
25 
#include "avcodec.h" 
26 
#include "bitstream.h" 
27 
#include "ra144.h" 
28 
#include "acelp_filters.h" 
29  
30 
#define NBLOCKS 4 ///< number of subblocks within a block 
31 
#define BLOCKSIZE 40 ///< subblock size in 16bit words 
32 
#define BUFFERSIZE 146 ///< the size of the adaptive codebook 
33  
34  
35 
typedef struct { 
36 
unsigned int old_energy; ///< previous frame energy 
37  
38 
unsigned int lpc_tables[2][10]; 
39  
40 
/** LPC coefficients: lpc_coef[0] is the coefficients of the current frame

41 
* and lpc_coef[1] of the previous one */

42 
unsigned int *lpc_coef[2]; 
43  
44 
unsigned int lpc_refl_rms[2]; 
45  
46 
/** the current subblock padded by the last 10 values of the previous one*/

47 
int16_t curr_sblock[50];

48  
49 
/** adaptive codebook. Its size is two units bigger to avoid a

50 
* buffer overflow */

51 
uint16_t adapt_cb[148];

52 
} RA144Context; 
53  
54 
static int ra144_decode_init(AVCodecContext * avctx) 
55 
{ 
56 
RA144Context *ractx = avctx>priv_data; 
57  
58 
ractx>lpc_coef[0] = ractx>lpc_tables[0]; 
59 
ractx>lpc_coef[1] = ractx>lpc_tables[1]; 
60  
61 
avctx>sample_fmt = SAMPLE_FMT_S16; 
62 
return 0; 
63 
} 
64  
65 
/**

66 
* Evaluate sqrt(x << 24). x must fit in 20 bits. This value is evaluated in an

67 
* odd way to make the output identical to the binary decoder.

68 
*/

69 
static int t_sqrt(unsigned int x) 
70 
{ 
71 
int s = 2; 
72 
while (x > 0xfff) { 
73 
s++; 
74 
x >>= 2;

75 
} 
76  
77 
return ff_sqrt(x << 20) << s; 
78 
} 
79  
80 
/**

81 
* Evaluate the LPC filter coefficients from the reflection coefficients.

82 
* Does the inverse of the eval_refl() function.

83 
*/

84 
static void eval_coefs(int *coefs, const int *refl) 
85 
{ 
86 
int buffer[10]; 
87 
int *b1 = buffer;

88 
int *b2 = coefs;

89 
int i, j;

90  
91 
for (i=0; i < 10; i++) { 
92 
b1[i] = refl[i] << 4;

93  
94 
for (j=0; j < i; j++) 
95 
b1[j] = ((refl[i] * b2[ij1]) >> 12) + b2[j]; 
96  
97 
FFSWAP(int *, b1, b2);

98 
} 
99  
100 
for (i=0; i < 10; i++) 
101 
coefs[i] >>= 4;

102 
} 
103  
104 
/**

105 
* Copy the last offset values of *source to *target. If those values are not

106 
* enough to fill the target buffer, fill it with another copy of those values.

107 
*/

108 
static void copy_and_dup(int16_t *target, const int16_t *source, int offset) 
109 
{ 
110 
source += BUFFERSIZE  offset; 
111  
112 
if (offset > BLOCKSIZE) {

113 
memcpy(target, source, BLOCKSIZE*sizeof(*target));

114 
} else {

115 
memcpy(target, source, offset*sizeof(*target));

116 
memcpy(target + offset, source, (BLOCKSIZE  offset)*sizeof(*target));

117 
} 
118 
} 
119  
120 
/** inverse root mean square */

121 
static int irms(const int16_t *data) 
122 
{ 
123 
unsigned int i, sum = 0; 
124  
125 
for (i=0; i < BLOCKSIZE; i++) 
126 
sum += data[i] * data[i]; 
127  
128 
if (sum == 0) 
129 
return 0; /* OOPS  division by zero */ 
130  
131 
return 0x20000000 / (t_sqrt(sum) >> 8); 
132 
} 
133  
134 
static void add_wav(int16_t *dest, int n, int skip_first, int *m, 
135 
const int16_t *s1, const int8_t *s2, const int8_t *s3) 
136 
{ 
137 
int i;

138 
int v[3]; 
139  
140 
v[0] = 0; 
141 
for (i=!skip_first; i<3; i++) 
142 
v[i] = (gain_val_tab[n][i] * m[i]) >> (gain_exp_tab[n][i] + 1);

143  
144 
for (i=0; i < BLOCKSIZE; i++) 
145 
dest[i] = (s1[i]*v[0] + s2[i]*v[1] + s3[i]*v[2]) >> 12; 
146 
} 
147  
148 
static unsigned int rescale_rms(unsigned int rms, unsigned int energy) 
149 
{ 
150 
return (rms * energy) >> 10; 
151 
} 
152  
153 
static unsigned int rms(const int *data) 
154 
{ 
155 
int i;

156 
unsigned int res = 0x10000; 
157 
int b = 10; 
158  
159 
for (i=0; i < 10; i++) { 
160 
res = (((0x1000000  data[i]*data[i]) >> 12) * res) >> 12; 
161  
162 
if (res == 0) 
163 
return 0; 
164  
165 
while (res <= 0x3fff) { 
166 
b++; 
167 
res <<= 2;

168 
} 
169 
} 
170  
171 
return t_sqrt(res) >> b;

172 
} 
173  
174 
static void do_output_subblock(RA144Context *ractx, const uint16_t *lpc_coefs, 
175 
int gval, GetBitContext *gb)

176 
{ 
177 
uint16_t buffer_a[40];

178 
uint16_t *block; 
179 
int cba_idx = get_bits(gb, 7); // index of the adaptive CB, 0 if none 
180 
int gain = get_bits(gb, 8); 
181 
int cb1_idx = get_bits(gb, 7); 
182 
int cb2_idx = get_bits(gb, 7); 
183 
int m[3]; 
184  
185 
if (cba_idx) {

186 
cba_idx += BLOCKSIZE/2  1; 
187 
copy_and_dup(buffer_a, ractx>adapt_cb, cba_idx); 
188 
m[0] = (irms(buffer_a) * gval) >> 12; 
189 
} else {

190 
m[0] = 0; 
191 
} 
192  
193 
m[1] = (cb1_base[cb1_idx] * gval) >> 8; 
194 
m[2] = (cb2_base[cb2_idx] * gval) >> 8; 
195  
196 
memmove(ractx>adapt_cb, ractx>adapt_cb + BLOCKSIZE, 
197 
(BUFFERSIZE  BLOCKSIZE) * sizeof(*ractx>adapt_cb));

198  
199 
block = ractx>adapt_cb + BUFFERSIZE  BLOCKSIZE; 
200  
201 
add_wav(block, gain, cba_idx, m, buffer_a, 
202 
cb1_vects[cb1_idx], cb2_vects[cb2_idx]); 
203  
204 
memcpy(ractx>curr_sblock, ractx>curr_sblock + 40,

205 
10*sizeof(*ractx>curr_sblock)); 
206  
207 
if (ff_acelp_lp_synthesis_filter(ractx>curr_sblock + 10, lpc_coefs, 
208 
block, BLOCKSIZE, 10, 1, 0xfff)) 
209 
memset(ractx>curr_sblock, 0, 50*sizeof(*ractx>curr_sblock)); 
210 
} 
211  
212 
static void int_to_int16(int16_t *out, const int *inp) 
213 
{ 
214 
int i;

215  
216 
for (i=0; i < 30; i++) 
217 
*out++ = *inp++; 
218 
} 
219  
220 
/**

221 
* Evaluate the reflection coefficients from the filter coefficients.

222 
* Does the inverse of the eval_coefs() function.

223 
*

224 
* @return 1 if one of the reflection coefficients is of magnitude greater than

225 
* 4095, 0 if not.

226 
*/

227 
static int eval_refl(int *refl, const int16_t *coefs, RA144Context *ractx) 
228 
{ 
229 
int b, i, j;

230 
int buffer1[10]; 
231 
int buffer2[10]; 
232 
int *bp1 = buffer1;

233 
int *bp2 = buffer2;

234  
235 
for (i=0; i < 10; i++) 
236 
buffer2[i] = coefs[i]; 
237  
238 
refl[9] = bp2[9]; 
239  
240 
if ((unsigned) bp2[9] + 0x1000 > 0x1fff) { 
241 
av_log(ractx, AV_LOG_ERROR, "Overflow. Broken sample?\n");

242 
return 1; 
243 
} 
244  
245 
for (i=8; i >= 0; i) { 
246 
b = 0x1000((bp2[i+1] * bp2[i+1]) >> 12); 
247  
248 
if (!b)

249 
b = 2;

250  
251 
for (j=0; j <= i; j++) 
252 
bp1[j] = ((bp2[j]  ((refl[i+1] * bp2[ij]) >> 12)) * (0x1000000 / b)) >> 12; 
253  
254 
if ((unsigned) bp1[i] + 0x1000 > 0x1fff) 
255 
return 1; 
256  
257 
refl[i] = bp1[i]; 
258  
259 
FFSWAP(int *, bp1, bp2);

260 
} 
261 
return 0; 
262 
} 
263  
264 
static int interp(RA144Context *ractx, int16_t *out, int block_num, 
265 
int copyold, int energy) 
266 
{ 
267 
int work[10]; 
268 
int a = block_num + 1; 
269 
int b = NBLOCKS  a;

270 
int i;

271  
272 
// Interpolate block coefficients from the this frame forth block and

273 
// last frame forth block

274 
for (i=0; i<30; i++) 
275 
out[i] = (a * ractx>lpc_coef[0][i] + b * ractx>lpc_coef[1][i])>> 2; 
276  
277 
if (eval_refl(work, out, ractx)) {

278 
// The interpolated coefficients are unstable, copy either new or old

279 
// coefficients

280 
int_to_int16(out, ractx>lpc_coef[copyold]); 
281 
return rescale_rms(ractx>lpc_refl_rms[copyold], energy);

282 
} else {

283 
return rescale_rms(rms(work), energy);

284 
} 
285 
} 
286  
287 
/** Uncompress one block (20 bytes > 160*2 bytes) */

288 
static int ra144_decode_frame(AVCodecContext * avctx, void *vdata, 
289 
int *data_size, const uint8_t *buf, int buf_size) 
290 
{ 
291 
static const uint8_t sizes[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2}; 
292 
unsigned int refl_rms[4]; // RMS of the reflection coefficients 
293 
uint16_t block_coefs[4][30]; // LPC coefficients of each subblock 
294 
unsigned int lpc_refl[10]; // LPC reflection coefficients of the frame 
295 
int i, j;

296 
int16_t *data = vdata; 
297 
unsigned int energy; 
298  
299 
RA144Context *ractx = avctx>priv_data; 
300 
GetBitContext gb; 
301  
302 
if (*data_size < 2*160) 
303 
return 1; 
304  
305 
if(buf_size < 20) { 
306 
av_log(avctx, AV_LOG_ERROR, 
307 
"Frame too small (%d bytes). Truncated file?\n", buf_size);

308 
*data_size = 0;

309 
return buf_size;

310 
} 
311 
init_get_bits(&gb, buf, 20 * 8); 
312  
313 
for (i=0; i<10; i++) 
314 
lpc_refl[i] = lpc_refl_cb[i][get_bits(&gb, sizes[i])]; 
315  
316 
eval_coefs(ractx>lpc_coef[0], lpc_refl);

317 
ractx>lpc_refl_rms[0] = rms(lpc_refl);

318  
319 
energy = energy_tab[get_bits(&gb, 5)];

320  
321 
refl_rms[0] = interp(ractx, block_coefs[0], 0, 1, ractx>old_energy); 
322 
refl_rms[1] = interp(ractx, block_coefs[1], 1, energy <= ractx>old_energy, 
323 
t_sqrt(energy*ractx>old_energy) >> 12);

324 
refl_rms[2] = interp(ractx, block_coefs[2], 2, 0, energy); 
325 
refl_rms[3] = rescale_rms(ractx>lpc_refl_rms[0], energy); 
326  
327 
int_to_int16(block_coefs[3], ractx>lpc_coef[0]); 
328  
329 
for (i=0; i < 4; i++) { 
330 
do_output_subblock(ractx, block_coefs[i], refl_rms[i], &gb); 
331  
332 
for (j=0; j < BLOCKSIZE; j++) 
333 
*data++ = av_clip_int16(ractx>curr_sblock[j + 10] << 2); 
334 
} 
335  
336 
ractx>old_energy = energy; 
337 
ractx>lpc_refl_rms[1] = ractx>lpc_refl_rms[0]; 
338  
339 
FFSWAP(unsigned int *, ractx>lpc_coef[0], ractx>lpc_coef[1]); 
340  
341 
*data_size = 2*160; 
342 
return 20; 
343 
} 
344  
345 
AVCodec ra_144_decoder = 
346 
{ 
347 
"real_144",

348 
CODEC_TYPE_AUDIO, 
349 
CODEC_ID_RA_144, 
350 
sizeof(RA144Context),

351 
ra144_decode_init, 
352 
NULL,

353 
NULL,

354 
ra144_decode_frame, 
355 
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),

356 
}; 