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"
29 float sp_lpc
[36]; ///< LPC coefficients for speech data (spec: A)
30 float gain_lpc
[10]; ///< LPC coefficients for gain (spec: GB)
32 float sp_hist
[111]; ///< speech data history (spec: SB)
34 /// speech part of the gain autocorrelation (spec: REXP)
37 float gain_hist
[38]; ///< log-gain history (spec: SBLG)
39 /// recursive part of the gain autocorrelation (spec: REXPLG)
42 float sp_block
[41]; ///< four blocks of speech data (spec: STTMP)
43 float gain_block
[10]; ///< four blocks of gain data (spec: GSTATE)
46 static av_cold
int ra288_decode_init(AVCodecContext
*avctx
)
48 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
52 static inline float scalar_product_float(const float * v1
, const float * v2
,
63 static void apply_window(float *tgt
, const float *m1
, const float *m2
, int n
)
66 *tgt
++ = *m1
++ * *m2
++;
69 static void decode(RA288Context
*ractx
, float gain
, int cb_coef
)
74 float *block
= ractx
->sp_block
+ 36; // current block
76 memmove(ractx
->sp_block
, ractx
->sp_block
+ 5, 36*sizeof(*ractx
->sp_block
));
78 for (i
=0; i
< 5; i
++) {
80 for (j
=0; j
< 36; j
++)
81 block
[i
] -= block
[i
-1-j
]*ractx
->sp_lpc
[j
];
84 /* block 46 of G.728 spec */
86 for (i
=0; i
< 10; i
++)
87 sum
-= ractx
->gain_block
[9-i
] * ractx
->gain_lpc
[i
];
89 /* block 47 of G.728 spec */
90 sum
= av_clipf(sum
, 0, 60);
92 /* block 48 of G.728 spec */
93 sumsum
= exp(sum
* 0.1151292546497) * gain
; /* pow(10.0,sum/20)*gain */
96 buffer
[i
] = codetable
[cb_coef
][i
] * sumsum
* (1./2048.);
98 sum
= scalar_product_float(buffer
, buffer
, 5) / 5;
102 /* shift and store */
103 memmove(ractx
->gain_block
, ractx
->gain_block
+ 1,
104 9 * sizeof(*ractx
->gain_block
));
106 ractx
->gain_block
[9] = 10 * log10(sum
) - 32;
108 for (i
=1; i
< 5; i
++)
109 for (j
=i
-1; j
>= 0; j
--)
110 buffer
[i
] -= ractx
->sp_lpc
[i
-j
-1] * buffer
[j
];
113 for (i
=0; i
< 5; i
++)
114 block
[i
] = av_clipf(block
[i
] + buffer
[i
], -4095, 4095);
117 static void convolve(float *tgt
, const float *src
, int len
, int n
)
120 tgt
[n
] = scalar_product_float(src
, src
- n
, len
);
125 * Hybrid window filtering, see blocks 36 and 49 of the G.728 specification.
127 * @param order filter order
128 * @param n input length
129 * @param non_rec number of non-recursive samples
130 * @param out filter output
131 * @param in pointer to the input of the filter
132 * @param hist Pointer to the input history of the filter, it is updated by
134 * @param out pointer to the non-recursive part of the output
135 * @param out2 pointer to the recursive part of the output
136 * @param window pointer to the windowing function table
138 static void do_hybrid_window(int order
, int n
, int non_rec
, const float *in
,
139 float *out
, float *hist
, float *out2
,
143 float buffer1
[order
+ 1];
144 float buffer2
[order
+ 1];
145 float work
[order
+ n
+ non_rec
];
148 memmove(hist
, hist
+ n
, (order
+ non_rec
)*sizeof(*hist
));
149 memcpy (hist
+ order
+ non_rec
, in
, n
*sizeof(*hist
));
151 apply_window(work
, window
, hist
, order
+ n
+ non_rec
);
153 convolve(buffer1
, work
+ order
, n
, order
);
154 convolve(buffer2
, work
+ order
+ n
, non_rec
, order
);
156 for (i
=0; i
<= order
; i
++) {
157 out2
[i
] = out2
[i
] * 0.5625 + buffer1
[i
];
158 out
[i
] = out2
[i
] + buffer2
[i
];
161 /* Multiply by the white noise correcting factor (WNCF). */
166 * Backward synthesis filter, find the LPC coefficients from past speech data.
168 static void backward_filter(RA288Context
*ractx
)
170 float temp1
[37]; // RTMP in the spec
171 float temp2
[11]; // GPTPMP in the spec
173 do_hybrid_window(36, 40, 35, ractx
->sp_block
+1, temp1
, ractx
->sp_hist
,
174 ractx
->sp_rec
, syn_window
);
176 if (!compute_lpc_coefs(temp1
, 36, ractx
->sp_lpc
, 0, 1, 1))
177 apply_window(ractx
->sp_lpc
, ractx
->sp_lpc
, syn_bw_tab
, 36);
179 do_hybrid_window(10, 8, 20, ractx
->gain_block
+2, temp2
, ractx
->gain_hist
,
180 ractx
->gain_rec
, gain_window
);
182 if (!compute_lpc_coefs(temp2
, 10, ractx
->gain_lpc
, 0, 1, 1))
183 apply_window(ractx
->gain_lpc
, ractx
->gain_lpc
, gain_bw_tab
, 10);
186 static int ra288_decode_frame(AVCodecContext
* avctx
, void *data
,
187 int *data_size
, const uint8_t * buf
,
192 RA288Context
*ractx
= avctx
->priv_data
;
195 if (buf_size
< avctx
->block_align
) {
196 av_log(avctx
, AV_LOG_ERROR
,
197 "Error! Input buffer is too small [%d<%d]\n",
198 buf_size
, avctx
->block_align
);
202 if (*data_size
< 32*5*2)
205 init_get_bits(&gb
, buf
, avctx
->block_align
* 8);
207 for (i
=0; i
< 32; i
++) {
208 float gain
= amptable
[get_bits(&gb
, 3)];
209 int cb_coef
= get_bits(&gb
, 6 + (i
&1));
211 decode(ractx
, gain
, cb_coef
);
213 for (j
=0; j
< 5; j
++)
214 *(out
++) = 8 * ractx
->sp_block
[36 + j
];
217 backward_filter(ractx
);
220 *data_size
= (char *)out
- (char *)data
;
221 return avctx
->block_align
;
224 AVCodec ra_288_decoder
=
229 sizeof(RA288Context
),
234 .long_name
= NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),