summaryrefslogtreecommitdiff
path: root/lib/rbcodec/codecs/libwmavoice/wmavoice.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/rbcodec/codecs/libwmavoice/wmavoice.c')
-rw-r--r--lib/rbcodec/codecs/libwmavoice/wmavoice.c2060
1 files changed, 2060 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libwmavoice/wmavoice.c b/lib/rbcodec/codecs/libwmavoice/wmavoice.c
new file mode 100644
index 0000000000..4d31334c36
--- /dev/null
+++ b/lib/rbcodec/codecs/libwmavoice/wmavoice.c
@@ -0,0 +1,2060 @@
1/*
2 * Windows Media Audio Voice decoder.
3 * Copyright (c) 2009 Ronald S. Bultje
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22/**
23 * @file
24 * @brief Windows Media Audio Voice compatible decoder
25 * @author Ronald S. Bultje <rsbultje@gmail.com>
26 */
27
28#include <math.h>
29#include "wmavoice.h"
30#include "get_bits.h"
31#include "put_bits.h"
32#include "wmavoice_data.h"
33#include "celp_math.h"
34#include "celp_filters.h"
35#include "acelp_vectors.h"
36#include "acelp_filters.h"
37#include "lsp.h"
38#include "libavutil/lzo.h"
39#include "avfft.h"
40#include "fft.h"
41
42#define MAX_BLOCKS 8 ///< maximum number of blocks per frame
43#define MAX_LSPS 16 ///< maximum filter order
44#define MAX_LSPS_ALIGN16 16 ///< same as #MAX_LSPS; needs to be multiple
45 ///< of 16 for ASM input buffer alignment
46#define MAX_FRAMES 3 ///< maximum number of frames per superframe
47#define MAX_FRAMESIZE 160 ///< maximum number of samples per frame
48#define MAX_SIGNAL_HISTORY 416 ///< maximum excitation signal history
49#define MAX_SFRAMESIZE (MAX_FRAMESIZE * MAX_FRAMES)
50 ///< maximum number of samples per superframe
51#define SFRAME_CACHE_MAXSIZE 256 ///< maximum cache size for frame data that
52 ///< was split over two packets
53#define VLC_NBITS 6 ///< number of bits to read per VLC iteration
54
55/**
56 * Frame type VLC coding.
57 */
58static VLC frame_type_vlc;
59
60/**
61 * Adaptive codebook types.
62 */
63enum {
64 ACB_TYPE_NONE = 0, ///< no adaptive codebook (only hardcoded fixed)
65 ACB_TYPE_ASYMMETRIC = 1, ///< adaptive codebook with per-frame pitch, which
66 ///< we interpolate to get a per-sample pitch.
67 ///< Signal is generated using an asymmetric sinc
68 ///< window function
69 ///< @note see #wmavoice_ipol1_coeffs
70 ACB_TYPE_HAMMING = 2 ///< Per-block pitch with signal generation using
71 ///< a Hamming sinc window function
72 ///< @note see #wmavoice_ipol2_coeffs
73};
74
75/**
76 * Fixed codebook types.
77 */
78enum {
79 FCB_TYPE_SILENCE = 0, ///< comfort noise during silence
80 ///< generated from a hardcoded (fixed) codebook
81 ///< with per-frame (low) gain values
82 FCB_TYPE_HARDCODED = 1, ///< hardcoded (fixed) codebook with per-block
83 ///< gain values
84 FCB_TYPE_AW_PULSES = 2, ///< Pitch-adaptive window (AW) pulse signals,
85 ///< used in particular for low-bitrate streams
86 FCB_TYPE_EXC_PULSES = 3, ///< Innovation (fixed) codebook pulse sets in
87 ///< combinations of either single pulses or
88 ///< pulse pairs
89};
90
91/**
92 * Description of frame types.
93 */
94static const struct frame_type_desc {
95 uint8_t n_blocks; ///< amount of blocks per frame (each block
96 ///< (contains 160/#n_blocks samples)
97 uint8_t log_n_blocks; ///< log2(#n_blocks)
98 uint8_t acb_type; ///< Adaptive codebook type (ACB_TYPE_*)
99 uint8_t fcb_type; ///< Fixed codebook type (FCB_TYPE_*)
100 uint8_t dbl_pulses; ///< how many pulse vectors have pulse pairs
101 ///< (rather than just one single pulse)
102 ///< only if #fcb_type == #FCB_TYPE_EXC_PULSES
103 uint16_t frame_size; ///< the amount of bits that make up the block
104 ///< data (per frame)
105} frame_descs[17] = {
106 { 1, 0, ACB_TYPE_NONE, FCB_TYPE_SILENCE, 0, 0 },
107 { 2, 1, ACB_TYPE_NONE, FCB_TYPE_HARDCODED, 0, 28 },
108 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_AW_PULSES, 0, 46 },
109 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2, 80 },
110 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 104 },
111 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 0, 108 },
112 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2, 132 },
113 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 168 },
114 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 64 },
115 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 80 },
116 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 104 },
117 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 108 },
118 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 132 },
119 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 168 },
120 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 176 },
121 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 208 },
122 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 256 }
123};
124
125/**
126 * WMA Voice decoding context.
127 */
128typedef struct {
129 /**
130 * @defgroup struct_global Global values
131 * Global values, specified in the stream header / extradata or used
132 * all over.
133 * @{
134 */
135 GetBitContext gb; ///< packet bitreader. During decoder init,
136 ///< it contains the extradata from the
137 ///< demuxer. During decoding, it contains
138 ///< packet data.
139 int8_t vbm_tree[25]; ///< converts VLC codes to frame type
140
141 int spillover_bitsize; ///< number of bits used to specify
142 ///< #spillover_nbits in the packet header
143 ///< = ceil(log2(ctx->block_align << 3))
144 int history_nsamples; ///< number of samples in history for signal
145 ///< prediction (through ACB)
146
147 /* postfilter specific values */
148 int do_apf; ///< whether to apply the averaged
149 ///< projection filter (APF)
150 int denoise_strength; ///< strength of denoising in Wiener filter
151 ///< [0-11]
152 int denoise_tilt_corr; ///< Whether to apply tilt correction to the
153 ///< Wiener filter coefficients (postfilter)
154 int dc_level; ///< Predicted amount of DC noise, based
155 ///< on which a DC removal filter is used
156
157 int lsps; ///< number of LSPs per frame [10 or 16]
158 int lsp_q_mode; ///< defines quantizer defaults [0, 1]
159 int lsp_def_mode; ///< defines different sets of LSP defaults
160 ///< [0, 1]
161 int frame_lsp_bitsize; ///< size (in bits) of LSPs, when encoded
162 ///< per-frame (independent coding)
163 int sframe_lsp_bitsize; ///< size (in bits) of LSPs, when encoded
164 ///< per superframe (residual coding)
165
166 int min_pitch_val; ///< base value for pitch parsing code
167 int max_pitch_val; ///< max value + 1 for pitch parsing
168 int pitch_nbits; ///< number of bits used to specify the
169 ///< pitch value in the frame header
170 int block_pitch_nbits; ///< number of bits used to specify the
171 ///< first block's pitch value
172 int block_pitch_range; ///< range of the block pitch
173 int block_delta_pitch_nbits; ///< number of bits used to specify the
174 ///< delta pitch between this and the last
175 ///< block's pitch value, used in all but
176 ///< first block
177 int block_delta_pitch_hrange; ///< 1/2 range of the delta (full range is
178 ///< from -this to +this-1)
179 uint16_t block_conv_table[4]; ///< boundaries for block pitch unit/scale
180 ///< conversion
181
182 /**
183 * @}
184 * @defgroup struct_packet Packet values
185 * Packet values, specified in the packet header or related to a packet.
186 * A packet is considered to be a single unit of data provided to this
187 * decoder by the demuxer.
188 * @{
189 */
190 int spillover_nbits; ///< number of bits of the previous packet's
191 ///< last superframe preceeding this
192 ///< packet's first full superframe (useful
193 ///< for re-synchronization also)
194 int has_residual_lsps; ///< if set, superframes contain one set of
195 ///< LSPs that cover all frames, encoded as
196 ///< independent and residual LSPs; if not
197 ///< set, each frame contains its own, fully
198 ///< independent, LSPs
199 int skip_bits_next; ///< number of bits to skip at the next call
200 ///< to #wmavoice_decode_packet() (since
201 ///< they're part of the previous superframe)
202
203 uint8_t sframe_cache[SFRAME_CACHE_MAXSIZE + FF_INPUT_BUFFER_PADDING_SIZE];
204 ///< cache for superframe data split over
205 ///< multiple packets
206 int sframe_cache_size; ///< set to >0 if we have data from an
207 ///< (incomplete) superframe from a previous
208 ///< packet that spilled over in the current
209 ///< packet; specifies the amount of bits in
210 ///< #sframe_cache
211 PutBitContext pb; ///< bitstream writer for #sframe_cache
212
213 /**
214 * @}
215 * @defgroup struct_frame Frame and superframe values
216 * Superframe and frame data - these can change from frame to frame,
217 * although some of them do in that case serve as a cache / history for
218 * the next frame or superframe.
219 * @{
220 */
221 double prev_lsps[MAX_LSPS]; ///< LSPs of the last frame of the previous
222 ///< superframe
223 int last_pitch_val; ///< pitch value of the previous frame
224 int last_acb_type; ///< frame type [0-2] of the previous frame
225 int pitch_diff_sh16; ///< ((cur_pitch_val - #last_pitch_val)
226 ///< << 16) / #MAX_FRAMESIZE
227 float silence_gain; ///< set for use in blocks if #ACB_TYPE_NONE
228
229 int aw_idx_is_ext; ///< whether the AW index was encoded in
230 ///< 8 bits (instead of 6)
231 int aw_pulse_range; ///< the range over which #aw_pulse_set1()
232 ///< can apply the pulse, relative to the
233 ///< value in aw_first_pulse_off. The exact
234 ///< position of the first AW-pulse is within
235 ///< [pulse_off, pulse_off + this], and
236 ///< depends on bitstream values; [16 or 24]
237 int aw_n_pulses[2]; ///< number of AW-pulses in each block; note
238 ///< that this number can be negative (in
239 ///< which case it basically means "zero")
240 int aw_first_pulse_off[2]; ///< index of first sample to which to
241 ///< apply AW-pulses, or -0xff if unset
242 int aw_next_pulse_off_cache; ///< the position (relative to start of the
243 ///< second block) at which pulses should
244 ///< start to be positioned, serves as a
245 ///< cache for pitch-adaptive window pulses
246 ///< between blocks
247
248 int frame_cntr; ///< current frame index [0 - 0xFFFE]; is
249 ///< only used for comfort noise in #pRNG()
250 float gain_pred_err[6]; ///< cache for gain prediction
251 float excitation_history[MAX_SIGNAL_HISTORY];
252 ///< cache of the signal of previous
253 ///< superframes, used as a history for
254 ///< signal generation
255 float synth_history[MAX_LSPS]; ///< see #excitation_history
256 /**
257 * @}
258 * @defgroup post_filter Postfilter values
259 * Varibales used for postfilter implementation, mostly history for
260 * smoothing and so on, and context variables for FFT/iFFT.
261 * @{
262 */
263 RDFTContext rdft, irdft; ///< contexts for FFT-calculation in the
264 ///< postfilter (for denoise filter)
265 DCTContext dct, dst; ///< contexts for phase shift (in Hilbert
266 ///< transform, part of postfilter)
267 float sin[511], cos[511]; ///< 8-bit cosine/sine windows over [-pi,pi]
268 ///< range
269 float postfilter_agc; ///< gain control memory, used in
270 ///< #adaptive_gain_control()
271 float dcf_mem[2]; ///< DC filter history
272 float zero_exc_pf[MAX_SIGNAL_HISTORY + MAX_SFRAMESIZE];
273 ///< zero filter output (i.e. excitation)
274 ///< by postfilter
275 float denoise_filter_cache[MAX_FRAMESIZE];
276 int denoise_filter_cache_size; ///< samples in #denoise_filter_cache
277 DECLARE_ALIGNED(16, float, tilted_lpcs_pf)[0x80];
278 ///< aligned buffer for LPC tilting
279 DECLARE_ALIGNED(16, float, denoise_coeffs_pf)[0x80];
280 ///< aligned buffer for denoise coefficients
281 DECLARE_ALIGNED(16, float, synth_filter_out_buf)[0x80 + MAX_LSPS_ALIGN16];
282 ///< aligned buffer for postfilter speech
283 ///< synthesis
284 /**
285 * @}
286 */
287} WMAVoiceContext;
288
289/* global decode context */
290static WMAVoiceContext globWMAVoiceCtx;
291
292
293/**
294 * Set up the variable bit mode (VBM) tree from container extradata.
295 * @param gb bit I/O context.
296 * The bit context (s->gb) should be loaded with byte 23-46 of the
297 * container extradata (i.e. the ones containing the VBM tree).
298 * @param vbm_tree pointer to array to which the decoded VBM tree will be
299 * written.
300 * @return 0 on success, <0 on error.
301 */
302static av_cold int decode_vbmtree(GetBitContext *gb, int8_t vbm_tree[25])
303{
304 static const uint8_t bits[] = {
305 2, 2, 2, 4, 4, 4,
306 6, 6, 6, 8, 8, 8,
307 10, 10, 10, 12, 12, 12,
308 14, 14, 14, 14
309 };
310 static const uint16_t codes[] = {
311 0x0000, 0x0001, 0x0002, // 00/01/10
312 0x000c, 0x000d, 0x000e, // 11+00/01/10
313 0x003c, 0x003d, 0x003e, // 1111+00/01/10
314 0x00fc, 0x00fd, 0x00fe, // 111111+00/01/10
315 0x03fc, 0x03fd, 0x03fe, // 11111111+00/01/10
316 0x0ffc, 0x0ffd, 0x0ffe, // 1111111111+00/01/10
317 0x3ffc, 0x3ffd, 0x3ffe, 0x3fff // 111111111111+xx
318 };
319 int cntr[8], n, res;
320
321 memset(vbm_tree, 0xff, sizeof(int8_t) * 25);
322 memset(cntr, 0, sizeof(cntr));
323 for (n = 0; n < 17; n++) {
324 res = get_bits(gb, 3);
325 if (cntr[res] > 3) // should be >= 3 + (res == 7))
326 return -1;
327 vbm_tree[res * 3 + cntr[res]++] = n;
328 }
329 INIT_VLC_STATIC(&frame_type_vlc, VLC_NBITS, sizeof(bits),
330 bits, 1, 1, codes, 2, 2, 132);
331 return 0;
332}
333
334/**
335 * Set up decoder with parameters from demuxer (extradata etc.).
336 */
337av_cold int wmavoice_decode_init(AVCodecContext *ctx)
338{
339 int n, flags, pitch_range, lsp16_flag;
340 ctx->priv_data = &globWMAVoiceCtx;
341 WMAVoiceContext *s = ctx->priv_data;
342
343 /**
344 * Extradata layout:
345 * - byte 0-18: WMAPro-in-WMAVoice extradata (see wmaprodec.c),
346 * - byte 19-22: flags field (annoyingly in LE; see below for known
347 * values),
348 * - byte 23-46: variable bitmode tree (really just 17 * 3 bits,
349 * rest is 0).
350 */
351 if (ctx->extradata_size != 46) {
352 av_log(ctx, AV_LOG_ERROR,
353 "Invalid extradata size %d (should be 46)\n",
354 ctx->extradata_size);
355 return -1;
356 }
357 flags = AV_RL32(ctx->extradata + 18);
358 s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
359 s->do_apf = flags & 0x1;
360 if (s->do_apf) {
361 ff_rdft_init(&s->rdft, 7, DFT_R2C);
362 ff_rdft_init(&s->irdft, 7, IDFT_C2R);
363 ff_dct_init(&s->dct, 6, DCT_I);
364 ff_dct_init(&s->dst, 6, DST_I);
365
366 ff_sine_window_init(s->cos, 256);
367 memcpy(&s->sin[255], s->cos, 256 * sizeof(s->cos[0]));
368 for (n = 0; n < 255; n++) {
369 s->sin[n] = -s->sin[510 - n];
370 s->cos[510 - n] = s->cos[n];
371 }
372 }
373 s->denoise_strength = (flags >> 2) & 0xF;
374 if (s->denoise_strength >= 12) {
375 av_log(ctx, AV_LOG_ERROR,
376 "Invalid denoise filter strength %d (max=11)\n",
377 s->denoise_strength);
378 return -1;
379 }
380 s->denoise_tilt_corr = !!(flags & 0x40);
381 s->dc_level = (flags >> 7) & 0xF;
382 s->lsp_q_mode = !!(flags & 0x2000);
383 s->lsp_def_mode = !!(flags & 0x4000);
384 lsp16_flag = flags & 0x1000;
385 if (lsp16_flag) {
386 s->lsps = 16;
387 s->frame_lsp_bitsize = 34;
388 s->sframe_lsp_bitsize = 60;
389 } else {
390 s->lsps = 10;
391 s->frame_lsp_bitsize = 24;
392 s->sframe_lsp_bitsize = 48;
393 }
394 for (n = 0; n < s->lsps; n++)
395 s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
396
397 init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);
398 if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {
399 av_log(ctx, AV_LOG_ERROR, "Invalid VBM tree; broken extradata?\n");
400 return -1;
401 }
402
403 s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;
404 s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
405 pitch_range = s->max_pitch_val - s->min_pitch_val;
406 s->pitch_nbits = av_ceil_log2(pitch_range);
407 s->last_pitch_val = 40;
408 s->last_acb_type = ACB_TYPE_NONE;
409 s->history_nsamples = s->max_pitch_val + 8;
410
411 if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {
412 int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
413 max_sr = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;
414
415 av_log(ctx, AV_LOG_ERROR,
416 "Unsupported samplerate %d (min=%d, max=%d)\n",
417 ctx->sample_rate, min_sr, max_sr); // 322-22097 Hz
418
419 return -1;
420 }
421
422 s->block_conv_table[0] = s->min_pitch_val;
423 s->block_conv_table[1] = (pitch_range * 25) >> 6;
424 s->block_conv_table[2] = (pitch_range * 44) >> 6;
425 s->block_conv_table[3] = s->max_pitch_val - 1;
426 s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
427 s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);
428 s->block_pitch_range = s->block_conv_table[2] +
429 s->block_conv_table[3] + 1 +
430 2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);
431 s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);
432
433 ctx->sample_fmt = SAMPLE_FMT_FLT;
434
435 return 0;
436}
437
438/**
439 * @defgroup postfilter Postfilter functions
440 * Postfilter functions (gain control, wiener denoise filter, DC filter,
441 * kalman smoothening, plus surrounding code to wrap it)
442 * @{
443 */
444/**
445 * Adaptive gain control (as used in postfilter).
446 *
447 * Identical to #ff_adaptive_gain_control() in acelp_vectors.c, except
448 * that the energy here is calculated using sum(abs(...)), whereas the
449 * other codecs (e.g. AMR-NB, SIPRO) use sqrt(dotproduct(...)).
450 *
451 * @param out output buffer for filtered samples
452 * @param in input buffer containing the samples as they are after the
453 * postfilter steps so far
454 * @param speech_synth input buffer containing speech synth before postfilter
455 * @param size input buffer size
456 * @param alpha exponential filter factor
457 * @param gain_mem pointer to filter memory (single float)
458 */
459static void adaptive_gain_control(float *out, const float *in,
460 const float *speech_synth,
461 int size, float alpha, float *gain_mem)
462{
463 int i;
464 float speech_energy = 0.0, postfilter_energy = 0.0, gain_scale_factor;
465 float mem = *gain_mem;
466
467 for (i = 0; i < size; i++) {
468 speech_energy += fabsf(speech_synth[i]);
469 postfilter_energy += fabsf(in[i]);
470 }
471 gain_scale_factor = (1.0 - alpha) * speech_energy / postfilter_energy;
472
473 for (i = 0; i < size; i++) {
474 mem = alpha * mem + gain_scale_factor;
475 out[i] = in[i] * mem;
476 }
477
478 *gain_mem = mem;
479}
480
481/**
482 * Kalman smoothing function.
483 *
484 * This function looks back pitch +/- 3 samples back into history to find
485 * the best fitting curve (that one giving the optimal gain of the two
486 * signals, i.e. the highest dot product between the two), and then
487 * uses that signal history to smoothen the output of the speech synthesis
488 * filter.
489 *
490 * @param s WMA Voice decoding context
491 * @param pitch pitch of the speech signal
492 * @param in input speech signal
493 * @param out output pointer for smoothened signal
494 * @param size input/output buffer size
495 *
496 * @returns -1 if no smoothening took place, e.g. because no optimal
497 * fit could be found, or 0 on success.
498 */
499static int kalman_smoothen(WMAVoiceContext *s, int pitch,
500 const float *in, float *out, int size)
501{
502 int n;
503 float optimal_gain = 0, dot;
504 const float *ptr = &in[-FFMAX(s->min_pitch_val, pitch - 3)],
505 *end = &in[-FFMIN(s->max_pitch_val, pitch + 3)],
506 *best_hist_ptr;
507
508 /* find best fitting point in history */
509 do {
510 dot = ff_dot_productf(in, ptr, size);
511 if (dot > optimal_gain) {
512 optimal_gain = dot;
513 best_hist_ptr = ptr;
514 }
515 } while (--ptr >= end);
516
517 if (optimal_gain <= 0)
518 return -1;
519 dot = ff_dot_productf(best_hist_ptr, best_hist_ptr, size);
520 if (dot <= 0) // would be 1.0
521 return -1;
522
523 if (optimal_gain <= dot) {
524 dot = dot / (dot + 0.6 * optimal_gain); // 0.625-1.000
525 } else
526 dot = 0.625;
527
528 /* actual smoothing */
529 for (n = 0; n < size; n++)
530 out[n] = best_hist_ptr[n] + dot * (in[n] - best_hist_ptr[n]);
531
532 return 0;
533}
534
535/**
536 * Get the tilt factor of a formant filter from its transfer function
537 * @see #tilt_factor() in amrnbdec.c, which does essentially the same,
538 * but somehow (??) it does a speech synthesis filter in the
539 * middle, which is missing here
540 *
541 * @param lpcs LPC coefficients
542 * @param n_lpcs Size of LPC buffer
543 * @returns the tilt factor
544 */
545static float tilt_factor(const float *lpcs, int n_lpcs)
546{
547 float rh0, rh1;
548
549 rh0 = 1.0 + ff_dot_productf(lpcs, lpcs, n_lpcs);
550 rh1 = lpcs[0] + ff_dot_productf(lpcs, &lpcs[1], n_lpcs - 1);
551
552 return rh1 / rh0;
553}
554
555/**
556 * Derive denoise filter coefficients (in real domain) from the LPCs.
557 */
558static void calc_input_response(WMAVoiceContext *s, float *lpcs,
559 int fcb_type, float *coeffs, int remainder)
560{
561 float last_coeff, min = 15.0, max = -15.0;
562 float irange, angle_mul, gain_mul, range, sq;
563 int n, idx;
564
565 /* Create frequency power spectrum of speech input (i.e. RDFT of LPCs) */
566 ff_rdft_calc(&s->rdft, lpcs);
567#define log_range(var, assign) do { \
568 float tmp = log10f(assign); var = tmp; \
569 max = FFMAX(max, tmp); min = FFMIN(min, tmp); \
570 } while (0)
571 log_range(last_coeff, lpcs[1] * lpcs[1]);
572 for (n = 1; n < 64; n++)
573 log_range(lpcs[n], lpcs[n * 2] * lpcs[n * 2] +
574 lpcs[n * 2 + 1] * lpcs[n * 2 + 1]);
575 log_range(lpcs[0], lpcs[0] * lpcs[0]);
576#undef log_range
577 range = max - min;
578 lpcs[64] = last_coeff;
579
580 /* Now, use this spectrum to pick out these frequencies with higher
581 * (relative) power/energy (which we then take to be "not noise"),
582 * and set up a table (still in lpc[]) of (relative) gains per frequency.
583 * These frequencies will be maintained, while others ("noise") will be
584 * decreased in the filter output. */
585 irange = 64.0 / range; // so irange*(max-value) is in the range [0, 63]
586 gain_mul = range * (fcb_type == FCB_TYPE_HARDCODED ? (5.0 / 13.0) :
587 (5.0 / 14.7));
588 angle_mul = gain_mul * (8.0 * M_LN10 / M_PI);
589 for (n = 0; n <= 64; n++) {
590 float pwr;
591
592 idx = FFMAX(0, lrint((max - lpcs[n]) * irange) - 1);
593 pwr = wmavoice_denoise_power_table[s->denoise_strength][idx];
594 lpcs[n] = angle_mul * pwr;
595
596 /* 70.57 =~ 1/log10(1.0331663) */
597 idx = (pwr * gain_mul - 0.0295) * 70.570526123;
598 if (idx > 127) { // fallback if index falls outside table range
599 coeffs[n] = wmavoice_energy_table[127] *
600 powf(1.0331663, idx - 127);
601 } else
602 coeffs[n] = wmavoice_energy_table[FFMAX(0, idx)];
603 }
604
605 /* calculate the Hilbert transform of the gains, which we do (since this
606 * is a sinus input) by doing a phase shift (in theory, H(sin())=cos()).
607 * Hilbert_Transform(RDFT(x)) = Laplace_Transform(x), which calculates the
608 * "moment" of the LPCs in this filter. */
609 ff_dct_calc(&s->dct, lpcs);
610 ff_dct_calc(&s->dst, lpcs);
611
612 /* Split out the coefficient indexes into phase/magnitude pairs */
613 idx = 255 + av_clip(lpcs[64], -255, 255);
614 coeffs[0] = coeffs[0] * s->cos[idx];
615 idx = 255 + av_clip(lpcs[64] - 2 * lpcs[63], -255, 255);
616 last_coeff = coeffs[64] * s->cos[idx];
617 for (n = 63;; n--) {
618 idx = 255 + av_clip(-lpcs[64] - 2 * lpcs[n - 1], -255, 255);
619 coeffs[n * 2 + 1] = coeffs[n] * s->sin[idx];
620 coeffs[n * 2] = coeffs[n] * s->cos[idx];
621
622 if (!--n) break;
623
624 idx = 255 + av_clip( lpcs[64] - 2 * lpcs[n - 1], -255, 255);
625 coeffs[n * 2 + 1] = coeffs[n] * s->sin[idx];
626 coeffs[n * 2] = coeffs[n] * s->cos[idx];
627 }
628 coeffs[1] = last_coeff;
629
630 /* move into real domain */
631 ff_rdft_calc(&s->irdft, coeffs);
632
633 /* tilt correction and normalize scale */
634 memset(&coeffs[remainder], 0, sizeof(coeffs[0]) * (128 - remainder));
635 if (s->denoise_tilt_corr) {
636 float tilt_mem = 0;
637
638 coeffs[remainder - 1] = 0;
639 ff_tilt_compensation(&tilt_mem,
640 -1.8 * tilt_factor(coeffs, remainder - 1),
641 coeffs, remainder);
642 }
643 sq = (1.0 / 64.0) * sqrtf(1 / ff_dot_productf(coeffs, coeffs, remainder));
644 for (n = 0; n < remainder; n++)
645 coeffs[n] *= sq;
646}
647
648/**
649 * This function applies a Wiener filter on the (noisy) speech signal as
650 * a means to denoise it.
651 *
652 * - take RDFT of LPCs to get the power spectrum of the noise + speech;
653 * - using this power spectrum, calculate (for each frequency) the Wiener
654 * filter gain, which depends on the frequency power and desired level
655 * of noise subtraction (when set too high, this leads to artifacts)
656 * We can do this symmetrically over the X-axis (so 0-4kHz is the inverse
657 * of 4-8kHz);
658 * - by doing a phase shift, calculate the Hilbert transform of this array
659 * of per-frequency filter-gains to get the filtering coefficients;
660 * - smoothen/normalize/de-tilt these filter coefficients as desired;
661 * - take RDFT of noisy sound, apply the coefficients and take its IRDFT
662 * to get the denoised speech signal;
663 * - the leftover (i.e. output of the IRDFT on denoised speech data beyond
664 * the frame boundary) are saved and applied to subsequent frames by an
665 * overlap-add method (otherwise you get clicking-artifacts).
666 *
667 * @param s WMA Voice decoding context
668 * @param fcb_type Frame (codebook) type
669 * @param synth_pf input: the noisy speech signal, output: denoised speech
670 * data; should be 16-byte aligned (for ASM purposes)
671 * @param size size of the speech data
672 * @param lpcs LPCs used to synthesize this frame's speech data
673 */
674static void wiener_denoise(WMAVoiceContext *s, int fcb_type,
675 float *synth_pf, int size,
676 const float *lpcs)
677{
678 int remainder, lim, n;
679
680 if (fcb_type != FCB_TYPE_SILENCE) {
681 float *tilted_lpcs = s->tilted_lpcs_pf,
682 *coeffs = s->denoise_coeffs_pf, tilt_mem = 0;
683
684 tilted_lpcs[0] = 1.0;
685 memcpy(&tilted_lpcs[1], lpcs, sizeof(lpcs[0]) * s->lsps);
686 memset(&tilted_lpcs[s->lsps + 1], 0,
687 sizeof(tilted_lpcs[0]) * (128 - s->lsps - 1));
688 ff_tilt_compensation(&tilt_mem, 0.7 * tilt_factor(lpcs, s->lsps),
689 tilted_lpcs, s->lsps + 2);
690
691 /* The IRDFT output (127 samples for 7-bit filter) beyond the frame
692 * size is applied to the next frame. All input beyond this is zero,
693 * and thus all output beyond this will go towards zero, hence we can
694 * limit to min(size-1, 127-size) as a performance consideration. */
695 remainder = FFMIN(127 - size, size - 1);
696 calc_input_response(s, tilted_lpcs, fcb_type, coeffs, remainder);
697
698 /* apply coefficients (in frequency spectrum domain), i.e. complex
699 * number multiplication */
700 memset(&synth_pf[size], 0, sizeof(synth_pf[0]) * (128 - size));
701 ff_rdft_calc(&s->rdft, synth_pf);
702 ff_rdft_calc(&s->rdft, coeffs);
703 synth_pf[0] *= coeffs[0];
704 synth_pf[1] *= coeffs[1];
705 for (n = 1; n < 64; n++) {
706 float v1 = synth_pf[n * 2], v2 = synth_pf[n * 2 + 1];
707 synth_pf[n * 2] = v1 * coeffs[n * 2] - v2 * coeffs[n * 2 + 1];
708 synth_pf[n * 2 + 1] = v2 * coeffs[n * 2] + v1 * coeffs[n * 2 + 1];
709 }
710 ff_rdft_calc(&s->irdft, synth_pf);
711 }
712
713 /* merge filter output with the history of previous runs */
714 if (s->denoise_filter_cache_size) {
715 lim = FFMIN(s->denoise_filter_cache_size, size);
716 for (n = 0; n < lim; n++)
717 synth_pf[n] += s->denoise_filter_cache[n];
718 s->denoise_filter_cache_size -= lim;
719 memmove(s->denoise_filter_cache, &s->denoise_filter_cache[size],
720 sizeof(s->denoise_filter_cache[0]) * s->denoise_filter_cache_size);
721 }
722
723 /* move remainder of filter output into a cache for future runs */
724 if (fcb_type != FCB_TYPE_SILENCE) {
725 lim = FFMIN(remainder, s->denoise_filter_cache_size);
726 for (n = 0; n < lim; n++)
727 s->denoise_filter_cache[n] += synth_pf[size + n];
728 if (lim < remainder) {
729 memcpy(&s->denoise_filter_cache[lim], &synth_pf[size + lim],
730 sizeof(s->denoise_filter_cache[0]) * (remainder - lim));
731 s->denoise_filter_cache_size = remainder;
732 }
733 }
734}
735
736/**
737 * Averaging projection filter, the postfilter used in WMAVoice.
738 *
739 * This uses the following steps:
740 * - A zero-synthesis filter (generate excitation from synth signal)
741 * - Kalman smoothing on excitation, based on pitch
742 * - Re-synthesized smoothened output
743 * - Iterative Wiener denoise filter
744 * - Adaptive gain filter
745 * - DC filter
746 *
747 * @param s WMAVoice decoding context
748 * @param synth Speech synthesis output (before postfilter)
749 * @param samples Output buffer for filtered samples
750 * @param size Buffer size of synth & samples
751 * @param lpcs Generated LPCs used for speech synthesis
752 * @param zero_exc_pf destination for zero synthesis filter (16-byte aligned)
753 * @param fcb_type Frame type (silence, hardcoded, AW-pulses or FCB-pulses)
754 * @param pitch Pitch of the input signal
755 */
756static void postfilter(WMAVoiceContext *s, const float *synth,
757 float *samples, int size,
758 const float *lpcs, float *zero_exc_pf,
759 int fcb_type, int pitch)
760{
761 float synth_filter_in_buf[MAX_FRAMESIZE / 2],
762 *synth_pf = &s->synth_filter_out_buf[MAX_LSPS_ALIGN16],
763 *synth_filter_in = zero_exc_pf;
764
765 assert(size <= MAX_FRAMESIZE / 2);
766
767 /* generate excitation from input signal */
768 ff_celp_lp_zero_synthesis_filterf(zero_exc_pf, lpcs, synth, size, s->lsps);
769
770 if (fcb_type >= FCB_TYPE_AW_PULSES &&
771 !kalman_smoothen(s, pitch, zero_exc_pf, synth_filter_in_buf, size))
772 synth_filter_in = synth_filter_in_buf;
773
774 /* re-synthesize speech after smoothening, and keep history */
775 ff_celp_lp_synthesis_filterf(synth_pf, lpcs,
776 synth_filter_in, size, s->lsps);
777 memcpy(&synth_pf[-s->lsps], &synth_pf[size - s->lsps],
778 sizeof(synth_pf[0]) * s->lsps);
779
780 wiener_denoise(s, fcb_type, synth_pf, size, lpcs);
781
782 adaptive_gain_control(samples, synth_pf, synth, size, 0.99,
783 &s->postfilter_agc);
784
785 if (s->dc_level > 8) {
786 /* remove ultra-low frequency DC noise / highpass filter;
787 * coefficients are identical to those used in SIPR decoding,
788 * and very closely resemble those used in AMR-NB decoding. */
789 ff_acelp_apply_order_2_transfer_function(samples, samples,
790 (const float[2]) { -1.99997, 1.0 },
791 (const float[2]) { -1.9330735188, 0.93589198496 },
792 0.93980580475, s->dcf_mem, size);
793 }
794}
795/**
796 * @}
797 */
798
799/**
800 * Dequantize LSPs
801 * @param lsps output pointer to the array that will hold the LSPs
802 * @param num number of LSPs to be dequantized
803 * @param values quantized values, contains n_stages values
804 * @param sizes range (i.e. max value) of each quantized value
805 * @param n_stages number of dequantization runs
806 * @param table dequantization table to be used
807 * @param mul_q LSF multiplier
808 * @param base_q base (lowest) LSF values
809 */
810static void dequant_lsps(double *lsps, int num,
811 const uint16_t *values,
812 const uint16_t *sizes,
813 int n_stages, const uint8_t *table,
814 const double *mul_q,
815 const double *base_q)
816{
817 int n, m;
818
819 memset(lsps, 0, num * sizeof(*lsps));
820 for (n = 0; n < n_stages; n++) {
821 const uint8_t *t_off = &table[values[n] * num];
822 double base = base_q[n], mul = mul_q[n];
823
824 for (m = 0; m < num; m++)
825 lsps[m] += base + mul * t_off[m];
826
827 table += sizes[n] * num;
828 }
829}
830
831/**
832 * @defgroup lsp_dequant LSP dequantization routines
833 * LSP dequantization routines, for 10/16LSPs and independent/residual coding.
834 * @note we assume enough bits are available, caller should check.
835 * lsp10i() consumes 24 bits; lsp10r() consumes an additional 24 bits;
836 * lsp16i() consumes 34 bits; lsp16r() consumes an additional 26 bits.
837 * @{
838 */
839/**
840 * Parse 10 independently-coded LSPs.
841 */
842static void dequant_lsp10i(GetBitContext *gb, double *lsps)
843{
844 static const uint16_t vec_sizes[4] = { 256, 64, 32, 32 };
845 static const double mul_lsf[4] = {
846 5.2187144800e-3, 1.4626986422e-3,
847 9.6179549166e-4, 1.1325736225e-3
848 };
849 static const double base_lsf[4] = {
850 M_PI * -2.15522e-1, M_PI * -6.1646e-2,
851 M_PI * -3.3486e-2, M_PI * -5.7408e-2
852 };
853 uint16_t v[4];
854
855 v[0] = get_bits(gb, 8);
856 v[1] = get_bits(gb, 6);
857 v[2] = get_bits(gb, 5);
858 v[3] = get_bits(gb, 5);
859
860 dequant_lsps(lsps, 10, v, vec_sizes, 4, wmavoice_dq_lsp10i,
861 mul_lsf, base_lsf);
862}
863
864/**
865 * Parse 10 independently-coded LSPs, and then derive the tables to
866 * generate LSPs for the other frames from them (residual coding).
867 */
868static void dequant_lsp10r(GetBitContext *gb,
869 double *i_lsps, const double *old,
870 double *a1, double *a2, int q_mode)
871{
872 static const uint16_t vec_sizes[3] = { 128, 64, 64 };
873 static const double mul_lsf[3] = {
874 2.5807601174e-3, 1.2354460219e-3, 1.1763821673e-3
875 };
876 static const double base_lsf[3] = {
877 M_PI * -1.07448e-1, M_PI * -5.2706e-2, M_PI * -5.1634e-2
878 };
879 const float (*ipol_tab)[2][10] = q_mode ?
880 wmavoice_lsp10_intercoeff_b : wmavoice_lsp10_intercoeff_a;
881 uint16_t interpol, v[3];
882 int n;
883
884 dequant_lsp10i(gb, i_lsps);
885
886 interpol = get_bits(gb, 5);
887 v[0] = get_bits(gb, 7);
888 v[1] = get_bits(gb, 6);
889 v[2] = get_bits(gb, 6);
890
891 for (n = 0; n < 10; n++) {
892 double delta = old[n] - i_lsps[n];
893 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
894 a1[10 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
895 }
896
897 dequant_lsps(a2, 20, v, vec_sizes, 3, wmavoice_dq_lsp10r,
898 mul_lsf, base_lsf);
899}
900
901/**
902 * Parse 16 independently-coded LSPs.
903 */
904static void dequant_lsp16i(GetBitContext *gb, double *lsps)
905{
906 static const uint16_t vec_sizes[5] = { 256, 64, 128, 64, 128 };
907 static const double mul_lsf[5] = {
908 3.3439586280e-3, 6.9908173703e-4,
909 3.3216608306e-3, 1.0334960326e-3,
910 3.1899104283e-3
911 };
912 static const double base_lsf[5] = {
913 M_PI * -1.27576e-1, M_PI * -2.4292e-2,
914 M_PI * -1.28094e-1, M_PI * -3.2128e-2,
915 M_PI * -1.29816e-1
916 };
917 uint16_t v[5];
918
919 v[0] = get_bits(gb, 8);
920 v[1] = get_bits(gb, 6);
921 v[2] = get_bits(gb, 7);
922 v[3] = get_bits(gb, 6);
923 v[4] = get_bits(gb, 7);
924
925 dequant_lsps( lsps, 5, v, vec_sizes, 2,
926 wmavoice_dq_lsp16i1, mul_lsf, base_lsf);
927 dequant_lsps(&lsps[5], 5, &v[2], &vec_sizes[2], 2,
928 wmavoice_dq_lsp16i2, &mul_lsf[2], &base_lsf[2]);
929 dequant_lsps(&lsps[10], 6, &v[4], &vec_sizes[4], 1,
930 wmavoice_dq_lsp16i3, &mul_lsf[4], &base_lsf[4]);
931}
932
933/**
934 * Parse 16 independently-coded LSPs, and then derive the tables to
935 * generate LSPs for the other frames from them (residual coding).
936 */
937static void dequant_lsp16r(GetBitContext *gb,
938 double *i_lsps, const double *old,
939 double *a1, double *a2, int q_mode)
940{
941 static const uint16_t vec_sizes[3] = { 128, 128, 128 };
942 static const double mul_lsf[3] = {
943 1.2232979501e-3, 1.4062241527e-3, 1.6114744851e-3
944 };
945 static const double base_lsf[3] = {
946 M_PI * -5.5830e-2, M_PI * -5.2908e-2, M_PI * -5.4776e-2
947 };
948 const float (*ipol_tab)[2][16] = q_mode ?
949 wmavoice_lsp16_intercoeff_b : wmavoice_lsp16_intercoeff_a;
950 uint16_t interpol, v[3];
951 int n;
952
953 dequant_lsp16i(gb, i_lsps);
954
955 interpol = get_bits(gb, 5);
956 v[0] = get_bits(gb, 7);
957 v[1] = get_bits(gb, 7);
958 v[2] = get_bits(gb, 7);
959
960 for (n = 0; n < 16; n++) {
961 double delta = old[n] - i_lsps[n];
962 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
963 a1[16 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
964 }
965
966 dequant_lsps( a2, 10, v, vec_sizes, 1,
967 wmavoice_dq_lsp16r1, mul_lsf, base_lsf);
968 dequant_lsps(&a2[10], 10, &v[1], &vec_sizes[1], 1,
969 wmavoice_dq_lsp16r2, &mul_lsf[1], &base_lsf[1]);
970 dequant_lsps(&a2[20], 12, &v[2], &vec_sizes[2], 1,
971 wmavoice_dq_lsp16r3, &mul_lsf[2], &base_lsf[2]);
972}
973
974/**
975 * @}
976 * @defgroup aw Pitch-adaptive window coding functions
977 * The next few functions are for pitch-adaptive window coding.
978 * @{
979 */
980/**
981 * Parse the offset of the first pitch-adaptive window pulses, and
982 * the distribution of pulses between the two blocks in this frame.
983 * @param s WMA Voice decoding context private data
984 * @param gb bit I/O context
985 * @param pitch pitch for each block in this frame
986 */
987static void aw_parse_coords(WMAVoiceContext *s, GetBitContext *gb,
988 const int *pitch)
989{
990 static const int16_t start_offset[94] = {
991 -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11,
992 13, 15, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26,
993 27, 28, 29, 30, 31, 32, 33, 35, 37, 39, 41, 43,
994 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
995 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
996 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115,
997 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139,
998 141, 143, 145, 147, 149, 151, 153, 155, 157, 159
999 };
1000 int bits, offset;
1001
1002 /* position of pulse */
1003 s->aw_idx_is_ext = 0;
1004 if ((bits = get_bits(gb, 6)) >= 54) {
1005 s->aw_idx_is_ext = 1;
1006 bits += (bits - 54) * 3 + get_bits(gb, 2);
1007 }
1008
1009 /* for a repeated pulse at pulse_off with a pitch_lag of pitch[], count
1010 * the distribution of the pulses in each block contained in this frame. */
1011 s->aw_pulse_range = FFMIN(pitch[0], pitch[1]) > 32 ? 24 : 16;
1012 for (offset = start_offset[bits]; offset < 0; offset += pitch[0]) ;
1013 s->aw_n_pulses[0] = (pitch[0] - 1 + MAX_FRAMESIZE / 2 - offset) / pitch[0];
1014 s->aw_first_pulse_off[0] = offset - s->aw_pulse_range / 2;
1015 offset += s->aw_n_pulses[0] * pitch[0];
1016 s->aw_n_pulses[1] = (pitch[1] - 1 + MAX_FRAMESIZE - offset) / pitch[1];
1017 s->aw_first_pulse_off[1] = offset - (MAX_FRAMESIZE + s->aw_pulse_range) / 2;
1018
1019 /* if continuing from a position before the block, reset position to
1020 * start of block (when corrected for the range over which it can be
1021 * spread in aw_pulse_set1()). */
1022 if (start_offset[bits] < MAX_FRAMESIZE / 2) {
1023 while (s->aw_first_pulse_off[1] - pitch[1] + s->aw_pulse_range > 0)
1024 s->aw_first_pulse_off[1] -= pitch[1];
1025 if (start_offset[bits] < 0)
1026 while (s->aw_first_pulse_off[0] - pitch[0] + s->aw_pulse_range > 0)
1027 s->aw_first_pulse_off[0] -= pitch[0];
1028 }
1029}
1030
1031/**
1032 * Apply second set of pitch-adaptive window pulses.
1033 * @param s WMA Voice decoding context private data
1034 * @param gb bit I/O context
1035 * @param block_idx block index in frame [0, 1]
1036 * @param fcb structure containing fixed codebook vector info
1037 */
1038static void aw_pulse_set2(WMAVoiceContext *s, GetBitContext *gb,
1039 int block_idx, AMRFixed *fcb)
1040{
1041 uint16_t use_mask[7]; // only 5 are used, rest is padding
1042 /* in this function, idx is the index in the 80-bit (+ padding) use_mask
1043 * bit-array. Since use_mask consists of 16-bit values, the lower 4 bits
1044 * of idx are the position of the bit within a particular item in the
1045 * array (0 being the most significant bit, and 15 being the least
1046 * significant bit), and the remainder (>> 4) is the index in the
1047 * use_mask[]-array. This is faster and uses less memory than using a
1048 * 80-byte/80-int array. */
1049 int pulse_off = s->aw_first_pulse_off[block_idx],
1050 pulse_start, n, idx, range, aidx, start_off = 0;
1051
1052 /* set offset of first pulse to within this block */
1053 if (s->aw_n_pulses[block_idx] > 0)
1054 while (pulse_off + s->aw_pulse_range < 1)
1055 pulse_off += fcb->pitch_lag;
1056
1057 /* find range per pulse */
1058 if (s->aw_n_pulses[0] > 0) {
1059 if (block_idx == 0) {
1060 range = 32;
1061 } else /* block_idx = 1 */ {
1062 range = 8;
1063 if (s->aw_n_pulses[block_idx] > 0)
1064 pulse_off = s->aw_next_pulse_off_cache;
1065 }
1066 } else
1067 range = 16;
1068 pulse_start = s->aw_n_pulses[block_idx] > 0 ? pulse_off - range / 2 : 0;
1069
1070 /* aw_pulse_set1() already applies pulses around pulse_off (to be exactly,
1071 * in the range of [pulse_off, pulse_off + s->aw_pulse_range], and thus
1072 * we exclude that range from being pulsed again in this function. */
1073 memset( use_mask, -1, 5 * sizeof(use_mask[0]));
1074 memset(&use_mask[5], 0, 2 * sizeof(use_mask[0]));
1075 if (s->aw_n_pulses[block_idx] > 0)
1076 for (idx = pulse_off; idx < MAX_FRAMESIZE / 2; idx += fcb->pitch_lag) {
1077 int excl_range = s->aw_pulse_range; // always 16 or 24
1078 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
1079 int first_sh = 16 - (idx & 15);
1080 *use_mask_ptr++ &= 0xFFFF << first_sh;
1081 excl_range -= first_sh;
1082 if (excl_range >= 16) {
1083 *use_mask_ptr++ = 0;
1084 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
1085 } else
1086 *use_mask_ptr &= 0xFFFF >> excl_range;
1087 }
1088
1089 /* find the 'aidx'th offset that is not excluded */
1090 aidx = get_bits(gb, s->aw_n_pulses[0] > 0 ? 5 - 2 * block_idx : 4);
1091 for (n = 0; n <= aidx; pulse_start++) {
1092 for (idx = pulse_start; idx < 0; idx += fcb->pitch_lag) ;
1093 if (idx >= MAX_FRAMESIZE / 2) { // find from zero
1094 if (use_mask[0]) idx = 0x0F;
1095 else if (use_mask[1]) idx = 0x1F;
1096 else if (use_mask[2]) idx = 0x2F;
1097 else if (use_mask[3]) idx = 0x3F;
1098 else if (use_mask[4]) idx = 0x4F;
1099 else return;
1100 idx -= av_log2_16bit(use_mask[idx >> 4]);
1101 }
1102 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
1103 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
1104 n++;
1105 start_off = idx;
1106 }
1107 }
1108
1109 fcb->x[fcb->n] = start_off;
1110 fcb->y[fcb->n] = get_bits1(gb) ? -1.0 : 1.0;
1111 fcb->n++;
1112
1113 /* set offset for next block, relative to start of that block */
1114 n = (MAX_FRAMESIZE / 2 - start_off) % fcb->pitch_lag;
1115 s->aw_next_pulse_off_cache = n ? fcb->pitch_lag - n : 0;
1116}
1117
1118/**
1119 * Apply first set of pitch-adaptive window pulses.
1120 * @param s WMA Voice decoding context private data
1121 * @param gb bit I/O context
1122 * @param block_idx block index in frame [0, 1]
1123 * @param fcb storage location for fixed codebook pulse info
1124 */
1125static void aw_pulse_set1(WMAVoiceContext *s, GetBitContext *gb,
1126 int block_idx, AMRFixed *fcb)
1127{
1128 int val = get_bits(gb, 12 - 2 * (s->aw_idx_is_ext && !block_idx));
1129 float v;
1130
1131 if (s->aw_n_pulses[block_idx] > 0) {
1132 int n, v_mask, i_mask, sh, n_pulses;
1133
1134 if (s->aw_pulse_range == 24) { // 3 pulses, 1:sign + 3:index each
1135 n_pulses = 3;
1136 v_mask = 8;
1137 i_mask = 7;
1138 sh = 4;
1139 } else { // 4 pulses, 1:sign + 2:index each
1140 n_pulses = 4;
1141 v_mask = 4;
1142 i_mask = 3;
1143 sh = 3;
1144 }
1145
1146 for (n = n_pulses - 1; n >= 0; n--, val >>= sh) {
1147 fcb->y[fcb->n] = (val & v_mask) ? -1.0 : 1.0;
1148 fcb->x[fcb->n] = (val & i_mask) * n_pulses + n +
1149 s->aw_first_pulse_off[block_idx];
1150 while (fcb->x[fcb->n] < 0)
1151 fcb->x[fcb->n] += fcb->pitch_lag;
1152 if (fcb->x[fcb->n] < MAX_FRAMESIZE / 2)
1153 fcb->n++;
1154 }
1155 } else {
1156 int num2 = (val & 0x1FF) >> 1, delta, idx;
1157
1158 if (num2 < 1 * 79) { delta = 1; idx = num2 + 1; }
1159 else if (num2 < 2 * 78) { delta = 3; idx = num2 + 1 - 1 * 77; }
1160 else if (num2 < 3 * 77) { delta = 5; idx = num2 + 1 - 2 * 76; }
1161 else { delta = 7; idx = num2 + 1 - 3 * 75; }
1162 v = (val & 0x200) ? -1.0 : 1.0;
1163
1164 fcb->no_repeat_mask |= 3 << fcb->n;
1165 fcb->x[fcb->n] = idx - delta;
1166 fcb->y[fcb->n] = v;
1167 fcb->x[fcb->n + 1] = idx;
1168 fcb->y[fcb->n + 1] = (val & 1) ? -v : v;
1169 fcb->n += 2;
1170 }
1171}
1172
1173/**
1174 * @}
1175 *
1176 * Generate a random number from frame_cntr and block_idx, which will lief
1177 * in the range [0, 1000 - block_size] (so it can be used as an index in a
1178 * table of size 1000 of which you want to read block_size entries).
1179 *
1180 * @param frame_cntr current frame number
1181 * @param block_num current block index
1182 * @param block_size amount of entries we want to read from a table
1183 * that has 1000 entries
1184 * @return a (non-)random number in the [0, 1000 - block_size] range.
1185 */
1186static int pRNG(int frame_cntr, int block_num, int block_size)
1187{
1188 /* array to simplify the calculation of z:
1189 * y = (x % 9) * 5 + 6;
1190 * z = (49995 * x) / y;
1191 * Since y only has 9 values, we can remove the division by using a
1192 * LUT and using FASTDIV-style divisions. For each of the 9 values
1193 * of y, we can rewrite z as:
1194 * z = x * (49995 / y) + x * ((49995 % y) / y)
1195 * In this table, each col represents one possible value of y, the
1196 * first number is 49995 / y, and the second is the FASTDIV variant
1197 * of 49995 % y / y. */
1198 static const unsigned int div_tbl[9][2] = {
1199 { 8332, 3 * 715827883U }, // y = 6
1200 { 4545, 0 * 390451573U }, // y = 11
1201 { 3124, 11 * 268435456U }, // y = 16
1202 { 2380, 15 * 204522253U }, // y = 21
1203 { 1922, 23 * 165191050U }, // y = 26
1204 { 1612, 23 * 138547333U }, // y = 31
1205 { 1388, 27 * 119304648U }, // y = 36
1206 { 1219, 16 * 104755300U }, // y = 41
1207 { 1086, 39 * 93368855U } // y = 46
1208 };
1209 unsigned int z, y, x = MUL16(block_num, 1877) + frame_cntr;
1210 if (x >= 0xFFFF) x -= 0xFFFF; // max value of x is 8*1877+0xFFFE=0x13AA6,
1211 // so this is effectively a modulo (%)
1212 y = x - 9 * MULH(477218589, x); // x % 9
1213 z = (uint16_t) (x * div_tbl[y][0] + UMULH(x, div_tbl[y][1]));
1214 // z = x * 49995 / (y * 5 + 6)
1215 return z % (1000 - block_size);
1216}
1217
1218/**
1219 * Parse hardcoded signal for a single block.
1220 * @note see #synth_block().
1221 */
1222static void synth_block_hardcoded(WMAVoiceContext *s, GetBitContext *gb,
1223 int block_idx, int size,
1224 const struct frame_type_desc *frame_desc,
1225 float *excitation)
1226{
1227 float gain;
1228 int n, r_idx;
1229
1230 assert(size <= MAX_FRAMESIZE);
1231
1232 /* Set the offset from which we start reading wmavoice_std_codebook */
1233 if (frame_desc->fcb_type == FCB_TYPE_SILENCE) {
1234 r_idx = pRNG(s->frame_cntr, block_idx, size);
1235 gain = s->silence_gain;
1236 } else /* FCB_TYPE_HARDCODED */ {
1237 r_idx = get_bits(gb, 8);
1238 gain = wmavoice_gain_universal[get_bits(gb, 6)];
1239 }
1240
1241 /* Clear gain prediction parameters */
1242 memset(s->gain_pred_err, 0, sizeof(s->gain_pred_err));
1243
1244 /* Apply gain to hardcoded codebook and use that as excitation signal */
1245 for (n = 0; n < size; n++)
1246 excitation[n] = wmavoice_std_codebook[r_idx + n] * gain;
1247}
1248
1249/**
1250 * Parse FCB/ACB signal for a single block.
1251 * @note see #synth_block().
1252 */
1253static void synth_block_fcb_acb(WMAVoiceContext *s, GetBitContext *gb,
1254 int block_idx, int size,
1255 int block_pitch_sh2,
1256 const struct frame_type_desc *frame_desc,
1257 float *excitation)
1258{
1259 static const float gain_coeff[6] = {
1260 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
1261 };
1262 float pulses[MAX_FRAMESIZE / 2], pred_err, acb_gain, fcb_gain;
1263 int n, idx, gain_weight;
1264 AMRFixed fcb;
1265
1266 assert(size <= MAX_FRAMESIZE / 2);
1267 memset(pulses, 0, sizeof(*pulses) * size);
1268
1269 fcb.pitch_lag = block_pitch_sh2 >> 2;
1270 fcb.pitch_fac = 1.0;
1271 fcb.no_repeat_mask = 0;
1272 fcb.n = 0;
1273
1274 /* For the other frame types, this is where we apply the innovation
1275 * (fixed) codebook pulses of the speech signal. */
1276 if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
1277 aw_pulse_set1(s, gb, block_idx, &fcb);
1278 aw_pulse_set2(s, gb, block_idx, &fcb);
1279 } else /* FCB_TYPE_EXC_PULSES */ {
1280 int offset_nbits = 5 - frame_desc->log_n_blocks;
1281
1282 fcb.no_repeat_mask = -1;
1283 /* similar to ff_decode_10_pulses_35bits(), but with single pulses
1284 * (instead of double) for a subset of pulses */
1285 for (n = 0; n < 5; n++) {
1286 float sign;
1287 int pos1, pos2;
1288
1289 sign = get_bits1(gb) ? 1.0 : -1.0;
1290 pos1 = get_bits(gb, offset_nbits);
1291 fcb.x[fcb.n] = n + 5 * pos1;
1292 fcb.y[fcb.n++] = sign;
1293 if (n < frame_desc->dbl_pulses) {
1294 pos2 = get_bits(gb, offset_nbits);
1295 fcb.x[fcb.n] = n + 5 * pos2;
1296 fcb.y[fcb.n++] = (pos1 < pos2) ? -sign : sign;
1297 }
1298 }
1299 }
1300 ff_set_fixed_vector(pulses, &fcb, 1.0, size);
1301
1302 /* Calculate gain for adaptive & fixed codebook signal.
1303 * see ff_amr_set_fixed_gain(). */
1304 idx = get_bits(gb, 7);
1305 fcb_gain = expf(ff_dot_productf(s->gain_pred_err, gain_coeff, 6) -
1306 5.2409161640 + wmavoice_gain_codebook_fcb[idx]);
1307 acb_gain = wmavoice_gain_codebook_acb[idx];
1308 pred_err = av_clipf(wmavoice_gain_codebook_fcb[idx],
1309 -2.9957322736 /* log(0.05) */,
1310 1.6094379124 /* log(5.0) */);
1311
1312 gain_weight = 8 >> frame_desc->log_n_blocks;
1313 memmove(&s->gain_pred_err[gain_weight], s->gain_pred_err,
1314 sizeof(*s->gain_pred_err) * (6 - gain_weight));
1315 for (n = 0; n < gain_weight; n++)
1316 s->gain_pred_err[n] = pred_err;
1317
1318 /* Calculation of adaptive codebook */
1319 if (frame_desc->acb_type == ACB_TYPE_ASYMMETRIC) {
1320 int len;
1321 for (n = 0; n < size; n += len) {
1322 int next_idx_sh16;
1323 int abs_idx = block_idx * size + n;
1324 int pitch_sh16 = (s->last_pitch_val << 16) +
1325 s->pitch_diff_sh16 * abs_idx;
1326 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
1327 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
1328 idx = idx_sh16 >> 16;
1329 if (s->pitch_diff_sh16) {
1330 if (s->pitch_diff_sh16 > 0) {
1331 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
1332 } else
1333 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
1334 len = av_clip((idx_sh16 - next_idx_sh16) / s->pitch_diff_sh16 / 8,
1335 1, size - n);
1336 } else
1337 len = size;
1338
1339 ff_acelp_interpolatef(&excitation[n], &excitation[n - pitch],
1340 wmavoice_ipol1_coeffs, 17,
1341 idx, 9, len);
1342 }
1343 } else /* ACB_TYPE_HAMMING */ {
1344 int block_pitch = block_pitch_sh2 >> 2;
1345 idx = block_pitch_sh2 & 3;
1346 if (idx) {
1347 ff_acelp_interpolatef(excitation, &excitation[-block_pitch],
1348 wmavoice_ipol2_coeffs, 4,
1349 idx, 8, size);
1350 } else
1351 av_memcpy_backptr((uint8_t *) excitation, sizeof(float) * block_pitch,
1352 sizeof(float) * size);
1353 }
1354
1355 /* Interpolate ACB/FCB and use as excitation signal */
1356 ff_weighted_vector_sumf(excitation, excitation, pulses,
1357 acb_gain, fcb_gain, size);
1358}
1359
1360/**
1361 * Parse data in a single block.
1362 * @note we assume enough bits are available, caller should check.
1363 *
1364 * @param s WMA Voice decoding context private data
1365 * @param gb bit I/O context
1366 * @param block_idx index of the to-be-read block
1367 * @param size amount of samples to be read in this block
1368 * @param block_pitch_sh2 pitch for this block << 2
1369 * @param lsps LSPs for (the end of) this frame
1370 * @param prev_lsps LSPs for the last frame
1371 * @param frame_desc frame type descriptor
1372 * @param excitation target memory for the ACB+FCB interpolated signal
1373 * @param synth target memory for the speech synthesis filter output
1374 * @return 0 on success, <0 on error.
1375 */
1376static void synth_block(WMAVoiceContext *s, GetBitContext *gb,
1377 int block_idx, int size,
1378 int block_pitch_sh2,
1379 const double *lsps, const double *prev_lsps,
1380 const struct frame_type_desc *frame_desc,
1381 float *excitation, float *synth)
1382{
1383 double i_lsps[MAX_LSPS];
1384 float lpcs[MAX_LSPS];
1385 float fac;
1386 int n;
1387
1388 if (frame_desc->acb_type == ACB_TYPE_NONE)
1389 synth_block_hardcoded(s, gb, block_idx, size, frame_desc, excitation);
1390 else
1391 synth_block_fcb_acb(s, gb, block_idx, size, block_pitch_sh2,
1392 frame_desc, excitation);
1393
1394 /* convert interpolated LSPs to LPCs */
1395 fac = (block_idx + 0.5) / frame_desc->n_blocks;
1396 for (n = 0; n < s->lsps; n++) // LSF -> LSP
1397 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
1398 ff_acelp_lspd2lpc(i_lsps, lpcs, s->lsps >> 1);
1399
1400 /* Speech synthesis */
1401 ff_celp_lp_synthesis_filterf(synth, lpcs, excitation, size, s->lsps);
1402}
1403
1404/**
1405 * Synthesize output samples for a single frame.
1406 * @note we assume enough bits are available, caller should check.
1407 *
1408 * @param ctx WMA Voice decoder context
1409 * @param gb bit I/O context (s->gb or one for cross-packet superframes)
1410 * @param frame_idx Frame number within superframe [0-2]
1411 * @param samples pointer to output sample buffer, has space for at least 160
1412 * samples
1413 * @param lsps LSP array
1414 * @param prev_lsps array of previous frame's LSPs
1415 * @param excitation target buffer for excitation signal
1416 * @param synth target buffer for synthesized speech data
1417 * @return 0 on success, <0 on error.
1418 */
1419static int synth_frame(AVCodecContext *ctx, GetBitContext *gb, int frame_idx,
1420 float *samples,
1421 const double *lsps, const double *prev_lsps,
1422 float *excitation, float *synth)
1423{
1424 WMAVoiceContext *s = ctx->priv_data;
1425 int n, n_blocks_x2, log_n_blocks_x2, cur_pitch_val;
1426 int pitch[MAX_BLOCKS], last_block_pitch;
1427
1428 /* Parse frame type ("frame header"), see frame_descs */
1429 int bd_idx = s->vbm_tree[get_vlc2(gb, frame_type_vlc.table, 6, 3)],
1430 block_nsamples = MAX_FRAMESIZE / frame_descs[bd_idx].n_blocks;
1431
1432 if (bd_idx < 0) {
1433 av_log(ctx, AV_LOG_ERROR,
1434 "Invalid frame type VLC code, skipping\n");
1435 return -1;
1436 }
1437
1438 /* Pitch calculation for ACB_TYPE_ASYMMETRIC ("pitch-per-frame") */
1439 if (frame_descs[bd_idx].acb_type == ACB_TYPE_ASYMMETRIC) {
1440 /* Pitch is provided per frame, which is interpreted as the pitch of
1441 * the last sample of the last block of this frame. We can interpolate
1442 * the pitch of other blocks (and even pitch-per-sample) by gradually
1443 * incrementing/decrementing prev_frame_pitch to cur_pitch_val. */
1444 n_blocks_x2 = frame_descs[bd_idx].n_blocks << 1;
1445 log_n_blocks_x2 = frame_descs[bd_idx].log_n_blocks + 1;
1446 cur_pitch_val = s->min_pitch_val + get_bits(gb, s->pitch_nbits);
1447 cur_pitch_val = FFMIN(cur_pitch_val, s->max_pitch_val - 1);
1448 if (s->last_acb_type == ACB_TYPE_NONE ||
1449 20 * abs(cur_pitch_val - s->last_pitch_val) >
1450 (cur_pitch_val + s->last_pitch_val))
1451 s->last_pitch_val = cur_pitch_val;
1452
1453 /* pitch per block */
1454 for (n = 0; n < frame_descs[bd_idx].n_blocks; n++) {
1455 int fac = n * 2 + 1;
1456
1457 pitch[n] = (MUL16(fac, cur_pitch_val) +
1458 MUL16((n_blocks_x2 - fac), s->last_pitch_val) +
1459 frame_descs[bd_idx].n_blocks) >> log_n_blocks_x2;
1460 }
1461
1462 /* "pitch-diff-per-sample" for calculation of pitch per sample */
1463 s->pitch_diff_sh16 =
1464 ((cur_pitch_val - s->last_pitch_val) << 16) / MAX_FRAMESIZE;
1465 }
1466
1467 /* Global gain (if silence) and pitch-adaptive window coordinates */
1468 switch (frame_descs[bd_idx].fcb_type) {
1469 case FCB_TYPE_SILENCE:
1470 s->silence_gain = wmavoice_gain_silence[get_bits(gb, 8)];
1471 break;
1472 case FCB_TYPE_AW_PULSES:
1473 aw_parse_coords(s, gb, pitch);
1474 break;
1475 }
1476
1477 for (n = 0; n < frame_descs[bd_idx].n_blocks; n++) {
1478 int bl_pitch_sh2;
1479
1480 /* Pitch calculation for ACB_TYPE_HAMMING ("pitch-per-block") */
1481 switch (frame_descs[bd_idx].acb_type) {
1482 case ACB_TYPE_HAMMING: {
1483 /* Pitch is given per block. Per-block pitches are encoded as an
1484 * absolute value for the first block, and then delta values
1485 * relative to this value) for all subsequent blocks. The scale of
1486 * this pitch value is semi-logaritmic compared to its use in the
1487 * decoder, so we convert it to normal scale also. */
1488 int block_pitch,
1489 t1 = (s->block_conv_table[1] - s->block_conv_table[0]) << 2,
1490 t2 = (s->block_conv_table[2] - s->block_conv_table[1]) << 1,
1491 t3 = s->block_conv_table[3] - s->block_conv_table[2] + 1;
1492
1493 if (n == 0) {
1494 block_pitch = get_bits(gb, s->block_pitch_nbits);
1495 } else
1496 block_pitch = last_block_pitch - s->block_delta_pitch_hrange +
1497 get_bits(gb, s->block_delta_pitch_nbits);
1498 /* Convert last_ so that any next delta is within _range */
1499 last_block_pitch = av_clip(block_pitch,
1500 s->block_delta_pitch_hrange,
1501 s->block_pitch_range -
1502 s->block_delta_pitch_hrange);
1503
1504 /* Convert semi-log-style scale back to normal scale */
1505 if (block_pitch < t1) {
1506 bl_pitch_sh2 = (s->block_conv_table[0] << 2) + block_pitch;
1507 } else {
1508 block_pitch -= t1;
1509 if (block_pitch < t2) {
1510 bl_pitch_sh2 =
1511 (s->block_conv_table[1] << 2) + (block_pitch << 1);
1512 } else {
1513 block_pitch -= t2;
1514 if (block_pitch < t3) {
1515 bl_pitch_sh2 =
1516 (s->block_conv_table[2] + block_pitch) << 2;
1517 } else
1518 bl_pitch_sh2 = s->block_conv_table[3] << 2;
1519 }
1520 }
1521 pitch[n] = bl_pitch_sh2 >> 2;
1522 break;
1523 }
1524
1525 case ACB_TYPE_ASYMMETRIC: {
1526 bl_pitch_sh2 = pitch[n] << 2;
1527 break;
1528 }
1529
1530 default: // ACB_TYPE_NONE has no pitch
1531 bl_pitch_sh2 = 0;
1532 break;
1533 }
1534
1535 synth_block(s, gb, n, block_nsamples, bl_pitch_sh2,
1536 lsps, prev_lsps, &frame_descs[bd_idx],
1537 &excitation[n * block_nsamples],
1538 &synth[n * block_nsamples]);
1539 }
1540
1541 /* Averaging projection filter, if applicable. Else, just copy samples
1542 * from synthesis buffer */
1543 if (s->do_apf) {
1544 double i_lsps[MAX_LSPS];
1545 float lpcs[MAX_LSPS];
1546
1547 for (n = 0; n < s->lsps; n++) // LSF -> LSP
1548 i_lsps[n] = cos(0.5 * (prev_lsps[n] + lsps[n]));
1549 ff_acelp_lspd2lpc(i_lsps, lpcs, s->lsps >> 1);
1550 postfilter(s, synth, samples, 80, lpcs,
1551 &s->zero_exc_pf[s->history_nsamples + MAX_FRAMESIZE * frame_idx],
1552 frame_descs[bd_idx].fcb_type, pitch[0]);
1553
1554 for (n = 0; n < s->lsps; n++) // LSF -> LSP
1555 i_lsps[n] = cos(lsps[n]);
1556 ff_acelp_lspd2lpc(i_lsps, lpcs, s->lsps >> 1);
1557 postfilter(s, &synth[80], &samples[80], 80, lpcs,
1558 &s->zero_exc_pf[s->history_nsamples + MAX_FRAMESIZE * frame_idx + 80],
1559 frame_descs[bd_idx].fcb_type, pitch[0]);
1560 } else
1561 memcpy(samples, synth, 160 * sizeof(synth[0]));
1562
1563 /* Cache values for next frame */
1564 s->frame_cntr++;
1565 if (s->frame_cntr >= 0xFFFF) s->frame_cntr -= 0xFFFF; // i.e. modulo (%)
1566 s->last_acb_type = frame_descs[bd_idx].acb_type;
1567 switch (frame_descs[bd_idx].acb_type) {
1568 case ACB_TYPE_NONE:
1569 s->last_pitch_val = 0;
1570 break;
1571 case ACB_TYPE_ASYMMETRIC:
1572 s->last_pitch_val = cur_pitch_val;
1573 break;
1574 case ACB_TYPE_HAMMING:
1575 s->last_pitch_val = pitch[frame_descs[bd_idx].n_blocks - 1];
1576 break;
1577 }
1578
1579 return 0;
1580}
1581
1582/**
1583 * Ensure minimum value for first item, maximum value for last value,
1584 * proper spacing between each value and proper ordering.
1585 *
1586 * @param lsps array of LSPs
1587 * @param num size of LSP array
1588 *
1589 * @note basically a double version of #ff_acelp_reorder_lsf(), might be
1590 * useful to put in a generic location later on. Parts are also
1591 * present in #ff_set_min_dist_lsf() + #ff_sort_nearly_sorted_floats(),
1592 * which is in float.
1593 */
1594static void stabilize_lsps(double *lsps, int num)
1595{
1596 int n, m, l;
1597
1598 /* set minimum value for first, maximum value for last and minimum
1599 * spacing between LSF values.
1600 * Very similar to ff_set_min_dist_lsf(), but in double. */
1601 lsps[0] = FFMAX(lsps[0], 0.0015 * M_PI);
1602 for (n = 1; n < num; n++)
1603 lsps[n] = FFMAX(lsps[n], lsps[n - 1] + 0.0125 * M_PI);
1604 lsps[num - 1] = FFMIN(lsps[num - 1], 0.9985 * M_PI);
1605
1606 /* reorder (looks like one-time / non-recursed bubblesort).
1607 * Very similar to ff_sort_nearly_sorted_floats(), but in double. */
1608 for (n = 1; n < num; n++) {
1609 if (lsps[n] < lsps[n - 1]) {
1610 for (m = 1; m < num; m++) {
1611 double tmp = lsps[m];
1612 for (l = m - 1; l >= 0; l--) {
1613 if (lsps[l] <= tmp) break;
1614 lsps[l + 1] = lsps[l];
1615 }
1616 lsps[l + 1] = tmp;
1617 }
1618 break;
1619 }
1620 }
1621}
1622
1623/**
1624 * Test if there's enough bits to read 1 superframe.
1625 *
1626 * @param orig_gb bit I/O context used for reading. This function
1627 * does not modify the state of the bitreader; it
1628 * only uses it to copy the current stream position
1629 * @param s WMA Voice decoding context private data
1630 * @return -1 if unsupported, 1 on not enough bits or 0 if OK.
1631 */
1632static int check_bits_for_superframe(GetBitContext *orig_gb,
1633 WMAVoiceContext *s)
1634{
1635 GetBitContext s_gb, *gb = &s_gb;
1636 int n, need_bits, bd_idx;
1637 const struct frame_type_desc *frame_desc;
1638
1639 /* initialize a copy */
1640 init_get_bits(gb, orig_gb->buffer, orig_gb->size_in_bits);
1641 skip_bits_long(gb, get_bits_count(orig_gb));
1642 assert(get_bits_left(gb) == get_bits_left(orig_gb));
1643
1644 /* superframe header */
1645 if (get_bits_left(gb) < 14)
1646 return 1;
1647 if (!get_bits1(gb))
1648 return -1; // WMAPro-in-WMAVoice superframe
1649 if (get_bits1(gb)) skip_bits(gb, 12); // number of samples in superframe
1650 if (s->has_residual_lsps) { // residual LSPs (for all frames)
1651 if (get_bits_left(gb) < s->sframe_lsp_bitsize)
1652 return 1;
1653 skip_bits_long(gb, s->sframe_lsp_bitsize);
1654 }
1655
1656 /* frames */
1657 for (n = 0; n < MAX_FRAMES; n++) {
1658 int aw_idx_is_ext = 0;
1659
1660 if (!s->has_residual_lsps) { // independent LSPs (per-frame)
1661 if (get_bits_left(gb) < s->frame_lsp_bitsize) return 1;
1662 skip_bits_long(gb, s->frame_lsp_bitsize);
1663 }
1664 bd_idx = s->vbm_tree[get_vlc2(gb, frame_type_vlc.table, 6, 3)];
1665 if (bd_idx < 0)
1666 return -1; // invalid frame type VLC code
1667 frame_desc = &frame_descs[bd_idx];
1668 if (frame_desc->acb_type == ACB_TYPE_ASYMMETRIC) {
1669 if (get_bits_left(gb) < s->pitch_nbits)
1670 return 1;
1671 skip_bits_long(gb, s->pitch_nbits);
1672 }
1673 if (frame_desc->fcb_type == FCB_TYPE_SILENCE) {
1674 skip_bits(gb, 8);
1675 } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
1676 int tmp = get_bits(gb, 6);
1677 if (tmp >= 0x36) {
1678 skip_bits(gb, 2);
1679 aw_idx_is_ext = 1;
1680 }
1681 }
1682
1683 /* blocks */
1684 if (frame_desc->acb_type == ACB_TYPE_HAMMING) {
1685 need_bits = s->block_pitch_nbits +
1686 (frame_desc->n_blocks - 1) * s->block_delta_pitch_nbits;
1687 } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
1688 need_bits = 2 * !aw_idx_is_ext;
1689 } else
1690 need_bits = 0;
1691 need_bits += frame_desc->frame_size;
1692 if (get_bits_left(gb) < need_bits)
1693 return 1;
1694 skip_bits_long(gb, need_bits);
1695 }
1696
1697 return 0;
1698}
1699
1700/**
1701 * Synthesize output samples for a single superframe. If we have any data
1702 * cached in s->sframe_cache, that will be used instead of whatever is loaded
1703 * in s->gb.
1704 *
1705 * WMA Voice superframes contain 3 frames, each containing 160 audio samples,
1706 * to give a total of 480 samples per frame. See #synth_frame() for frame
1707 * parsing. In addition to 3 frames, superframes can also contain the LSPs
1708 * (if these are globally specified for all frames (residually); they can
1709 * also be specified individually per-frame. See the s->has_residual_lsps
1710 * option), and can specify the number of samples encoded in this superframe
1711 * (if less than 480), usually used to prevent blanks at track boundaries.
1712 *
1713 * @param ctx WMA Voice decoder context
1714 * @param samples pointer to output buffer for voice samples
1715 * @param data_size pointer containing the size of #samples on input, and the
1716 * amount of #samples filled on output
1717 * @return 0 on success, <0 on error or 1 if there was not enough data to
1718 * fully parse the superframe
1719 */
1720static int synth_superframe(AVCodecContext *ctx,
1721 float *samples, int *data_size)
1722{
1723 WMAVoiceContext *s = ctx->priv_data;
1724 GetBitContext *gb = &s->gb, s_gb;
1725 int n, res, n_samples = 480;
1726 double lsps[MAX_FRAMES][MAX_LSPS];
1727 const double *mean_lsf = s->lsps == 16 ?
1728 wmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10[s->lsp_def_mode];
1729 float excitation[MAX_SIGNAL_HISTORY + MAX_SFRAMESIZE + 12];
1730 float synth[MAX_LSPS + MAX_SFRAMESIZE];
1731
1732 memcpy(synth, s->synth_history,
1733 s->lsps * sizeof(*synth));
1734 memcpy(excitation, s->excitation_history,
1735 s->history_nsamples * sizeof(*excitation));
1736
1737 if (s->sframe_cache_size > 0) {
1738 gb = &s_gb;
1739 init_get_bits(gb, s->sframe_cache, s->sframe_cache_size);
1740 s->sframe_cache_size = 0;
1741 }
1742
1743 if ((res = check_bits_for_superframe(gb, s)) == 1) return 1;
1744
1745 /* First bit is speech/music bit, it differentiates between WMAVoice
1746 * speech samples (the actual codec) and WMAVoice music samples, which
1747 * are really WMAPro-in-WMAVoice-superframes. I've never seen those in
1748 * the wild yet. */
1749 if (!get_bits1(gb)) {
1750 av_log_missing_feature(ctx, "WMAPro-in-WMAVoice support", 1);
1751 return ERROR_WMAPRO_IN_WMAVOICE;
1752 }
1753
1754 /* (optional) nr. of samples in superframe; always <= 480 and >= 0 */
1755 if (get_bits1(gb)) {
1756 if ((n_samples = get_bits(gb, 12)) > 480) {
1757 av_log(ctx, AV_LOG_ERROR,
1758 "Superframe encodes >480 samples (%d), not allowed\n",
1759 n_samples);
1760 return -1;
1761 }
1762 }
1763 /* Parse LSPs, if global for the superframe (can also be per-frame). */
1764 if (s->has_residual_lsps) {
1765 double prev_lsps[MAX_LSPS], a1[MAX_LSPS * 2], a2[MAX_LSPS * 2];
1766
1767 for (n = 0; n < s->lsps; n++)
1768 prev_lsps[n] = s->prev_lsps[n] - mean_lsf[n];
1769
1770 if (s->lsps == 10) {
1771 dequant_lsp10r(gb, lsps[2], prev_lsps, a1, a2, s->lsp_q_mode);
1772 } else /* s->lsps == 16 */
1773 dequant_lsp16r(gb, lsps[2], prev_lsps, a1, a2, s->lsp_q_mode);
1774
1775 for (n = 0; n < s->lsps; n++) {
1776 lsps[0][n] = mean_lsf[n] + (a1[n] - a2[n * 2]);
1777 lsps[1][n] = mean_lsf[n] + (a1[s->lsps + n] - a2[n * 2 + 1]);
1778 lsps[2][n] += mean_lsf[n];
1779 }
1780 for (n = 0; n < 3; n++)
1781 stabilize_lsps(lsps[n], s->lsps);
1782 }
1783
1784 /* Parse frames, optionally preceeded by per-frame (independent) LSPs. */
1785 for (n = 0; n < 3; n++) {
1786 if (!s->has_residual_lsps) {
1787 int m;
1788
1789 if (s->lsps == 10) {
1790 dequant_lsp10i(gb, lsps[n]);
1791 } else /* s->lsps == 16 */
1792 dequant_lsp16i(gb, lsps[n]);
1793
1794 for (m = 0; m < s->lsps; m++)
1795 lsps[n][m] += mean_lsf[m];
1796 stabilize_lsps(lsps[n], s->lsps);
1797 }
1798
1799 if ((res = synth_frame(ctx, gb, n,
1800 &samples[n * MAX_FRAMESIZE],
1801 lsps[n], n == 0 ? s->prev_lsps : lsps[n - 1],
1802 &excitation[s->history_nsamples + n * MAX_FRAMESIZE],
1803 &synth[s->lsps + n * MAX_FRAMESIZE])))
1804 return res;
1805 }
1806
1807 /* Statistics? FIXME - we don't check for length, a slight overrun
1808 * will be caught by internal buffer padding, and anything else
1809 * will be skipped, not read. */
1810 if (get_bits1(gb)) {
1811 res = get_bits(gb, 4);
1812 skip_bits(gb, 10 * (res + 1));
1813 }
1814
1815 /* Specify nr. of output samples */
1816 *data_size = n_samples * sizeof(float);
1817
1818 /* Update history */
1819 memcpy(s->prev_lsps, lsps[2],
1820 s->lsps * sizeof(*s->prev_lsps));
1821 memcpy(s->synth_history, &synth[MAX_SFRAMESIZE],
1822 s->lsps * sizeof(*synth));
1823 memcpy(s->excitation_history, &excitation[MAX_SFRAMESIZE],
1824 s->history_nsamples * sizeof(*excitation));
1825 if (s->do_apf)
1826 memmove(s->zero_exc_pf, &s->zero_exc_pf[MAX_SFRAMESIZE],
1827 s->history_nsamples * sizeof(*s->zero_exc_pf));
1828
1829 return 0;
1830}
1831
1832/**
1833 * Parse the packet header at the start of each packet (input data to this
1834 * decoder).
1835 *
1836 * @param s WMA Voice decoding context private data
1837 * @return 1 if not enough bits were available, or 0 on success.
1838 */
1839static int parse_packet_header(WMAVoiceContext *s)
1840{
1841 GetBitContext *gb = &s->gb;
1842 unsigned int res;
1843
1844 if (get_bits_left(gb) < 11)
1845 return 1;
1846 skip_bits(gb, 4); // packet sequence number
1847 s->has_residual_lsps = get_bits1(gb);
1848 do {
1849 res = get_bits(gb, 6); // number of superframes per packet
1850 // (minus first one if there is spillover)
1851 if (get_bits_left(gb) < 6 * (res == 0x3F) + s->spillover_bitsize)
1852 return 1;
1853 } while (res == 0x3F);
1854 s->spillover_nbits = get_bits(gb, s->spillover_bitsize);
1855
1856 return 0;
1857}
1858
1859/**
1860 * Copy (unaligned) bits from gb/data/size to pb.
1861 *
1862 * @param pb target buffer to copy bits into
1863 * @param data source buffer to copy bits from
1864 * @param size size of the source data, in bytes
1865 * @param gb bit I/O context specifying the current position in the source.
1866 * data. This function might use this to align the bit position to
1867 * a whole-byte boundary before calling #ff_copy_bits() on aligned
1868 * source data
1869 * @param nbits the amount of bits to copy from source to target
1870 *
1871 * @note after calling this function, the current position in the input bit
1872 * I/O context is undefined.
1873 */
1874static void copy_bits(PutBitContext *pb,
1875 const uint8_t *data, int size,
1876 GetBitContext *gb, int nbits)
1877{
1878 int rmn_bytes, rmn_bits;
1879
1880 rmn_bits = rmn_bytes = get_bits_left(gb);
1881 if (rmn_bits < nbits)
1882 return;
1883 rmn_bits &= 7; rmn_bytes >>= 3;
1884 if ((rmn_bits = FFMIN(rmn_bits, nbits)) > 0)
1885 put_bits(pb, rmn_bits, get_bits(gb, rmn_bits));
1886 ff_copy_bits(pb, data + size - rmn_bytes,
1887 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
1888}
1889
1890/**
1891 * Packet decoding: a packet is anything that the (ASF) demuxer contains,
1892 * and we expect that the demuxer / application provides it to us as such
1893 * (else you'll probably get garbage as output). Every packet has a size of
1894 * ctx->block_align bytes, starts with a packet header (see
1895 * #parse_packet_header()), and then a series of superframes. Superframe
1896 * boundaries may exceed packets, i.e. superframes can split data over
1897 * multiple (two) packets.
1898 *
1899 * For more information about frames, see #synth_superframe().
1900 */
1901int wmavoice_decode_packet(AVCodecContext *ctx, void *data,
1902 int *data_size, AVPacket *avpkt)
1903{
1904 WMAVoiceContext *s = ctx->priv_data;
1905 GetBitContext *gb = &s->gb;
1906 int size, res, pos;
1907
1908 if (*data_size < 480 * sizeof(float)) {
1909 av_log(ctx, AV_LOG_ERROR,
1910 "Output buffer too small (%d given - %zu needed)\n",
1911 *data_size, 480 * sizeof(float));
1912 return -1;
1913 }
1914 *data_size = 0;
1915
1916 /* Packets are sometimes a multiple of ctx->block_align, with a packet
1917 * header at each ctx->block_align bytes. However, FFmpeg's ASF demuxer
1918 * feeds us ASF packets, which may concatenate multiple "codec" packets
1919 * in a single "muxer" packet, so we artificially emulate that by
1920 * capping the packet size at ctx->block_align. */
1921 for (size = avpkt->size; size > ctx->block_align; size -= ctx->block_align);
1922 if (!size)
1923 return 0;
1924 init_get_bits(&s->gb, avpkt->data, size << 3);
1925
1926 /* size == ctx->block_align is used to indicate whether we are dealing with
1927 * a new packet or a packet of which we already read the packet header
1928 * previously. */
1929 if (size == ctx->block_align) { // new packet header
1930 if ((res = parse_packet_header(s)) < 0)
1931 return res;
1932
1933 /* If the packet header specifies a s->spillover_nbits, then we want
1934 * to push out all data of the previous packet (+ spillover) before
1935 * continuing to parse new superframes in the current packet. */
1936 if (s->spillover_nbits > 0) {
1937 if (s->sframe_cache_size > 0) {
1938 int cnt = get_bits_count(gb);
1939 copy_bits(&s->pb, avpkt->data, size, gb, s->spillover_nbits);
1940 flush_put_bits(&s->pb);
1941 s->sframe_cache_size += s->spillover_nbits;
1942 if ((res = synth_superframe(ctx, data, data_size)) == 0 &&
1943 *data_size > 0) {
1944 /* convert the float values to int32 for rockbox */
1945 int i;
1946 int32_t *iptr = data;
1947 float *fptr = data;
1948 for(i = 0; i < *data_size/sizeof(float); i++)
1949 {
1950 fptr[i] *= (float)(INT32_MAX);
1951 iptr[i] = (int32_t)fptr[i];
1952 }
1953 cnt += s->spillover_nbits;
1954 s->skip_bits_next = cnt & 7;
1955 return cnt >> 3;
1956 } else
1957 skip_bits_long (gb, s->spillover_nbits - cnt +
1958 get_bits_count(gb)); // resync
1959 } else
1960 skip_bits_long(gb, s->spillover_nbits); // resync
1961 }
1962 } else if (s->skip_bits_next)
1963 skip_bits(gb, s->skip_bits_next);
1964
1965 /* Try parsing superframes in current packet */
1966 s->sframe_cache_size = 0;
1967 s->skip_bits_next = 0;
1968 pos = get_bits_left(gb);
1969 if ((res = synth_superframe(ctx, data, data_size)) < 0) {
1970 return res;
1971 } else if (*data_size > 0) {
1972 int cnt = get_bits_count(gb);
1973 s->skip_bits_next = cnt & 7;
1974 /* convert the float values to int32 for rockbox */
1975 int i;
1976 int32_t *iptr = data;
1977 float *fptr = data;
1978 for(i = 0; i < *data_size/sizeof(float); i++)
1979 {
1980 fptr[i] *= (float)(INT32_MAX);
1981 iptr[i] = (int32_t)fptr[i];
1982 }
1983 return cnt >> 3;
1984 } else if ((s->sframe_cache_size = pos) > 0) {
1985 /* rewind bit reader to start of last (incomplete) superframe... */
1986 init_get_bits(gb, avpkt->data, size << 3);
1987 skip_bits_long(gb, (size << 3) - pos);
1988 //assert(get_bits_left(gb) == pos);
1989
1990 /* ...and cache it for spillover in next packet */
1991 init_put_bits(&s->pb, s->sframe_cache, SFRAME_CACHE_MAXSIZE);
1992 copy_bits(&s->pb, avpkt->data, size, gb, s->sframe_cache_size);
1993 // FIXME bad - just copy bytes as whole and add use the
1994 // skip_bits_next field
1995 }
1996
1997 return size;
1998}
1999
2000static av_cold int wmavoice_decode_end(AVCodecContext *ctx)
2001{
2002 WMAVoiceContext *s = ctx->priv_data;
2003
2004 if (s->do_apf) {
2005 ff_rdft_end(&s->rdft);
2006 ff_rdft_end(&s->irdft);
2007 ff_dct_end(&s->dct);
2008 ff_dct_end(&s->dst);
2009 }
2010
2011 return 0;
2012}
2013
2014static av_cold void wmavoice_flush(AVCodecContext *ctx)
2015{
2016 WMAVoiceContext *s = ctx->priv_data;
2017 int n;
2018
2019 s->postfilter_agc = 0;
2020 s->sframe_cache_size = 0;
2021 s->skip_bits_next = 0;
2022 for (n = 0; n < s->lsps; n++)
2023 s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
2024 memset(s->excitation_history, 0,
2025 sizeof(*s->excitation_history) * MAX_SIGNAL_HISTORY);
2026 memset(s->synth_history, 0,
2027 sizeof(*s->synth_history) * MAX_LSPS);
2028 memset(s->gain_pred_err, 0,
2029 sizeof(s->gain_pred_err));
2030
2031 if (s->do_apf) {
2032 memset(&s->synth_filter_out_buf[MAX_LSPS_ALIGN16 - s->lsps], 0,
2033 sizeof(*s->synth_filter_out_buf) * s->lsps);
2034 memset(s->dcf_mem, 0,
2035 sizeof(*s->dcf_mem) * 2);
2036 memset(s->zero_exc_pf, 0,
2037 sizeof(*s->zero_exc_pf) * s->history_nsamples);
2038 memset(s->denoise_filter_cache, 0, sizeof(s->denoise_filter_cache));
2039 }
2040}
2041#if 0
2042AVCodec wmavoice_decoder = {
2043 "wmavoice",
2044 AVMEDIA_TYPE_AUDIO,
2045 CODEC_ID_WMAVOICE,
2046 sizeof(WMAVoiceContext),
2047 wmavoice_decode_init,
2048 NULL,
2049 wmavoice_decode_end,
2050 wmavoice_decode_packet,
2051 CODEC_CAP_SUBFRAMES,
2052 .flush = wmavoice_flush,
2053 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
2054};
2055#endif
2056
2057int main(void)
2058{
2059 return 0;
2060}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-07 13:40:55 +0000