00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00028 #include <math.h>
00029 #include "avcodec.h"
00030 #include "get_bits.h"
00031 #include "put_bits.h"
00032 #include "wmavoice_data.h"
00033 #include "celp_math.h"
00034 #include "celp_filters.h"
00035 #include "acelp_vectors.h"
00036 #include "acelp_filters.h"
00037 #include "lsp.h"
00038 #include "libavutil/lzo.h"
00039
00040 #define MAX_BLOCKS 8
00041 #define MAX_LSPS 16
00042 #define MAX_FRAMES 3
00043 #define MAX_FRAMESIZE 160
00044 #define MAX_SIGNAL_HISTORY 416
00045 #define MAX_SFRAMESIZE (MAX_FRAMESIZE * MAX_FRAMES)
00047 #define SFRAME_CACHE_MAXSIZE 256
00048
00049 #define VLC_NBITS 6
00050
00051
00054 static VLC frame_type_vlc;
00055
00059 enum {
00060 ACB_TYPE_NONE = 0,
00061 ACB_TYPE_ASYMMETRIC = 1,
00062
00063
00064
00065
00066 ACB_TYPE_HAMMING = 2
00067
00068
00069 };
00070
00074 enum {
00075 FCB_TYPE_SILENCE = 0,
00076
00077
00078 FCB_TYPE_HARDCODED = 1,
00079
00080 FCB_TYPE_AW_PULSES = 2,
00081
00082 FCB_TYPE_EXC_PULSES = 3,
00083
00084
00085 };
00086
00090 static const struct frame_type_desc {
00091 uint8_t n_blocks;
00092
00093 uint8_t log_n_blocks;
00094 uint8_t acb_type;
00095 uint8_t fcb_type;
00096 uint8_t dbl_pulses;
00097
00098
00099 uint16_t frame_size;
00100
00101 } frame_descs[17] = {
00102 { 1, 0, ACB_TYPE_NONE, FCB_TYPE_SILENCE, 0, 0 },
00103 { 2, 1, ACB_TYPE_NONE, FCB_TYPE_HARDCODED, 0, 28 },
00104 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_AW_PULSES, 0, 46 },
00105 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2, 80 },
00106 { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 104 },
00107 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 0, 108 },
00108 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2, 132 },
00109 { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 168 },
00110 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 64 },
00111 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 80 },
00112 { 2, 1, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 104 },
00113 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 108 },
00114 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 132 },
00115 { 4, 2, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 168 },
00116 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 0, 176 },
00117 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 2, 208 },
00118 { 8, 3, ACB_TYPE_HAMMING, FCB_TYPE_EXC_PULSES, 5, 256 }
00119 };
00120
00124 typedef struct {
00131 GetBitContext gb;
00132
00133
00134
00135 int8_t vbm_tree[25];
00136
00137 int spillover_bitsize;
00138
00139
00140 int history_nsamples;
00141
00142
00143 int do_apf;
00144
00145
00146 int lsps;
00147 int lsp_q_mode;
00148 int lsp_def_mode;
00149
00150 int frame_lsp_bitsize;
00151
00152 int sframe_lsp_bitsize;
00153
00154
00155 int min_pitch_val;
00156 int max_pitch_val;
00157 int pitch_nbits;
00158
00159 int block_pitch_nbits;
00160
00161 int block_pitch_range;
00162 int block_delta_pitch_nbits;
00163
00164
00165
00166 int block_delta_pitch_hrange;
00167
00168 uint16_t block_conv_table[4];
00169
00170
00179 int spillover_nbits;
00180
00181
00182
00183 int has_residual_lsps;
00184
00185
00186
00187
00188 int skip_bits_next;
00189
00190
00191
00192 uint8_t sframe_cache[SFRAME_CACHE_MAXSIZE + FF_INPUT_BUFFER_PADDING_SIZE];
00195 int sframe_cache_size;
00196
00197
00198
00199
00200 PutBitContext pb;
00201
00210 double prev_lsps[MAX_LSPS];
00211
00212 int last_pitch_val;
00213 int last_acb_type;
00214 int pitch_diff_sh16;
00215
00216 float silence_gain;
00217
00218 int aw_idx_is_ext;
00219
00220 int aw_pulse_range;
00221
00222
00223
00224
00225
00226 int aw_n_pulses[2];
00227
00228
00229 int aw_first_pulse_off[2];
00230
00231 int aw_next_pulse_off_cache;
00232
00233
00234
00235
00236
00237 int frame_cntr;
00238
00239 float gain_pred_err[6];
00240 float excitation_history[MAX_SIGNAL_HISTORY];
00244 float synth_history[MAX_LSPS];
00245
00248 } WMAVoiceContext;
00249
00259 static av_cold int decode_vbmtree(GetBitContext *gb, int8_t vbm_tree[25])
00260 {
00261 static const uint8_t bits[] = {
00262 2, 2, 2, 4, 4, 4,
00263 6, 6, 6, 8, 8, 8,
00264 10, 10, 10, 12, 12, 12,
00265 14, 14, 14, 14
00266 };
00267 static const uint16_t codes[] = {
00268 0x0000, 0x0001, 0x0002,
00269 0x000c, 0x000d, 0x000e,
00270 0x003c, 0x003d, 0x003e,
00271 0x00fc, 0x00fd, 0x00fe,
00272 0x03fc, 0x03fd, 0x03fe,
00273 0x0ffc, 0x0ffd, 0x0ffe,
00274 0x3ffc, 0x3ffd, 0x3ffe, 0x3fff
00275 };
00276 int cntr[8], n, res;
00277
00278 memset(vbm_tree, 0xff, sizeof(vbm_tree));
00279 memset(cntr, 0, sizeof(cntr));
00280 for (n = 0; n < 17; n++) {
00281 res = get_bits(gb, 3);
00282 if (cntr[res] > 3)
00283 return -1;
00284 vbm_tree[res * 3 + cntr[res]++] = n;
00285 }
00286 INIT_VLC_STATIC(&frame_type_vlc, VLC_NBITS, sizeof(bits),
00287 bits, 1, 1, codes, 2, 2, 132);
00288 return 0;
00289 }
00290
00294 static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
00295 {
00296 int n, flags, pitch_range, lsp16_flag;
00297 WMAVoiceContext *s = ctx->priv_data;
00298
00307 if (ctx->extradata_size != 46) {
00308 av_log(ctx, AV_LOG_ERROR,
00309 "Invalid extradata size %d (should be 46)\n",
00310 ctx->extradata_size);
00311 return -1;
00312 }
00313 flags = AV_RL32(ctx->extradata + 18);
00314 s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
00315 s->do_apf = flags & 0x1;
00316 s->lsp_q_mode = !!(flags & 0x2000);
00317 s->lsp_def_mode = !!(flags & 0x4000);
00318 lsp16_flag = flags & 0x1000;
00319 if (lsp16_flag) {
00320 s->lsps = 16;
00321 s->frame_lsp_bitsize = 34;
00322 s->sframe_lsp_bitsize = 60;
00323 } else {
00324 s->lsps = 10;
00325 s->frame_lsp_bitsize = 24;
00326 s->sframe_lsp_bitsize = 48;
00327 }
00328 for (n = 0; n < s->lsps; n++)
00329 s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
00330
00331 init_get_bits(&s->gb, ctx->extradata + 22, (ctx->extradata_size - 22) << 3);
00332 if (decode_vbmtree(&s->gb, s->vbm_tree) < 0) {
00333 av_log(ctx, AV_LOG_ERROR, "Invalid VBM tree; broken extradata?\n");
00334 return -1;
00335 }
00336
00337 s->min_pitch_val = ((ctx->sample_rate << 8) / 400 + 50) >> 8;
00338 s->max_pitch_val = ((ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
00339 pitch_range = s->max_pitch_val - s->min_pitch_val;
00340 s->pitch_nbits = av_ceil_log2(pitch_range);
00341 s->last_pitch_val = 40;
00342 s->last_acb_type = ACB_TYPE_NONE;
00343 s->history_nsamples = s->max_pitch_val + 8;
00344
00345 if (s->min_pitch_val < 1 || s->history_nsamples > MAX_SIGNAL_HISTORY) {
00346 int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
00347 max_sr = ((((MAX_SIGNAL_HISTORY - 8) << 8) + 205) * 2000 / 37) >> 8;
00348
00349 av_log(ctx, AV_LOG_ERROR,
00350 "Unsupported samplerate %d (min=%d, max=%d)\n",
00351 ctx->sample_rate, min_sr, max_sr);
00352
00353 return -1;
00354 }
00355
00356 s->block_conv_table[0] = s->min_pitch_val;
00357 s->block_conv_table[1] = (pitch_range * 25) >> 6;
00358 s->block_conv_table[2] = (pitch_range * 44) >> 6;
00359 s->block_conv_table[3] = s->max_pitch_val - 1;
00360 s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
00361 s->block_delta_pitch_nbits = 1 + av_ceil_log2(s->block_delta_pitch_hrange);
00362 s->block_pitch_range = s->block_conv_table[2] +
00363 s->block_conv_table[3] + 1 +
00364 2 * (s->block_conv_table[1] - 2 * s->min_pitch_val);
00365 s->block_pitch_nbits = av_ceil_log2(s->block_pitch_range);
00366
00367 ctx->sample_fmt = SAMPLE_FMT_FLT;
00368
00369 return 0;
00370 }
00371
00383 static void dequant_lsps(double *lsps, int num,
00384 const uint16_t *values,
00385 const uint16_t *sizes,
00386 int n_stages, const uint8_t *table,
00387 const double *mul_q,
00388 const double *base_q)
00389 {
00390 int n, m;
00391
00392 memset(lsps, 0, num * sizeof(*lsps));
00393 for (n = 0; n < n_stages; n++) {
00394 const uint8_t *t_off = &table[values[n] * num];
00395 double base = base_q[n], mul = mul_q[n];
00396
00397 for (m = 0; m < num; m++)
00398 lsps[m] += base + mul * t_off[m];
00399
00400 table += sizes[n] * num;
00401 }
00402 }
00403
00415 static void dequant_lsp10i(GetBitContext *gb, double *lsps)
00416 {
00417 static const uint16_t vec_sizes[4] = { 256, 64, 32, 32 };
00418 static const double mul_lsf[4] = {
00419 5.2187144800e-3, 1.4626986422e-3,
00420 9.6179549166e-4, 1.1325736225e-3
00421 };
00422 static const double base_lsf[4] = {
00423 M_PI * -2.15522e-1, M_PI * -6.1646e-2,
00424 M_PI * -3.3486e-2, M_PI * -5.7408e-2
00425 };
00426 uint16_t v[4];
00427
00428 v[0] = get_bits(gb, 8);
00429 v[1] = get_bits(gb, 6);
00430 v[2] = get_bits(gb, 5);
00431 v[3] = get_bits(gb, 5);
00432
00433 dequant_lsps(lsps, 10, v, vec_sizes, 4, wmavoice_dq_lsp10i,
00434 mul_lsf, base_lsf);
00435 }
00436
00441 static void dequant_lsp10r(GetBitContext *gb,
00442 double *i_lsps, const double *old,
00443 double *a1, double *a2, int q_mode)
00444 {
00445 static const uint16_t vec_sizes[3] = { 128, 64, 64 };
00446 static const double mul_lsf[3] = {
00447 2.5807601174e-3, 1.2354460219e-3, 1.1763821673e-3
00448 };
00449 static const double base_lsf[3] = {
00450 M_PI * -1.07448e-1, M_PI * -5.2706e-2, M_PI * -5.1634e-2
00451 };
00452 const float (*ipol_tab)[2][10] = q_mode ?
00453 wmavoice_lsp10_intercoeff_b : wmavoice_lsp10_intercoeff_a;
00454 uint16_t interpol, v[3];
00455 int n;
00456
00457 dequant_lsp10i(gb, i_lsps);
00458
00459 interpol = get_bits(gb, 5);
00460 v[0] = get_bits(gb, 7);
00461 v[1] = get_bits(gb, 6);
00462 v[2] = get_bits(gb, 6);
00463
00464 for (n = 0; n < 10; n++) {
00465 double delta = old[n] - i_lsps[n];
00466 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
00467 a1[10 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
00468 }
00469
00470 dequant_lsps(a2, 20, v, vec_sizes, 3, wmavoice_dq_lsp10r,
00471 mul_lsf, base_lsf);
00472 }
00473
00477 static void dequant_lsp16i(GetBitContext *gb, double *lsps)
00478 {
00479 static const uint16_t vec_sizes[5] = { 256, 64, 128, 64, 128 };
00480 static const double mul_lsf[5] = {
00481 3.3439586280e-3, 6.9908173703e-4,
00482 3.3216608306e-3, 1.0334960326e-3,
00483 3.1899104283e-3
00484 };
00485 static const double base_lsf[5] = {
00486 M_PI * -1.27576e-1, M_PI * -2.4292e-2,
00487 M_PI * -1.28094e-1, M_PI * -3.2128e-2,
00488 M_PI * -1.29816e-1
00489 };
00490 uint16_t v[5];
00491
00492 v[0] = get_bits(gb, 8);
00493 v[1] = get_bits(gb, 6);
00494 v[2] = get_bits(gb, 7);
00495 v[3] = get_bits(gb, 6);
00496 v[4] = get_bits(gb, 7);
00497
00498 dequant_lsps( lsps, 5, v, vec_sizes, 2,
00499 wmavoice_dq_lsp16i1, mul_lsf, base_lsf);
00500 dequant_lsps(&lsps[5], 5, &v[2], &vec_sizes[2], 2,
00501 wmavoice_dq_lsp16i2, &mul_lsf[2], &base_lsf[2]);
00502 dequant_lsps(&lsps[10], 6, &v[4], &vec_sizes[4], 1,
00503 wmavoice_dq_lsp16i3, &mul_lsf[4], &base_lsf[4]);
00504 }
00505
00510 static void dequant_lsp16r(GetBitContext *gb,
00511 double *i_lsps, const double *old,
00512 double *a1, double *a2, int q_mode)
00513 {
00514 static const uint16_t vec_sizes[3] = { 128, 128, 128 };
00515 static const double mul_lsf[3] = {
00516 1.2232979501e-3, 1.4062241527e-3, 1.6114744851e-3
00517 };
00518 static const double base_lsf[3] = {
00519 M_PI * -5.5830e-2, M_PI * -5.2908e-2, M_PI * -5.4776e-2
00520 };
00521 const float (*ipol_tab)[2][16] = q_mode ?
00522 wmavoice_lsp16_intercoeff_b : wmavoice_lsp16_intercoeff_a;
00523 uint16_t interpol, v[3];
00524 int n;
00525
00526 dequant_lsp16i(gb, i_lsps);
00527
00528 interpol = get_bits(gb, 5);
00529 v[0] = get_bits(gb, 7);
00530 v[1] = get_bits(gb, 7);
00531 v[2] = get_bits(gb, 7);
00532
00533 for (n = 0; n < 16; n++) {
00534 double delta = old[n] - i_lsps[n];
00535 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
00536 a1[16 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
00537 }
00538
00539 dequant_lsps( a2, 10, v, vec_sizes, 1,
00540 wmavoice_dq_lsp16r1, mul_lsf, base_lsf);
00541 dequant_lsps(&a2[10], 10, &v[1], &vec_sizes[1], 1,
00542 wmavoice_dq_lsp16r2, &mul_lsf[1], &base_lsf[1]);
00543 dequant_lsps(&a2[20], 12, &v[2], &vec_sizes[2], 1,
00544 wmavoice_dq_lsp16r3, &mul_lsf[2], &base_lsf[2]);
00545 }
00546
00560 static void aw_parse_coords(WMAVoiceContext *s, GetBitContext *gb,
00561 const int *pitch)
00562 {
00563 static const int16_t start_offset[94] = {
00564 -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11,
00565 13, 15, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26,
00566 27, 28, 29, 30, 31, 32, 33, 35, 37, 39, 41, 43,
00567 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
00568 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
00569 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115,
00570 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139,
00571 141, 143, 145, 147, 149, 151, 153, 155, 157, 159
00572 };
00573 int bits, offset;
00574
00575
00576 s->aw_idx_is_ext = 0;
00577 if ((bits = get_bits(gb, 6)) >= 54) {
00578 s->aw_idx_is_ext = 1;
00579 bits += (bits - 54) * 3 + get_bits(gb, 2);
00580 }
00581
00582
00583
00584 s->aw_pulse_range = FFMIN(pitch[0], pitch[1]) > 32 ? 24 : 16;
00585 for (offset = start_offset[bits]; offset < 0; offset += pitch[0]) ;
00586 s->aw_n_pulses[0] = (pitch[0] - 1 + MAX_FRAMESIZE / 2 - offset) / pitch[0];
00587 s->aw_first_pulse_off[0] = offset - s->aw_pulse_range / 2;
00588 offset += s->aw_n_pulses[0] * pitch[0];
00589 s->aw_n_pulses[1] = (pitch[1] - 1 + MAX_FRAMESIZE - offset) / pitch[1];
00590 s->aw_first_pulse_off[1] = offset - (MAX_FRAMESIZE + s->aw_pulse_range) / 2;
00591
00592
00593
00594
00595 if (start_offset[bits] < MAX_FRAMESIZE / 2) {
00596 while (s->aw_first_pulse_off[1] - pitch[1] + s->aw_pulse_range > 0)
00597 s->aw_first_pulse_off[1] -= pitch[1];
00598 if (start_offset[bits] < 0)
00599 while (s->aw_first_pulse_off[0] - pitch[0] + s->aw_pulse_range > 0)
00600 s->aw_first_pulse_off[0] -= pitch[0];
00601 }
00602 }
00603
00611 static void aw_pulse_set2(WMAVoiceContext *s, GetBitContext *gb,
00612 int block_idx, AMRFixed *fcb)
00613 {
00614 uint16_t use_mask[7];
00615
00616
00617
00618
00619
00620
00621
00622 int pulse_off = s->aw_first_pulse_off[block_idx],
00623 pulse_start, n, idx, range, aidx, start_off = 0;
00624
00625
00626 if (s->aw_n_pulses[block_idx] > 0)
00627 while (pulse_off + s->aw_pulse_range < 1)
00628 pulse_off += fcb->pitch_lag;
00629
00630
00631 if (s->aw_n_pulses[0] > 0) {
00632 if (block_idx == 0) {
00633 range = 32;
00634 } else {
00635 range = 8;
00636 if (s->aw_n_pulses[block_idx] > 0)
00637 pulse_off = s->aw_next_pulse_off_cache;
00638 }
00639 } else
00640 range = 16;
00641 pulse_start = s->aw_n_pulses[block_idx] > 0 ? pulse_off - range / 2 : 0;
00642
00643
00644
00645
00646 memset( use_mask, -1, 5 * sizeof(use_mask[0]));
00647 memset(&use_mask[5], 0, 2 * sizeof(use_mask[0]));
00648 if (s->aw_n_pulses[block_idx] > 0)
00649 for (idx = pulse_off; idx < MAX_FRAMESIZE / 2; idx += fcb->pitch_lag) {
00650 int excl_range = s->aw_pulse_range;
00651 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
00652 int first_sh = 16 - (idx & 15);
00653 *use_mask_ptr++ &= 0xFFFF << first_sh;
00654 excl_range -= first_sh;
00655 if (excl_range >= 16) {
00656 *use_mask_ptr++ = 0;
00657 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
00658 } else
00659 *use_mask_ptr &= 0xFFFF >> excl_range;
00660 }
00661
00662
00663 aidx = get_bits(gb, s->aw_n_pulses[0] > 0 ? 5 - 2 * block_idx : 4);
00664 for (n = 0; n <= aidx; pulse_start++) {
00665 for (idx = pulse_start; idx < 0; idx += fcb->pitch_lag) ;
00666 if (idx >= MAX_FRAMESIZE / 2) {
00667 if (use_mask[0]) idx = 0x0F;
00668 else if (use_mask[1]) idx = 0x1F;
00669 else if (use_mask[2]) idx = 0x2F;
00670 else if (use_mask[3]) idx = 0x3F;
00671 else if (use_mask[4]) idx = 0x4F;
00672 else return;
00673 idx -= av_log2_16bit(use_mask[idx >> 4]);
00674 }
00675 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
00676 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
00677 n++;
00678 start_off = idx;
00679 }
00680 }
00681
00682 fcb->x[fcb->n] = start_off;
00683 fcb->y[fcb->n] = get_bits1(gb) ? -1.0 : 1.0;
00684 fcb->n++;
00685
00686
00687 n = (MAX_FRAMESIZE / 2 - start_off) % fcb->pitch_lag;
00688 s->aw_next_pulse_off_cache = n ? fcb->pitch_lag - n : 0;
00689 }
00690
00698 static void aw_pulse_set1(WMAVoiceContext *s, GetBitContext *gb,
00699 int block_idx, AMRFixed *fcb)
00700 {
00701 int val = get_bits(gb, 12 - 2 * (s->aw_idx_is_ext && !block_idx));
00702 float v;
00703
00704 if (s->aw_n_pulses[block_idx] > 0) {
00705 int n, v_mask, i_mask, sh, n_pulses;
00706
00707 if (s->aw_pulse_range == 24) {
00708 n_pulses = 3;
00709 v_mask = 8;
00710 i_mask = 7;
00711 sh = 4;
00712 } else {
00713 n_pulses = 4;
00714 v_mask = 4;
00715 i_mask = 3;
00716 sh = 3;
00717 }
00718
00719 for (n = n_pulses - 1; n >= 0; n--, val >>= sh) {
00720 fcb->y[fcb->n] = (val & v_mask) ? -1.0 : 1.0;
00721 fcb->x[fcb->n] = (val & i_mask) * n_pulses + n +
00722 s->aw_first_pulse_off[block_idx];
00723 while (fcb->x[fcb->n] < 0)
00724 fcb->x[fcb->n] += fcb->pitch_lag;
00725 if (fcb->x[fcb->n] < MAX_FRAMESIZE / 2)
00726 fcb->n++;
00727 }
00728 } else {
00729 int num2 = (val & 0x1FF) >> 1, delta, idx;
00730
00731 if (num2 < 1 * 79) { delta = 1; idx = num2 + 1; }
00732 else if (num2 < 2 * 78) { delta = 3; idx = num2 + 1 - 1 * 77; }
00733 else if (num2 < 3 * 77) { delta = 5; idx = num2 + 1 - 2 * 76; }
00734 else { delta = 7; idx = num2 + 1 - 3 * 75; }
00735 v = (val & 0x200) ? -1.0 : 1.0;
00736
00737 fcb->no_repeat_mask |= 3 << fcb->n;
00738 fcb->x[fcb->n] = idx - delta;
00739 fcb->y[fcb->n] = v;
00740 fcb->x[fcb->n + 1] = idx;
00741 fcb->y[fcb->n + 1] = (val & 1) ? -v : v;
00742 fcb->n += 2;
00743 }
00744 }
00745
00759 static int pRNG(int frame_cntr, int block_num, int block_size)
00760 {
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771 static const unsigned int div_tbl[9][2] = {
00772 { 8332, 3 * 715827883U },
00773 { 4545, 0 * 390451573U },
00774 { 3124, 11 * 268435456U },
00775 { 2380, 15 * 204522253U },
00776 { 1922, 23 * 165191050U },
00777 { 1612, 23 * 138547333U },
00778 { 1388, 27 * 119304648U },
00779 { 1219, 16 * 104755300U },
00780 { 1086, 39 * 93368855U }
00781 };
00782 unsigned int z, y, x = MUL16(block_num, 1877) + frame_cntr;
00783 if (x >= 0xFFFF) x -= 0xFFFF;
00784
00785 y = x - 9 * MULH(477218589, x);
00786 z = (uint16_t) (x * div_tbl[y][0] + UMULH(x, div_tbl[y][1]));
00787
00788 return z % (1000 - block_size);
00789 }
00790
00795 static void synth_block_hardcoded(WMAVoiceContext *s, GetBitContext *gb,
00796 int block_idx, int size,
00797 const struct frame_type_desc *frame_desc,
00798 float *excitation)
00799 {
00800 float gain;
00801 int n, r_idx;
00802
00803 assert(size <= MAX_FRAMESIZE);
00804
00805
00806 if (frame_desc->fcb_type == FCB_TYPE_SILENCE) {
00807 r_idx = pRNG(s->frame_cntr, block_idx, size);
00808 gain = s->silence_gain;
00809 } else {
00810 r_idx = get_bits(gb, 8);
00811 gain = wmavoice_gain_universal[get_bits(gb, 6)];
00812 }
00813
00814
00815 memset(s->gain_pred_err, 0, sizeof(s->gain_pred_err));
00816
00817
00818 for (n = 0; n < size; n++)
00819 excitation[n] = wmavoice_std_codebook[r_idx + n] * gain;
00820 }
00821
00826 static void synth_block_fcb_acb(WMAVoiceContext *s, GetBitContext *gb,
00827 int block_idx, int size,
00828 int block_pitch_sh2,
00829 const struct frame_type_desc *frame_desc,
00830 float *excitation)
00831 {
00832 static const float gain_coeff[6] = {
00833 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
00834 };
00835 float pulses[MAX_FRAMESIZE / 2], pred_err, acb_gain, fcb_gain;
00836 int n, idx, gain_weight;
00837 AMRFixed fcb;
00838
00839 assert(size <= MAX_FRAMESIZE / 2);
00840 memset(pulses, 0, sizeof(*pulses) * size);
00841
00842 fcb.pitch_lag = block_pitch_sh2 >> 2;
00843 fcb.pitch_fac = 1.0;
00844 fcb.no_repeat_mask = 0;
00845 fcb.n = 0;
00846
00847
00848
00849 if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
00850 aw_pulse_set1(s, gb, block_idx, &fcb);
00851 aw_pulse_set2(s, gb, block_idx, &fcb);
00852 } else {
00853 int offset_nbits = 5 - frame_desc->log_n_blocks;
00854
00855 fcb.no_repeat_mask = -1;
00856
00857
00858 for (n = 0; n < 5; n++) {
00859 float sign;
00860 int pos1, pos2;
00861
00862 sign = get_bits1(gb) ? 1.0 : -1.0;
00863 pos1 = get_bits(gb, offset_nbits);
00864 fcb.x[fcb.n] = n + 5 * pos1;
00865 fcb.y[fcb.n++] = sign;
00866 if (n < frame_desc->dbl_pulses) {
00867 pos2 = get_bits(gb, offset_nbits);
00868 fcb.x[fcb.n] = n + 5 * pos2;
00869 fcb.y[fcb.n++] = (pos1 < pos2) ? -sign : sign;
00870 }
00871 }
00872 }
00873 ff_set_fixed_vector(pulses, &fcb, 1.0, size);
00874
00875
00876
00877 idx = get_bits(gb, 7);
00878 fcb_gain = expf(ff_dot_productf(s->gain_pred_err, gain_coeff, 6) -
00879 5.2409161640 + wmavoice_gain_codebook_fcb[idx]);
00880 acb_gain = wmavoice_gain_codebook_acb[idx];
00881 pred_err = av_clipf(wmavoice_gain_codebook_fcb[idx],
00882 -2.9957322736 ,
00883 1.6094379124 );
00884
00885 gain_weight = 8 >> frame_desc->log_n_blocks;
00886 memmove(&s->gain_pred_err[gain_weight], s->gain_pred_err,
00887 sizeof(*s->gain_pred_err) * (6 - gain_weight));
00888 for (n = 0; n < gain_weight; n++)
00889 s->gain_pred_err[n] = pred_err;
00890
00891
00892 if (frame_desc->acb_type == ACB_TYPE_ASYMMETRIC) {
00893 int len;
00894 for (n = 0; n < size; n += len) {
00895 int next_idx_sh16;
00896 int abs_idx = block_idx * size + n;
00897 int pitch_sh16 = (s->last_pitch_val << 16) +
00898 s->pitch_diff_sh16 * abs_idx;
00899 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
00900 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
00901 idx = idx_sh16 >> 16;
00902 if (s->pitch_diff_sh16) {
00903 if (s->pitch_diff_sh16 > 0) {
00904 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
00905 } else
00906 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
00907 len = av_clip((idx_sh16 - next_idx_sh16) / s->pitch_diff_sh16 / 8,
00908 1, size - n);
00909 } else
00910 len = size;
00911
00912 ff_acelp_interpolatef(&excitation[n], &excitation[n - pitch],
00913 wmavoice_ipol1_coeffs, 17,
00914 idx, 9, len);
00915 }
00916 } else {
00917 int block_pitch = block_pitch_sh2 >> 2;
00918 idx = block_pitch_sh2 & 3;
00919 if (idx) {
00920 ff_acelp_interpolatef(excitation, &excitation[-block_pitch],
00921 wmavoice_ipol2_coeffs, 4,
00922 idx, 8, size);
00923 } else
00924 av_memcpy_backptr(excitation, sizeof(float) * block_pitch,
00925 sizeof(float) * size);
00926 }
00927
00928
00929 ff_weighted_vector_sumf(excitation, excitation, pulses,
00930 acb_gain, fcb_gain, size);
00931 }
00932
00949 static void synth_block(WMAVoiceContext *s, GetBitContext *gb,
00950 int block_idx, int size,
00951 int block_pitch_sh2,
00952 const double *lsps, const double *prev_lsps,
00953 const struct frame_type_desc *frame_desc,
00954 float *excitation, float *synth)
00955 {
00956 double i_lsps[MAX_LSPS];
00957 float lpcs[MAX_LSPS];
00958 float fac;
00959 int n;
00960
00961 if (frame_desc->acb_type == ACB_TYPE_NONE)
00962 synth_block_hardcoded(s, gb, block_idx, size, frame_desc, excitation);
00963 else
00964 synth_block_fcb_acb(s, gb, block_idx, size, block_pitch_sh2,
00965 frame_desc, excitation);
00966
00967
00968 fac = (block_idx + 0.5) / frame_desc->n_blocks;
00969 for (n = 0; n < s->lsps; n++)
00970 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
00971 ff_acelp_lspd2lpc(i_lsps, lpcs, s->lsps >> 1);
00972
00973
00974 ff_celp_lp_synthesis_filterf(synth, lpcs, excitation, size, s->lsps);
00975 }
00976
00991 static int synth_frame(AVCodecContext *ctx, GetBitContext *gb,
00992 float *samples,
00993 const double *lsps, const double *prev_lsps,
00994 float *excitation, float *synth)
00995 {
00996 WMAVoiceContext *s = ctx->priv_data;
00997 int n, n_blocks_x2, log_n_blocks_x2, cur_pitch_val;
00998 int pitch[MAX_BLOCKS], last_block_pitch;
00999
01000
01001 int bd_idx = s->vbm_tree[get_vlc2(gb, frame_type_vlc.table, 6, 3)],
01002 block_nsamples = MAX_FRAMESIZE / frame_descs[bd_idx].n_blocks;
01003
01004 if (bd_idx < 0) {
01005 av_log(ctx, AV_LOG_ERROR,
01006 "Invalid frame type VLC code, skipping\n");
01007 return -1;
01008 }
01009
01010
01011 if (frame_descs[bd_idx].acb_type == ACB_TYPE_ASYMMETRIC) {
01012
01013
01014
01015
01016 n_blocks_x2 = frame_descs[bd_idx].n_blocks << 1;
01017 log_n_blocks_x2 = frame_descs[bd_idx].log_n_blocks + 1;
01018 cur_pitch_val = s->min_pitch_val + get_bits(gb, s->pitch_nbits);
01019 cur_pitch_val = FFMIN(cur_pitch_val, s->max_pitch_val - 1);
01020 if (s->last_acb_type == ACB_TYPE_NONE ||
01021 20 * abs(cur_pitch_val - s->last_pitch_val) >
01022 (cur_pitch_val + s->last_pitch_val))
01023 s->last_pitch_val = cur_pitch_val;
01024
01025
01026 for (n = 0; n < frame_descs[bd_idx].n_blocks; n++) {
01027 int fac = n * 2 + 1;
01028
01029 pitch[n] = (MUL16(fac, cur_pitch_val) +
01030 MUL16((n_blocks_x2 - fac), s->last_pitch_val) +
01031 frame_descs[bd_idx].n_blocks) >> log_n_blocks_x2;
01032 }
01033
01034
01035 s->pitch_diff_sh16 =
01036 ((cur_pitch_val - s->last_pitch_val) << 16) / MAX_FRAMESIZE;
01037 }
01038
01039
01040 switch (frame_descs[bd_idx].fcb_type) {
01041 case FCB_TYPE_SILENCE:
01042 s->silence_gain = wmavoice_gain_silence[get_bits(gb, 8)];
01043 break;
01044 case FCB_TYPE_AW_PULSES:
01045 aw_parse_coords(s, gb, pitch);
01046 break;
01047 }
01048
01049 for (n = 0; n < frame_descs[bd_idx].n_blocks; n++) {
01050 int bl_pitch_sh2;
01051
01052
01053 switch (frame_descs[bd_idx].acb_type) {
01054 case ACB_TYPE_HAMMING: {
01055
01056
01057
01058
01059
01060 int block_pitch,
01061 t1 = (s->block_conv_table[1] - s->block_conv_table[0]) << 2,
01062 t2 = (s->block_conv_table[2] - s->block_conv_table[1]) << 1,
01063 t3 = s->block_conv_table[3] - s->block_conv_table[2] + 1;
01064
01065 if (n == 0) {
01066 block_pitch = get_bits(gb, s->block_pitch_nbits);
01067 } else
01068 block_pitch = last_block_pitch - s->block_delta_pitch_hrange +
01069 get_bits(gb, s->block_delta_pitch_nbits);
01070
01071 last_block_pitch = av_clip(block_pitch,
01072 s->block_delta_pitch_hrange,
01073 s->block_pitch_range -
01074 s->block_delta_pitch_hrange);
01075
01076
01077 if (block_pitch < t1) {
01078 bl_pitch_sh2 = (s->block_conv_table[0] << 2) + block_pitch;
01079 } else {
01080 block_pitch -= t1;
01081 if (block_pitch < t2) {
01082 bl_pitch_sh2 =
01083 (s->block_conv_table[1] << 2) + (block_pitch << 1);
01084 } else {
01085 block_pitch -= t2;
01086 if (block_pitch < t3) {
01087 bl_pitch_sh2 =
01088 (s->block_conv_table[2] + block_pitch) << 2;
01089 } else
01090 bl_pitch_sh2 = s->block_conv_table[3] << 2;
01091 }
01092 }
01093 pitch[n] = bl_pitch_sh2 >> 2;
01094 break;
01095 }
01096
01097 case ACB_TYPE_ASYMMETRIC: {
01098 bl_pitch_sh2 = pitch[n] << 2;
01099 break;
01100 }
01101
01102 default:
01103 bl_pitch_sh2 = 0;
01104 break;
01105 }
01106
01107 synth_block(s, gb, n, block_nsamples, bl_pitch_sh2,
01108 lsps, prev_lsps, &frame_descs[bd_idx],
01109 &excitation[n * block_nsamples],
01110 &synth[n * block_nsamples]);
01111 }
01112
01113
01114
01115 if (s->do_apf) {
01116
01117 av_log_missing_feature(ctx, "APF", 0);
01118 s->do_apf = 0;
01119 }
01120 for (n = 0; n < 160; n++)
01121 samples[n] = av_clipf(synth[n], -1.0, 1.0);
01122
01123
01124 s->frame_cntr++;
01125 if (s->frame_cntr >= 0xFFFF) s->frame_cntr -= 0xFFFF;
01126 s->last_acb_type = frame_descs[bd_idx].acb_type;
01127 switch (frame_descs[bd_idx].acb_type) {
01128 case ACB_TYPE_NONE:
01129 s->last_pitch_val = 0;
01130 break;
01131 case ACB_TYPE_ASYMMETRIC:
01132 s->last_pitch_val = cur_pitch_val;
01133 break;
01134 case ACB_TYPE_HAMMING:
01135 s->last_pitch_val = pitch[frame_descs[bd_idx].n_blocks - 1];
01136 break;
01137 }
01138
01139 return 0;
01140 }
01141
01154 static void stabilize_lsps(double *lsps, int num)
01155 {
01156 int n, m, l;
01157
01158
01159
01160
01161 lsps[0] = FFMAX(lsps[0], 0.0015 * M_PI);
01162 for (n = 1; n < num; n++)
01163 lsps[n] = FFMAX(lsps[n], lsps[n - 1] + 0.0125 * M_PI);
01164 lsps[num - 1] = FFMIN(lsps[num - 1], 0.9985 * M_PI);
01165
01166
01167
01168 for (n = 1; n < num; n++) {
01169 if (lsps[n] < lsps[n - 1]) {
01170 for (m = 1; m < num; m++) {
01171 double tmp = lsps[m];
01172 for (l = m - 1; l >= 0; l--) {
01173 if (lsps[l] <= tmp) break;
01174 lsps[l + 1] = lsps[l];
01175 }
01176 lsps[l + 1] = tmp;
01177 }
01178 break;
01179 }
01180 }
01181 }
01182
01192 static int check_bits_for_superframe(GetBitContext *orig_gb,
01193 WMAVoiceContext *s)
01194 {
01195 GetBitContext s_gb, *gb = &s_gb;
01196 int n, need_bits, bd_idx;
01197 const struct frame_type_desc *frame_desc;
01198
01199
01200 init_get_bits(gb, orig_gb->buffer, orig_gb->size_in_bits);
01201 skip_bits_long(gb, get_bits_count(orig_gb));
01202 assert(get_bits_left(gb) == get_bits_left(orig_gb));
01203
01204
01205 if (get_bits_left(gb) < 14)
01206 return 1;
01207 if (!get_bits1(gb))
01208 return -1;
01209 if (get_bits1(gb)) skip_bits(gb, 12);
01210 if (s->has_residual_lsps) {
01211 if (get_bits_left(gb) < s->sframe_lsp_bitsize)
01212 return 1;
01213 skip_bits_long(gb, s->sframe_lsp_bitsize);
01214 }
01215
01216
01217 for (n = 0; n < MAX_FRAMES; n++) {
01218 int aw_idx_is_ext = 0;
01219
01220 if (!s->has_residual_lsps) {
01221 if (get_bits_left(gb) < s->frame_lsp_bitsize) return 1;
01222 skip_bits_long(gb, s->frame_lsp_bitsize);
01223 }
01224 bd_idx = s->vbm_tree[get_vlc2(gb, frame_type_vlc.table, 6, 3)];
01225 if (bd_idx < 0)
01226 return -1;
01227 frame_desc = &frame_descs[bd_idx];
01228 if (frame_desc->acb_type == ACB_TYPE_ASYMMETRIC) {
01229 if (get_bits_left(gb) < s->pitch_nbits)
01230 return 1;
01231 skip_bits_long(gb, s->pitch_nbits);
01232 }
01233 if (frame_desc->fcb_type == FCB_TYPE_SILENCE) {
01234 skip_bits(gb, 8);
01235 } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
01236 int tmp = get_bits(gb, 6);
01237 if (tmp >= 0x36) {
01238 skip_bits(gb, 2);
01239 aw_idx_is_ext = 1;
01240 }
01241 }
01242
01243
01244 if (frame_desc->acb_type == ACB_TYPE_HAMMING) {
01245 need_bits = s->block_pitch_nbits +
01246 (frame_desc->n_blocks - 1) * s->block_delta_pitch_nbits;
01247 } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
01248 need_bits = 2 * !aw_idx_is_ext;
01249 } else
01250 need_bits = 0;
01251 need_bits += frame_desc->frame_size;
01252 if (get_bits_left(gb) < need_bits)
01253 return 1;
01254 skip_bits_long(gb, need_bits);
01255 }
01256
01257 return 0;
01258 }
01259
01280 static int synth_superframe(AVCodecContext *ctx,
01281 float *samples, int *data_size)
01282 {
01283 WMAVoiceContext *s = ctx->priv_data;
01284 GetBitContext *gb = &s->gb, s_gb;
01285 int n, res, n_samples = 480;
01286 double lsps[MAX_FRAMES][MAX_LSPS];
01287 const double *mean_lsf = s->lsps == 16 ?
01288 wmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10[s->lsp_def_mode];
01289 float excitation[MAX_SIGNAL_HISTORY + MAX_SFRAMESIZE + 12];
01290 float synth[MAX_LSPS + MAX_SFRAMESIZE];
01291
01292 memcpy(synth, s->synth_history,
01293 s->lsps * sizeof(*synth));
01294 memcpy(excitation, s->excitation_history,
01295 s->history_nsamples * sizeof(*excitation));
01296
01297 if (s->sframe_cache_size > 0) {
01298 gb = &s_gb;
01299 init_get_bits(gb, s->sframe_cache, s->sframe_cache_size);
01300 s->sframe_cache_size = 0;
01301 }
01302
01303 if ((res = check_bits_for_superframe(gb, s)) == 1) return 1;
01304
01305
01306
01307
01308
01309 if (!get_bits1(gb)) {
01310 av_log_missing_feature(ctx, "WMAPro-in-WMAVoice support", 1);
01311 return -1;
01312 }
01313
01314
01315 if (get_bits1(gb)) {
01316 if ((n_samples = get_bits(gb, 12)) > 480) {
01317 av_log(ctx, AV_LOG_ERROR,
01318 "Superframe encodes >480 samples (%d), not allowed\n",
01319 n_samples);
01320 return -1;
01321 }
01322 }
01323
01324 if (s->has_residual_lsps) {
01325 double prev_lsps[MAX_LSPS], a1[MAX_LSPS * 2], a2[MAX_LSPS * 2];
01326
01327 for (n = 0; n < s->lsps; n++)
01328 prev_lsps[n] = s->prev_lsps[n] - mean_lsf[n];
01329
01330 if (s->lsps == 10) {
01331 dequant_lsp10r(gb, lsps[2], prev_lsps, a1, a2, s->lsp_q_mode);
01332 } else
01333 dequant_lsp16r(gb, lsps[2], prev_lsps, a1, a2, s->lsp_q_mode);
01334
01335 for (n = 0; n < s->lsps; n++) {
01336 lsps[0][n] = mean_lsf[n] + (a1[n] - a2[n * 2]);
01337 lsps[1][n] = mean_lsf[n] + (a1[s->lsps + n] - a2[n * 2 + 1]);
01338 lsps[2][n] += mean_lsf[n];
01339 }
01340 for (n = 0; n < 3; n++)
01341 stabilize_lsps(lsps[n], s->lsps);
01342 }
01343
01344
01345 for (n = 0; n < 3; n++) {
01346 if (!s->has_residual_lsps) {
01347 int m;
01348
01349 if (s->lsps == 10) {
01350 dequant_lsp10i(gb, lsps[n]);
01351 } else
01352 dequant_lsp16i(gb, lsps[n]);
01353
01354 for (m = 0; m < s->lsps; m++)
01355 lsps[n][m] += mean_lsf[m];
01356 stabilize_lsps(lsps[n], s->lsps);
01357 }
01358
01359 if ((res = synth_frame(ctx, gb,
01360 &samples[n * MAX_FRAMESIZE],
01361 lsps[n], n == 0 ? s->prev_lsps : lsps[n - 1],
01362 &excitation[s->history_nsamples + n * MAX_FRAMESIZE],
01363 &synth[s->lsps + n * MAX_FRAMESIZE])))
01364 return res;
01365 }
01366
01367
01368
01369
01370 if (get_bits1(gb)) {
01371 res = get_bits(gb, 4);
01372 skip_bits(gb, 10 * (res + 1));
01373 }
01374
01375
01376 *data_size = n_samples * sizeof(float);
01377
01378
01379 memcpy(s->prev_lsps, lsps[2],
01380 s->lsps * sizeof(*s->prev_lsps));
01381 memcpy(s->synth_history, &synth[MAX_SFRAMESIZE],
01382 s->lsps * sizeof(*synth));
01383 memcpy(s->excitation_history, &excitation[MAX_SFRAMESIZE],
01384 s->history_nsamples * sizeof(*excitation));
01385
01386 return 0;
01387 }
01388
01396 static int parse_packet_header(WMAVoiceContext *s)
01397 {
01398 GetBitContext *gb = &s->gb;
01399 unsigned int res;
01400
01401 if (get_bits_left(gb) < 11)
01402 return 1;
01403 skip_bits(gb, 4);
01404 s->has_residual_lsps = get_bits1(gb);
01405 do {
01406 res = get_bits(gb, 6);
01407
01408 if (get_bits_left(gb) < 6 * (res == 0x3F) + s->spillover_bitsize)
01409 return 1;
01410 } while (res == 0x3F);
01411 s->spillover_nbits = get_bits(gb, s->spillover_bitsize);
01412
01413 return 0;
01414 }
01415
01431 static void copy_bits(PutBitContext *pb,
01432 const uint8_t *data, int size,
01433 GetBitContext *gb, int nbits)
01434 {
01435 int rmn_bytes, rmn_bits;
01436
01437 rmn_bits = rmn_bytes = get_bits_left(gb);
01438 if (rmn_bits < nbits)
01439 return;
01440 rmn_bits &= 7; rmn_bytes >>= 3;
01441 if ((rmn_bits = FFMIN(rmn_bits, nbits)) > 0)
01442 put_bits(pb, rmn_bits, get_bits(gb, rmn_bits));
01443 ff_copy_bits(pb, data + size - rmn_bytes,
01444 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
01445 }
01446
01458 static int wmavoice_decode_packet(AVCodecContext *ctx, void *data,
01459 int *data_size, AVPacket *avpkt)
01460 {
01461 WMAVoiceContext *s = ctx->priv_data;
01462 GetBitContext *gb = &s->gb;
01463 int size, res, pos;
01464
01465 if (*data_size < 480 * sizeof(float)) {
01466 av_log(ctx, AV_LOG_ERROR,
01467 "Output buffer too small (%d given - %lu needed)\n",
01468 *data_size, 480 * sizeof(float));
01469 return -1;
01470 }
01471 *data_size = 0;
01472
01473
01474
01475
01476
01477
01478 for (size = avpkt->size; size > ctx->block_align; size -= ctx->block_align);
01479 if (!size)
01480 return 0;
01481 init_get_bits(&s->gb, avpkt->data, size << 3);
01482
01483
01484
01485
01486 if (size == ctx->block_align) {
01487 if ((res = parse_packet_header(s)) < 0)
01488 return res;
01489
01490
01491
01492
01493 if (s->spillover_nbits > 0) {
01494 if (s->sframe_cache_size > 0) {
01495 int cnt = get_bits_count(gb);
01496 copy_bits(&s->pb, avpkt->data, size, gb, s->spillover_nbits);
01497 flush_put_bits(&s->pb);
01498 s->sframe_cache_size += s->spillover_nbits;
01499 if ((res = synth_superframe(ctx, data, data_size)) == 0 &&
01500 *data_size > 0) {
01501 cnt += s->spillover_nbits;
01502 s->skip_bits_next = cnt & 7;
01503 return cnt >> 3;
01504 } else
01505 skip_bits_long (gb, s->spillover_nbits - cnt +
01506 get_bits_count(gb));
01507 } else
01508 skip_bits_long(gb, s->spillover_nbits);
01509 }
01510 } else if (s->skip_bits_next)
01511 skip_bits(gb, s->skip_bits_next);
01512
01513
01514 s->sframe_cache_size = 0;
01515 s->skip_bits_next = 0;
01516 pos = get_bits_left(gb);
01517 if ((res = synth_superframe(ctx, data, data_size)) < 0) {
01518 return res;
01519 } else if (*data_size > 0) {
01520 int cnt = get_bits_count(gb);
01521 s->skip_bits_next = cnt & 7;
01522 return cnt >> 3;
01523 } else if ((s->sframe_cache_size = pos) > 0) {
01524
01525 init_get_bits(gb, avpkt->data, size << 3);
01526 skip_bits_long(gb, (size << 3) - pos);
01527 assert(get_bits_left(gb) == pos);
01528
01529
01530 init_put_bits(&s->pb, s->sframe_cache, SFRAME_CACHE_MAXSIZE);
01531 copy_bits(&s->pb, avpkt->data, size, gb, s->sframe_cache_size);
01532
01533
01534 }
01535
01536 return size;
01537 }
01538
01539 static av_cold void wmavoice_flush(AVCodecContext *ctx)
01540 {
01541 WMAVoiceContext *s = ctx->priv_data;
01542 int n;
01543
01544 s->sframe_cache_size = 0;
01545 s->skip_bits_next = 0;
01546 for (n = 0; n < s->lsps; n++)
01547 s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
01548 memset(s->excitation_history, 0,
01549 sizeof(*s->excitation_history) * MAX_SIGNAL_HISTORY);
01550 memset(s->synth_history, 0,
01551 sizeof(*s->synth_history) * MAX_LSPS);
01552 memset(s->gain_pred_err, 0,
01553 sizeof(s->gain_pred_err));
01554 }
01555
01556 AVCodec wmavoice_decoder = {
01557 "wmavoice",
01558 AVMEDIA_TYPE_AUDIO,
01559 CODEC_ID_WMAVOICE,
01560 sizeof(WMAVoiceContext),
01561 wmavoice_decode_init,
01562 NULL,
01563 NULL,
01564 wmavoice_decode_packet,
01565 CODEC_CAP_SUBFRAMES,
01566 .flush = wmavoice_flush,
01567 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
01568 };