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 /** speech data history (spec: SB).
33 * Its first 70 coefficients are updated only at backward filtering.
37 /// speech part of the gain autocorrelation (spec: REXP)
40 /** log-gain history (spec: SBLG).
41 * Its first 28 coefficients are updated only at backward filtering.
45 /// recursive part of the gain autocorrelation (spec: REXPLG)
49 static av_cold
int ra288_decode_init(AVCodecContext
*avctx
)
51 avctx
->sample_fmt
= SAMPLE_FMT_FLT
;
55 static inline float scalar_product_float(const float * v1
, const float * v2
,
66 static void apply_window(float *tgt
, const float *m1
, const float *m2
, int n
)
69 *tgt
++ = *m1
++ * *m2
++;
72 static void convolve(float *tgt
, const float *src
, int len
, int n
)
75 tgt
[n
] = scalar_product_float(src
, src
- n
, len
);
79 static void decode(RA288Context
*ractx
, float gain
, int cb_coef
)
84 float *block
= ractx
->sp_hist
+ 70 + 36; // current block
85 float *gain_block
= ractx
->gain_hist
+ 28;
87 memmove(ractx
->sp_hist
+ 70, ractx
->sp_hist
+ 75, 36*sizeof(*block
));
89 /* block 46 of G.728 spec */
91 for (i
=0; i
< 10; i
++)
92 sum
-= gain_block
[9-i
] * ractx
->gain_lpc
[i
];
94 /* block 47 of G.728 spec */
95 sum
= av_clipf(sum
, 0, 60);
97 /* block 48 of G.728 spec */
98 /* exp(sum * 0.1151292546497) == pow(10.0,sum/20) */
99 sumsum
= exp(sum
* 0.1151292546497) * gain
* (1.0/(1<<23));
101 for (i
=0; i
< 5; i
++)
102 buffer
[i
] = codetable
[cb_coef
][i
] * sumsum
;
104 sum
= scalar_product_float(buffer
, buffer
, 5) * ((1<<24)/5.);
108 /* shift and store */
109 memmove(gain_block
, gain_block
+ 1, 9 * sizeof(*gain_block
));
111 gain_block
[9] = 10 * log10(sum
) - 32;
113 for (i
=0; i
< 5; i
++) {
114 block
[i
] = buffer
[i
];
115 for (j
=0; j
< 36; j
++)
116 block
[i
] -= block
[i
-1-j
]*ractx
->sp_lpc
[j
];
120 for (i
=0; i
< 5; i
++)
121 block
[i
] = av_clipf(block
[i
], -4095./4096., 4095./4096.);
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 hist pointer to the input history of the filter
132 * @param out pointer to the non-recursive part of the output
133 * @param out2 pointer to the recursive part of the output
134 * @param window pointer to the windowing function table
136 static void do_hybrid_window(int order
, int n
, int non_rec
, float *out
,
137 float *hist
, float *out2
, const float *window
)
140 float buffer1
[order
+ 1];
141 float buffer2
[order
+ 1];
142 float work
[order
+ n
+ non_rec
];
144 apply_window(work
, window
, hist
, order
+ n
+ non_rec
);
146 convolve(buffer1
, work
+ order
, n
, order
);
147 convolve(buffer2
, work
+ order
+ n
, non_rec
, order
);
149 for (i
=0; i
<= order
; i
++) {
150 out2
[i
] = out2
[i
] * 0.5625 + buffer1
[i
];
151 out
[i
] = out2
[i
] + buffer2
[i
];
154 /* Multiply by the white noise correcting factor (WNCF). */
159 * Backward synthesis filter, find the LPC coefficients from past speech data.
161 static void backward_filter(float *hist
, float *rec
, const float *window
,
162 float *lpc
, const float *tab
,
163 int order
, int n
, int non_rec
, int move_size
)
167 do_hybrid_window(order
, n
, non_rec
, temp
, hist
, rec
, window
);
169 if (!compute_lpc_coefs(temp
, order
, lpc
, 0, 1, 1))
170 apply_window(lpc
, lpc
, tab
, order
);
172 memmove(hist
, hist
+ n
, move_size
*sizeof(*hist
));
175 static int ra288_decode_frame(AVCodecContext
* avctx
, void *data
,
176 int *data_size
, const uint8_t * buf
,
181 RA288Context
*ractx
= avctx
->priv_data
;
184 if (buf_size
< avctx
->block_align
) {
185 av_log(avctx
, AV_LOG_ERROR
,
186 "Error! Input buffer is too small [%d<%d]\n",
187 buf_size
, avctx
->block_align
);
191 if (*data_size
< 32*5*4)
194 init_get_bits(&gb
, buf
, avctx
->block_align
* 8);
196 for (i
=0; i
< 32; i
++) {
197 float gain
= amptable
[get_bits(&gb
, 3)];
198 int cb_coef
= get_bits(&gb
, 6 + (i
&1));
200 decode(ractx
, gain
, cb_coef
);
202 for (j
=0; j
< 5; j
++)
203 *(out
++) = ractx
->sp_hist
[70 + 36 + j
];
206 backward_filter(ractx
->sp_hist
, ractx
->sp_rec
, syn_window
,
207 ractx
->sp_lpc
, syn_bw_tab
, 36, 40, 35, 70);
209 backward_filter(ractx
->gain_hist
, ractx
->gain_rec
, gain_window
,
210 ractx
->gain_lpc
, gain_bw_tab
, 10, 8, 20, 28);
214 *data_size
= (char *)out
- (char *)data
;
215 return avctx
->block_align
;
218 AVCodec ra_288_decoder
=
223 sizeof(RA288Context
),
228 .long_name
= NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),