2 * RealAudio 2.0 (28.8K)
3 * Copyright (c) 2003 the ffmpeg project
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #define ALT_BITSTREAM_READER_LE
24 #include "bitstream.h"
28 float sp_lpc
[36]; ///< LPC coefficients for speech data (spec: A)
29 float gain_lpc
[10]; ///< LPC coefficients for gain (spec: GB)
31 float sp_hist
[111]; ///< Speech data history (spec: SB)
33 /** Speech part of the gain autocorrelation (spec: REXP) */
36 float gain_hist
[38]; ///< Log-gain history (spec: SBLG)
38 /** Recursive part of the gain autocorrelation (spec: REXPLG) */
41 float sp_block
[41]; ///< Speech data of four blocks (spec: STTMP)
42 float gain_block
[10]; ///< Gain data of four blocks (spec: GSTATE)
45 static av_cold
int ra288_decode_init(AVCodecContext
*avctx
)
47 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
51 static inline float scalar_product_float(const float * v1
, const float * v2
,
62 static void colmult(float *tgt
, const float *m1
, const float *m2
, int n
)
65 *tgt
++ = *m1
++ * *m2
++;
68 static void decode(RA288Context
*ractx
, float gain
, int cb_coef
)
74 memmove(ractx
->sp_block
+ 5, ractx
->sp_block
, 36*sizeof(*ractx
->sp_block
));
76 for (i
=4; i
>= 0; i
--)
77 ractx
->sp_block
[i
] = -scalar_product_float(ractx
->sp_block
+ i
+ 1,
80 /* block 46 of G.728 spec */
81 sum
= 32. - scalar_product_float(ractx
->gain_lpc
, ractx
->gain_block
, 10);
83 /* block 47 of G.728 spec */
84 sum
= av_clipf(sum
, 0, 60);
86 /* block 48 of G.728 spec */
87 sumsum
= exp(sum
* 0.1151292546497) * gain
; /* pow(10.0,sum/20)*gain */
90 buffer
[i
] = codetable
[cb_coef
][i
] * sumsum
;
92 sum
= scalar_product_float(buffer
, buffer
, 5) / 5;
97 memmove(ractx
->gain_block
, ractx
->gain_block
- 1,
98 10 * sizeof(*ractx
->gain_block
));
100 *ractx
->gain_block
= 10 * log10(sum
) - 32;
102 for (i
=1; i
< 5; i
++)
103 for (j
=i
-1; j
>= 0; j
--)
104 buffer
[i
] -= ractx
->sp_lpc
[i
-j
-1] * buffer
[j
];
107 for (i
=0; i
< 5; i
++)
108 ractx
->sp_block
[4-i
] =
109 av_clipf(ractx
->sp_block
[4-i
] + buffer
[i
], -4095, 4095);
113 * Converts autocorrelation coefficients to LPC coefficients using the
114 * Levinson-Durbin algorithm. See blocks 37 and 50 of the G.728 specification.
116 * @return 0 if success, -1 if fail
118 static int eval_lpc_coeffs(const float *in
, float *tgt
, int n
)
129 in
--; // To avoid a -1 subtraction in the inner loop
131 for (i
=1; i
<= n
; i
++) {
134 for (j
=0; j
< i
- 1; j
++)
135 f1
+= in
[i
-j
]*tgt
[j
];
137 tgt
[i
-1] = f2
= -f1
/f0
;
138 for (j
=0; j
< i
>> 1; j
++) {
139 float temp
= tgt
[j
] + tgt
[i
-j
-2]*f2
;
140 tgt
[i
-j
-2] += tgt
[j
]*f2
;
143 if ((f0
+= f1
*f2
) < 0)
150 static void convolve(float *tgt
, const float *src
, int len
, int n
)
153 tgt
[n
] = scalar_product_float(src
, src
- n
, len
);
158 * Hybrid window filtering. See blocks 36 and 49 of the G.728 specification.
160 * @note This function is slightly different from that described in the spec.
161 * It expects in[0] to be the newest sample and in[n-1] to be the oldest
162 * one stored. The spec has in the more ordinary way (in[0] the oldest
163 * and in[n-1] the newest).
165 * @param order the order of the filter
166 * @param n the length of the input
167 * @param non_rec the number of non-recursive samples
168 * @param out the filter output
169 * @param in pointer to the input of the filter
170 * @param hist pointer to the input history of the filter. It is updated by
172 * @param out pointer to the non-recursive part of the output
173 * @param out2 pointer to the recursive part of the output
174 * @param window pointer to the windowing function table
176 static void do_hybrid_window(int order
, int n
, int non_rec
, const float *in
,
177 float *out
, float *hist
, float *out2
,
181 float buffer1
[order
+ 1];
182 float buffer2
[order
+ 1];
183 float work
[order
+ n
+ non_rec
];
186 memmove(hist
, hist
+ n
, (order
+ non_rec
)*sizeof(*hist
));
188 for (i
=0; i
< n
; i
++)
189 hist
[order
+ non_rec
+ i
] = in
[n
-i
-1];
191 colmult(work
, window
, hist
, order
+ n
+ non_rec
);
193 convolve(buffer1
, work
+ order
, n
, order
);
194 convolve(buffer2
, work
+ order
+ n
, non_rec
, order
);
196 for (i
=0; i
<= order
; i
++) {
197 out2
[i
] = out2
[i
] * 0.5625 + buffer1
[i
];
198 out
[i
] = out2
[i
] + buffer2
[i
];
201 /* Multiply by the white noise correcting factor (WNCF) */
206 * Backward synthesis filter. Find the LPC coefficients from past speech data.
208 static void backward_filter(RA288Context
*ractx
)
210 float temp1
[37]; // RTMP in the spec
211 float temp2
[11]; // GPTPMP in the spec
213 do_hybrid_window(36, 40, 35, ractx
->sp_block
, temp1
, ractx
->sp_hist
,
214 ractx
->sp_rec
, syn_window
);
216 if (!eval_lpc_coeffs(temp1
, ractx
->sp_lpc
, 36))
217 colmult(ractx
->sp_lpc
, ractx
->sp_lpc
, syn_bw_tab
, 36);
219 do_hybrid_window(10, 8, 20, ractx
->gain_block
, temp2
, ractx
->gain_hist
,
220 ractx
->gain_rec
, gain_window
);
222 if (!eval_lpc_coeffs(temp2
, ractx
->gain_lpc
, 10))
223 colmult(ractx
->gain_lpc
, ractx
->gain_lpc
, gain_bw_tab
, 10);
226 static int ra288_decode_frame(AVCodecContext
* avctx
, void *data
,
227 int *data_size
, const uint8_t * buf
,
232 RA288Context
*ractx
= avctx
->priv_data
;
235 if (buf_size
< avctx
->block_align
) {
236 av_log(avctx
, AV_LOG_ERROR
,
237 "Error! Input buffer is too small [%d<%d]\n",
238 buf_size
, avctx
->block_align
);
242 init_get_bits(&gb
, buf
, avctx
->block_align
* 8);
244 for (i
=0; i
< 32; i
++) {
245 float gain
= amptable
[get_bits(&gb
, 3)];
246 int cb_coef
= get_bits(&gb
, 6 + (i
&1));
248 decode(ractx
, gain
, cb_coef
);
250 for (j
=0; j
< 5; j
++)
251 *(out
++) = 8 * ractx
->sp_block
[4 - j
];
254 backward_filter(ractx
);
257 *data_size
= (char *)out
- (char *)data
;
258 return avctx
->block_align
;
261 AVCodec ra_288_decoder
=
266 sizeof(RA288Context
),
271 .long_name
= NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),