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 02110-1301 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 16-bit words 33#define BUFFERSIZE 146 ///< the size of the adaptive codebook 34 35 36typedef 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 57static 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 */ 74static 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 */ 89static 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[i-j-1]) >> 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 */ 113static 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 */ 123static 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 136static 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 155static unsigned int rescale_rms(unsigned int rms, unsigned int energy) 156{ 157 return (rms * energy) >> 10; 158} 159 160static 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 181static 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 219static 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 */ 234static 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[i-j]) >> 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 271static 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). */ 294static 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 sub-block 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 353AVCodec 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}; 365