ffmpeg / libavcodec / ra144.c @ 72415b2a
History  View  Annotate  Download (9.86 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 "libavutil/intmath.h" 
26 
#include "avcodec.h" 
27 
#include "get_bits.h" 
28 
#include "ra144.h" 
29 
#include "celp_filters.h" 
30  
31 
#define NBLOCKS 4 ///< number of subblocks within a block 
32 
#define BLOCKSIZE 40 ///< subblock size in 16bit words 
33 
#define BUFFERSIZE 146 ///< the size of the adaptive codebook 
34  
35  
36 
typedef struct { 
37 
AVCodecContext *avctx; 
38  
39 
unsigned int old_energy; ///< previous frame energy 
40  
41 
unsigned int lpc_tables[2][10]; 
42  
43 
/** LPC coefficients: lpc_coef[0] is the coefficients of the current frame

44 
* and lpc_coef[1] of the previous one. */

45 
unsigned int *lpc_coef[2]; 
46  
47 
unsigned int lpc_refl_rms[2]; 
48  
49 
/** The current subblock padded by the last 10 values of the previous one. */

50 
int16_t curr_sblock[50];

51  
52 
/** Adaptive codebook, its size is two units bigger to avoid a

53 
* buffer overflow. */

54 
uint16_t adapt_cb[146+2]; 
55 
} RA144Context; 
56  
57 
static av_cold int ra144_decode_init(AVCodecContext * avctx) 
58 
{ 
59 
RA144Context *ractx = avctx>priv_data; 
60  
61 
ractx>avctx = avctx; 
62  
63 
ractx>lpc_coef[0] = ractx>lpc_tables[0]; 
64 
ractx>lpc_coef[1] = ractx>lpc_tables[1]; 
65  
66 
avctx>sample_fmt = SAMPLE_FMT_S16; 
67 
return 0; 
68 
} 
69  
70 
/**

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

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

73 
*/

74 
static int t_sqrt(unsigned int x) 
75 
{ 
76 
int s = 2; 
77 
while (x > 0xfff) { 
78 
s++; 
79 
x >>= 2;

80 
} 
81  
82 
return ff_sqrt(x << 20) << s; 
83 
} 
84  
85 
/**

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

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

88 
*/

89 
static void eval_coefs(int *coefs, const int *refl) 
90 
{ 
91 
int buffer[10]; 
92 
int *b1 = buffer;

93 
int *b2 = coefs;

94 
int i, j;

95  
96 
for (i=0; i < 10; i++) { 
97 
b1[i] = refl[i] << 4;

98  
99 
for (j=0; j < i; j++) 
100 
b1[j] = ((refl[i] * b2[ij1]) >> 12) + b2[j]; 
101  
102 
FFSWAP(int *, b1, b2);

103 
} 
104  
105 
for (i=0; i < 10; i++) 
106 
coefs[i] >>= 4;

107 
} 
108  
109 
/**

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

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

112 
*/

113 
static void copy_and_dup(int16_t *target, const int16_t *source, int offset) 
114 
{ 
115 
source += BUFFERSIZE  offset; 
116  
117 
memcpy(target, source, FFMIN(BLOCKSIZE, offset)*sizeof(*target));

118 
if (offset < BLOCKSIZE)

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

120 
} 
121  
122 
/** inverse root mean square */

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

140 
int v[3]; 
141  
142 
v[0] = 0; 
143 
for (i=!skip_first; i<3; i++) 
144 
v[i] = (gain_val_tab[n][i] * m[i]) >> gain_exp_tab[n]; 
145  
146 
if (v[0]) { 
147 
for (i=0; i < BLOCKSIZE; i++) 
148 
dest[i] = (s1[i]*v[0] + s2[i]*v[1] + s3[i]*v[2]) >> 12; 
149 
} else {

150 
for (i=0; i < BLOCKSIZE; i++) 
151 
dest[i] = ( s2[i]*v[1] + s3[i]*v[2]) >> 12; 
152 
} 
153 
} 
154  
155 
static unsigned int rescale_rms(unsigned int rms, unsigned int energy) 
156 
{ 
157 
return (rms * energy) >> 10; 
158 
} 
159  
160 
static unsigned int rms(const int *data) 
161 
{ 
162 
int i;

163 
unsigned int res = 0x10000; 
164 
int b = 10; 
165  
166 
for (i=0; i < 10; i++) { 
167 
res = (((0x1000000  data[i]*data[i]) >> 12) * res) >> 12; 
168  
169 
if (res == 0) 
170 
return 0; 
171  
172 
while (res <= 0x3fff) { 
173 
b++; 
174 
res <<= 2;

175 
} 
176 
} 
177  
178 
return t_sqrt(res) >> b;

179 
} 
180  
181 
static void do_output_subblock(RA144Context *ractx, const uint16_t *lpc_coefs, 
182 
int gval, GetBitContext *gb)

183 
{ 
184 
uint16_t buffer_a[40];

185 
uint16_t *block; 
186 
int cba_idx = get_bits(gb, 7); // index of the adaptive CB, 0 if none 
187 
int gain = get_bits(gb, 8); 
188 
int cb1_idx = get_bits(gb, 7); 
189 
int cb2_idx = get_bits(gb, 7); 
190 
int m[3]; 
191  
192 
if (cba_idx) {

193 
cba_idx += BLOCKSIZE/2  1; 
194 
copy_and_dup(buffer_a, ractx>adapt_cb, cba_idx); 
195 
m[0] = (irms(buffer_a) * gval) >> 12; 
196 
} else {

197 
m[0] = 0; 
198 
} 
199  
200 
m[1] = (cb1_base[cb1_idx] * gval) >> 8; 
201 
m[2] = (cb2_base[cb2_idx] * gval) >> 8; 
202  
203 
memmove(ractx>adapt_cb, ractx>adapt_cb + BLOCKSIZE, 
204 
(BUFFERSIZE  BLOCKSIZE) * sizeof(*ractx>adapt_cb));

205  
206 
block = ractx>adapt_cb + BUFFERSIZE  BLOCKSIZE; 
207  
208 
add_wav(block, gain, cba_idx, m, cba_idx? buffer_a: NULL,

209 
cb1_vects[cb1_idx], cb2_vects[cb2_idx]); 
210  
211 
memcpy(ractx>curr_sblock, ractx>curr_sblock + 40,

212 
10*sizeof(*ractx>curr_sblock)); 
213  
214 
if (ff_celp_lp_synthesis_filter(ractx>curr_sblock + 10, lpc_coefs, 
215 
block, BLOCKSIZE, 10, 1, 0xfff)) 
216 
memset(ractx>curr_sblock, 0, 50*sizeof(*ractx>curr_sblock)); 
217 
} 
218  
219 
static void int_to_int16(int16_t *out, const int *inp) 
220 
{ 
221 
int i;

222  
223 
for (i=0; i < 10; i++) 
224 
*out++ = *inp++; 
225 
} 
226  
227 
/**

228 
* Evaluate the reflection coefficients from the filter coefficients.

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

230 
*

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

232 
* 4095, 0 if not.

233 
*/

234 
static int eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx) 
235 
{ 
236 
int b, i, j;

237 
int buffer1[10]; 
238 
int buffer2[10]; 
239 
int *bp1 = buffer1;

240 
int *bp2 = buffer2;

241  
242 
for (i=0; i < 10; i++) 
243 
buffer2[i] = coefs[i]; 
244  
245 
refl[9] = bp2[9]; 
246  
247 
if ((unsigned) bp2[9] + 0x1000 > 0x1fff) { 
248 
av_log(avctx, AV_LOG_ERROR, "Overflow. Broken sample?\n");

249 
return 1; 
250 
} 
251  
252 
for (i=8; i >= 0; i) { 
253 
b = 0x1000((bp2[i+1] * bp2[i+1]) >> 12); 
254  
255 
if (!b)

256 
b = 2;

257  
258 
for (j=0; j <= i; j++) 
259 
bp1[j] = ((bp2[j]  ((refl[i+1] * bp2[ij]) >> 12)) * (0x1000000 / b)) >> 12; 
260  
261 
if ((unsigned) bp1[i] + 0x1000 > 0x1fff) 
262 
return 1; 
263  
264 
refl[i] = bp1[i]; 
265  
266 
FFSWAP(int *, bp1, bp2);

267 
} 
268 
return 0; 
269 
} 
270  
271 
static int interp(RA144Context *ractx, int16_t *out, int a, 
272 
int copyold, int energy) 
273 
{ 
274 
int work[10]; 
275 
int b = NBLOCKS  a;

276 
int i;

277  
278 
// Interpolate block coefficients from the this frame's forth block and

279 
// last frame's forth block.

280 
for (i=0; i<10; i++) 
281 
out[i] = (a * ractx>lpc_coef[0][i] + b * ractx>lpc_coef[1][i])>> 2; 
282  
283 
if (eval_refl(work, out, ractx>avctx)) {

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

285 
// coefficients.

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

288 
} else {

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

290 
} 
291 
} 
292  
293 
/** Uncompress one block (20 bytes > 160*2 bytes). */

294 
static int ra144_decode_frame(AVCodecContext * avctx, void *vdata, 
295 
int *data_size, AVPacket *avpkt)

296 
{ 
297 
const uint8_t *buf = avpkt>data;

298 
int buf_size = avpkt>size;

299 
static const uint8_t sizes[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2}; 
300 
unsigned int refl_rms[4]; // RMS of the reflection coefficients 
301 
uint16_t block_coefs[4][10]; // LPC coefficients of each subblock 
302 
unsigned int lpc_refl[10]; // LPC reflection coefficients of the frame 
303 
int i, j;

304 
int16_t *data = vdata; 
305 
unsigned int energy; 
306  
307 
RA144Context *ractx = avctx>priv_data; 
308 
GetBitContext gb; 
309  
310 
if (*data_size < 2*160) 
311 
return 1; 
312  
313 
if(buf_size < 20) { 
314 
av_log(avctx, AV_LOG_ERROR, 
315 
"Frame too small (%d bytes). Truncated file?\n", buf_size);

316 
*data_size = 0;

317 
return buf_size;

318 
} 
319 
init_get_bits(&gb, buf, 20 * 8); 
320  
321 
for (i=0; i<10; i++) 
322 
lpc_refl[i] = lpc_refl_cb[i][get_bits(&gb, sizes[i])]; 
323  
324 
eval_coefs(ractx>lpc_coef[0], lpc_refl);

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

326  
327 
energy = energy_tab[get_bits(&gb, 5)];

328  
329 
refl_rms[0] = interp(ractx, block_coefs[0], 1, 1, ractx>old_energy); 
330 
refl_rms[1] = interp(ractx, block_coefs[1], 2, energy <= ractx>old_energy, 
331 
t_sqrt(energy*ractx>old_energy) >> 12);

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

356 
AVMEDIA_TYPE_AUDIO, 
357 
CODEC_ID_RA_144, 
358 
sizeof(RA144Context),

359 
ra144_decode_init, 
360 
NULL,

361 
NULL,

362 
ra144_decode_frame, 
363 
.long_name = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),

364 
}; 