Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

wma: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/88/head
Gabriel Dume 10 years ago committed by Diego Biurrun
parent c487972ed0
commit d2a4e4b9cc
6 changed files with 1747 additions and 1758 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 225
      libavcodec/wma.c
  2. 29
      libavcodec/wma.h
  3. 21
      libavcodec/wma_common.c
  4. 2566
      libavcodec/wmadata.h
  5. 386
      libavcodec/wmadec.c
  6. 278
      libavcodec/wmaenc.c

225
libavcodec/wma.c
Unescape View File

@ -20,6 +20,7 @@
*/ */
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "avcodec.h" #include "avcodec.h"
#include "sinewin.h" #include "sinewin.h"
#include "wma.h" #include "wma.h"
@ -30,12 +31,12 @@
#include <assert.h> #include <assert.h>
/* XXX: use same run/length optimization as mpeg decoders */ /* XXX: use same run/length optimization as mpeg decoders */
//FIXME maybe split decode / encode or pass flag // FIXME maybe split decode / encode or pass flag
static av_cold void init_coef_vlc(VLC *vlc, uint16_t **prun_table, static av_cold void init_coef_vlc(VLC *vlc, uint16_t **prun_table,
float **plevel_table, uint16_t **pint_table, float **plevel_table, uint16_t **pint_table,
const CoefVLCTable *vlc_table) const CoefVLCTable *vlc_table)
{ {
int n = vlc_table->n; int n = vlc_table->n;
const uint8_t *table_bits = vlc_table->huffbits; const uint8_t *table_bits = vlc_table->huffbits;
const uint32_t *table_codes = vlc_table->huffcodes; const uint32_t *table_codes = vlc_table->huffcodes;
const uint16_t *levels_table = vlc_table->levels; const uint16_t *levels_table = vlc_table->levels;
@ -45,20 +46,20 @@ static av_cold void init_coef_vlc(VLC *vlc, uint16_t **prun_table,
init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0); init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
run_table = av_malloc(n * sizeof(uint16_t)); run_table = av_malloc(n * sizeof(uint16_t));
level_table = av_malloc(n * sizeof(uint16_t)); level_table = av_malloc(n * sizeof(uint16_t));
flevel_table= av_malloc(n * sizeof(*flevel_table)); flevel_table = av_malloc(n * sizeof(*flevel_table));
int_table = av_malloc(n * sizeof(uint16_t)); int_table = av_malloc(n * sizeof(uint16_t));
i = 2; i = 2;
level = 1; level = 1;
k = 0; k = 0;
while (i < n) { while (i < n) {
int_table[k] = i; int_table[k] = i;
l = levels_table[k++]; l = levels_table[k++];
for (j = 0; j < l; j++) { for (j = 0; j < l; j++) {
run_table[i] = j; run_table[i] = j;
level_table[i] = level; level_table[i] = level;
flevel_table[i]= level; flevel_table[i] = level;
i++; i++;
} }
level++; level++;
@ -78,19 +79,18 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
int sample_rate1; int sample_rate1;
int coef_vlc_table; int coef_vlc_table;
if ( avctx->sample_rate <= 0 || avctx->sample_rate > 50000 if (avctx->sample_rate <= 0 || avctx->sample_rate > 50000 ||
|| avctx->channels <= 0 || avctx->channels > 2 avctx->channels <= 0 || avctx->channels > 2 ||
|| avctx->bit_rate <= 0) avctx->bit_rate <= 0)
return -1; return -1;
ff_fmt_convert_init(&s->fmt_conv, avctx); ff_fmt_convert_init(&s->fmt_conv, avctx);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT); avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
if (avctx->codec->id == AV_CODEC_ID_WMAV1) { if (avctx->codec->id == AV_CODEC_ID_WMAV1)
s->version = 1; s->version = 1;
} else { else
s->version = 2; s->version = 2;
}
/* compute MDCT block size */ /* compute MDCT block size */
s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate, s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
@ -109,76 +109,70 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
if (nb > nb_max) if (nb > nb_max)
nb = nb_max; nb = nb_max;
s->nb_block_sizes = nb + 1; s->nb_block_sizes = nb + 1;
} else { } else
s->nb_block_sizes = 1; s->nb_block_sizes = 1;
}
/* init rate dependent parameters */ /* init rate dependent parameters */
s->use_noise_coding = 1; s->use_noise_coding = 1;
high_freq = avctx->sample_rate * 0.5; high_freq = avctx->sample_rate * 0.5;
/* if version 2, then the rates are normalized */ /* if version 2, then the rates are normalized */
sample_rate1 = avctx->sample_rate; sample_rate1 = avctx->sample_rate;
if (s->version == 2) { if (s->version == 2) {
if (sample_rate1 >= 44100) { if (sample_rate1 >= 44100)
sample_rate1 = 44100; sample_rate1 = 44100;
} else if (sample_rate1 >= 22050) { else if (sample_rate1 >= 22050)
sample_rate1 = 22050; sample_rate1 = 22050;
} else if (sample_rate1 >= 16000) { else if (sample_rate1 >= 16000)
sample_rate1 = 16000; sample_rate1 = 16000;
} else if (sample_rate1 >= 11025) { else if (sample_rate1 >= 11025)
sample_rate1 = 11025; sample_rate1 = 11025;
} else if (sample_rate1 >= 8000) { else if (sample_rate1 >= 8000)
sample_rate1 = 8000; sample_rate1 = 8000;
}
} }
bps = (float)avctx->bit_rate / (float)(avctx->channels * avctx->sample_rate); bps = (float) avctx->bit_rate /
s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2; (float) (avctx->channels * avctx->sample_rate);
s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
/* compute high frequency value and choose if noise coding should /* compute high frequency value and choose if noise coding should
be activated */ * be activated */
bps1 = bps; bps1 = bps;
if (avctx->channels == 2) if (avctx->channels == 2)
bps1 = bps * 1.6; bps1 = bps * 1.6;
if (sample_rate1 == 44100) { if (sample_rate1 == 44100) {
if (bps1 >= 0.61) { if (bps1 >= 0.61)
s->use_noise_coding = 0; s->use_noise_coding = 0;
} else { else
high_freq = high_freq * 0.4; high_freq = high_freq * 0.4;
}
} else if (sample_rate1 == 22050) { } else if (sample_rate1 == 22050) {
if (bps1 >= 1.16) { if (bps1 >= 1.16)
s->use_noise_coding = 0; s->use_noise_coding = 0;
} else if (bps1 >= 0.72) { else if (bps1 >= 0.72)
high_freq = high_freq * 0.7; high_freq = high_freq * 0.7;
} else { else
high_freq = high_freq * 0.6; high_freq = high_freq * 0.6;
}
} else if (sample_rate1 == 16000) { } else if (sample_rate1 == 16000) {
if (bps > 0.5) { if (bps > 0.5)
high_freq = high_freq * 0.5; high_freq = high_freq * 0.5;
} else { else
high_freq = high_freq * 0.3; high_freq = high_freq * 0.3;
} } else if (sample_rate1 == 11025)
} else if (sample_rate1 == 11025) {
high_freq = high_freq * 0.7; high_freq = high_freq * 0.7;
} else if (sample_rate1 == 8000) { else if (sample_rate1 == 8000) {
if (bps <= 0.625) { if (bps <= 0.625)
high_freq = high_freq * 0.5; high_freq = high_freq * 0.5;
} else if (bps > 0.75) { else if (bps > 0.75)
s->use_noise_coding = 0; s->use_noise_coding = 0;
} else { else
high_freq = high_freq * 0.65; high_freq = high_freq * 0.65;
}
} else { } else {
if (bps >= 0.8) { if (bps >= 0.8)
high_freq = high_freq * 0.75; high_freq = high_freq * 0.75;
} else if (bps >= 0.6) { else if (bps >= 0.6)
high_freq = high_freq * 0.6; high_freq = high_freq * 0.6;
} else { else
high_freq = high_freq * 0.5; high_freq = high_freq * 0.5;
}
} }
av_dlog(s->avctx, "flags2=0x%x\n", flags2); av_dlog(s->avctx, "flags2=0x%x\n", flags2);
av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n", av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
@ -194,19 +188,18 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
int a, b, pos, lpos, k, block_len, i, j, n; int a, b, pos, lpos, k, block_len, i, j, n;
const uint8_t *table; const uint8_t *table;
if (s->version == 1) { if (s->version == 1)
s->coefs_start = 3; s->coefs_start = 3;
} else { else
s->coefs_start = 0; s->coefs_start = 0;
}
for (k = 0; k < s->nb_block_sizes; k++) { for (k = 0; k < s->nb_block_sizes; k++) {
block_len = s->frame_len >> k; block_len = s->frame_len >> k;
if (s->version == 1) { if (s->version == 1) {
lpos = 0; lpos = 0;
for (i = 0; i < 25; i++) { for (i = 0; i < 25; i++) {
a = ff_wma_critical_freqs[i]; a = ff_wma_critical_freqs[i];
b = avctx->sample_rate; b = avctx->sample_rate;
pos = ((block_len * 2 * a) + (b >> 1)) / b; pos = ((block_len * 2 * a) + (b >> 1)) / b;
if (pos > block_len) if (pos > block_len)
pos = block_len; pos = block_len;
@ -221,15 +214,14 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
} else { } else {
/* hardcoded tables */ /* hardcoded tables */
table = NULL; table = NULL;
a = s->frame_len_bits - BLOCK_MIN_BITS - k; a = s->frame_len_bits - BLOCK_MIN_BITS - k;
if (a < 3) { if (a < 3) {
if (avctx->sample_rate >= 44100) { if (avctx->sample_rate >= 44100)
table = exponent_band_44100[a]; table = exponent_band_44100[a];
} else if (avctx->sample_rate >= 32000) { else if (avctx->sample_rate >= 32000)
table = exponent_band_32000[a]; table = exponent_band_32000[a];
} else if (avctx->sample_rate >= 22050) { else if (avctx->sample_rate >= 22050)
table = exponent_band_22050[a]; table = exponent_band_22050[a];
}
} }
if (table) { if (table) {
n = *table++; n = *table++;
@ -237,12 +229,12 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
s->exponent_bands[k][i] = table[i]; s->exponent_bands[k][i] = table[i];
s->exponent_sizes[k] = n; s->exponent_sizes[k] = n;
} else { } else {
j = 0; j = 0;
lpos = 0; lpos = 0;
for (i = 0; i < 25; i++) { for (i = 0; i < 25; i++) {
a = ff_wma_critical_freqs[i]; a = ff_wma_critical_freqs[i];
b = avctx->sample_rate; b = avctx->sample_rate;
pos = ((block_len * 2 * a) + (b << 1)) / (4 * b); pos = ((block_len * 2 * a) + (b << 1)) / (4 * b);
pos <<= 2; pos <<= 2;
if (pos > block_len) if (pos > block_len)
pos = block_len; pos = block_len;
@ -259,16 +251,16 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
/* max number of coefs */ /* max number of coefs */
s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k; s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
/* high freq computation */ /* high freq computation */
s->high_band_start[k] = (int)((block_len * 2 * high_freq) / s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /
avctx->sample_rate + 0.5); avctx->sample_rate + 0.5);
n = s->exponent_sizes[k]; n = s->exponent_sizes[k];
j = 0; j = 0;
pos = 0; pos = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
int start, end; int start, end;
start = pos; start = pos;
pos += s->exponent_bands[k][i]; pos += s->exponent_bands[k][i];
end = pos; end = pos;
if (start < s->high_band_start[k]) if (start < s->high_band_start[k])
start = s->high_band_start[k]; start = s->high_band_start[k];
if (end > s->coefs_end[k]) if (end > s->coefs_end[k])
@ -286,7 +278,7 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
for (j = 0; j < s->exponent_high_sizes[k]; j++) for (j = 0; j < s->exponent_high_sizes[k]; j++)
tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]); tprintf(s->avctx, " %d", s->exponent_high_bands[k][j]);
tprintf(s->avctx, "\n"); tprintf(s->avctx, "\n");
#endif #endif /* 0 */
} }
} }
@ -302,7 +294,7 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
tprintf(s->avctx, "\n"); tprintf(s->avctx, "\n");
} }
} }
#endif #endif /* TRACE */
/* init MDCT windows : simple sine window */ /* init MDCT windows : simple sine window */
for (i = 0; i < s->nb_block_sizes; i++) { for (i = 0; i < s->nb_block_sizes; i++) {
@ -313,13 +305,11 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
s->reset_block_lengths = 1; s->reset_block_lengths = 1;
if (s->use_noise_coding) { if (s->use_noise_coding) {
/* init the noise generator */ /* init the noise generator */
if (s->use_exp_vlc) { if (s->use_exp_vlc)
s->noise_mult = 0.02; s->noise_mult = 0.02;
} else { else
s->noise_mult = 0.04; s->noise_mult = 0.04;
}
#ifdef TRACE #ifdef TRACE
for (i = 0; i < NOISE_TAB_SIZE; i++) for (i = 0; i < NOISE_TAB_SIZE; i++)
@ -329,41 +319,45 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
unsigned int seed; unsigned int seed;
float norm; float norm;
seed = 1; seed = 1;
norm = (1.0 / (float)(1LL << 31)) * sqrt(3) * s->noise_mult; norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;
for (i = 0; i < NOISE_TAB_SIZE; i++) { for (i = 0; i < NOISE_TAB_SIZE; i++) {
seed = seed * 314159 + 1; seed = seed * 314159 + 1;
s->noise_table[i] = (float)((int)seed) * norm; s->noise_table[i] = (float) ((int) seed) * norm;
} }
} }
#endif #endif /* TRACE */
} }
/* choose the VLC tables for the coefficients */ /* choose the VLC tables for the coefficients */
coef_vlc_table = 2; coef_vlc_table = 2;
if (avctx->sample_rate >= 32000) { if (avctx->sample_rate >= 32000) {
if (bps1 < 0.72) { if (bps1 < 0.72)
coef_vlc_table = 0; coef_vlc_table = 0;
} else if (bps1 < 1.16) { else if (bps1 < 1.16)
coef_vlc_table = 1; coef_vlc_table = 1;
}
} }
s->coef_vlcs[0]= &coef_vlcs[coef_vlc_table * 2 ]; s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
s->coef_vlcs[1]= &coef_vlcs[coef_vlc_table * 2 + 1]; s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0], &s->int_table[0], init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
s->coef_vlcs[0]); &s->int_table[0], s->coef_vlcs[0]);
init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1], &s->int_table[1], init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
s->coef_vlcs[1]); &s->int_table[1], s->coef_vlcs[1]);
return 0; return 0;
} }
int ff_wma_total_gain_to_bits(int total_gain) int ff_wma_total_gain_to_bits(int total_gain)
{ {
if (total_gain < 15) return 13; if (total_gain < 15)
else if (total_gain < 32) return 12; return 13;
else if (total_gain < 40) return 11; else if (total_gain < 32)
else if (total_gain < 45) return 10; return 12;
else return 9; else if (total_gain < 40)
return 11;
else if (total_gain < 45)
return 10;
else
return 9;
} }
int ff_wma_end(AVCodecContext *avctx) int ff_wma_end(AVCodecContext *avctx)
@ -374,12 +368,10 @@ int ff_wma_end(AVCodecContext *avctx)
for (i = 0; i < s->nb_block_sizes; i++) for (i = 0; i < s->nb_block_sizes; i++)
ff_mdct_end(&s->mdct_ctx[i]); ff_mdct_end(&s->mdct_ctx[i]);
if (s->use_exp_vlc) { if (s->use_exp_vlc)
ff_free_vlc(&s->exp_vlc); ff_free_vlc(&s->exp_vlc);
} if (s->use_noise_coding)
if (s->use_noise_coding) {
ff_free_vlc(&s->hgain_vlc); ff_free_vlc(&s->hgain_vlc);
}
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
ff_free_vlc(&s->coef_vlc[i]); ff_free_vlc(&s->coef_vlc[i]);
av_free(s->run_table[i]); av_free(s->run_table[i]);
@ -395,7 +387,7 @@ int ff_wma_end(AVCodecContext *avctx)
* @param gb GetBitContext * @param gb GetBitContext
* @return the decoded coefficient * @return the decoded coefficient
*/ */
unsigned int ff_wma_get_large_val(GetBitContext* gb) unsigned int ff_wma_get_large_val(GetBitContext *gb)
{ {
/** consumes up to 34 bits */ /** consumes up to 34 bits */
int n_bits = 8; int n_bits = 8;
@ -404,9 +396,8 @@ unsigned int ff_wma_get_large_val(GetBitContext* gb)
n_bits += 8; n_bits += 8;
if (get_bits1(gb)) { if (get_bits1(gb)) {
n_bits += 8; n_bits += 8;
if (get_bits1(gb)) { if (get_bits1(gb))
n_bits += 7; n_bits += 7;
}
} }
} }
return get_bits_long(gb, n_bits); return get_bits_long(gb, n_bits);
@ -428,24 +419,24 @@ unsigned int ff_wma_get_large_val(GetBitContext* gb)
* @param coef_nb_bits number of bits for escaped level codes * @param coef_nb_bits number of bits for escaped level codes
* @return 0 on success, -1 otherwise * @return 0 on success, -1 otherwise
*/ */
int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb,
VLC *vlc, VLC *vlc, const float *level_table,
const float *level_table, const uint16_t *run_table, const uint16_t *run_table, int version,
int version, WMACoef *ptr, int offset, WMACoef *ptr, int offset, int num_coefs,
int num_coefs, int block_len, int frame_len_bits, int block_len, int frame_len_bits,
int coef_nb_bits) int coef_nb_bits)
{ {
int code, level, sign; int code, level, sign;
const uint32_t *ilvl = (const uint32_t*)level_table; const uint32_t *ilvl = (const uint32_t *) level_table;
uint32_t *iptr = (uint32_t*)ptr; uint32_t *iptr = (uint32_t *) ptr;
const unsigned int coef_mask = block_len - 1; const unsigned int coef_mask = block_len - 1;
for (; offset < num_coefs; offset++) { for (; offset < num_coefs; offset++) {
code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX); code = get_vlc2(gb, vlc->table, VLCBITS, VLCMAX);
if (code > 1) { if (code > 1) {
/** normal code */ /** normal code */
offset += run_table[code]; offset += run_table[code];
sign = get_bits1(gb) - 1; sign = get_bits1(gb) - 1;
iptr[offset & coef_mask] = ilvl[code] ^ sign<<31; iptr[offset & coef_mask] = ilvl[code] ^ sign << 31;
} else if (code == 1) { } else if (code == 1) {
/** EOB */ /** EOB */
break; break;
@ -454,7 +445,7 @@ int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb,
if (!version) { if (!version) {
level = get_bits(gb, coef_nb_bits); level = get_bits(gb, coef_nb_bits);
/** NOTE: this is rather suboptimal. reading /** NOTE: this is rather suboptimal. reading
block_len_bits would be better */ * block_len_bits would be better */
offset += get_bits(gb, frame_len_bits); offset += get_bits(gb, frame_len_bits);
} else { } else {
level = ff_wma_get_large_val(gb); level = ff_wma_get_large_val(gb);
@ -462,8 +453,8 @@ int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb,
if (get_bits1(gb)) { if (get_bits1(gb)) {
if (get_bits1(gb)) { if (get_bits1(gb)) {
if (get_bits1(gb)) { if (get_bits1(gb)) {
av_log(avctx,AV_LOG_ERROR, av_log(avctx, AV_LOG_ERROR,
"broken escape sequence\n"); "broken escape sequence\n");
return -1; return -1;
} else } else
offset += get_bits(gb, frame_len_bits) + 4; offset += get_bits(gb, frame_len_bits) + 4;
@ -471,8 +462,8 @@ int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb,
offset += get_bits(gb, 2) + 1; offset += get_bits(gb, 2) + 1;
} }
} }
sign = get_bits1(gb) - 1; sign = get_bits1(gb) - 1;
ptr[offset & coef_mask] = (level^sign) - sign; ptr[offset & coef_mask] = (level ^ sign) - sign;
} }
} }
/** NOTE: EOB can be omitted */ /** NOTE: EOB can be omitted */

29
libavcodec/wma.h
Unescape View File

@ -23,10 +23,11 @@
#define AVCODEC_WMA_H #define AVCODEC_WMA_H
#include "libavutil/float_dsp.h" #include "libavutil/float_dsp.h"
#include "get_bits.h"
#include "put_bits.h"
#include "fft.h" #include "fft.h"
#include "fmtconvert.h" #include "fmtconvert.h"
#include "get_bits.h"
#include "put_bits.h"
/* size of blocks */ /* size of blocks */
#define BLOCK_MIN_BITS 7 #define BLOCK_MIN_BITS 7
@ -49,9 +50,9 @@
#define LSP_POW_BITS 7 #define LSP_POW_BITS 7
//FIXME should be in wmadec // FIXME should be in wmadec
#define VLCBITS 9 #define VLCBITS 9
#define VLCMAX ((22+VLCBITS-1)/VLCBITS) #define VLCMAX ((22 + VLCBITS - 1) / VLCBITS)
typedef float WMACoef; ///< type for decoded coefficients, int16_t would be enough for wma 1/2 typedef float WMACoef; ///< type for decoded coefficients, int16_t would be enough for wma 1/2
@ -64,7 +65,7 @@ typedef struct CoefVLCTable {
} CoefVLCTable; } CoefVLCTable;
typedef struct WMACodecContext { typedef struct WMACodecContext {
AVCodecContext* avctx; AVCodecContext *avctx;
GetBitContext gb; GetBitContext gb;
PutBitContext pb; PutBitContext pb;
int version; ///< 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2) int version; ///< 1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2)
@ -88,7 +89,7 @@ typedef struct WMACodecContext {
int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]; int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
/* there are two possible tables for spectral coefficients */ /* there are two possible tables for spectral coefficients */
//FIXME the following 3 tables should be shared between decoders // FIXME the following 3 tables should be shared between decoders
VLC coef_vlc[2]; VLC coef_vlc[2];
uint16_t *run_table[2]; uint16_t *run_table[2];
float *level_table[2]; float *level_table[2];
@ -135,7 +136,7 @@ typedef struct WMACodecContext {
#ifdef TRACE #ifdef TRACE
int frame_count; int frame_count;
#endif #endif /* TRACE */
} WMACodecContext; } WMACodecContext;
extern const uint16_t ff_wma_critical_freqs[25]; extern const uint16_t ff_wma_critical_freqs[25];
@ -145,15 +146,15 @@ extern const float ff_wma_lsp_codebook[NB_LSP_COEFS][16];
extern const uint32_t ff_aac_scalefactor_code[121]; extern const uint32_t ff_aac_scalefactor_code[121];
extern const uint8_t ff_aac_scalefactor_bits[121]; extern const uint8_t ff_aac_scalefactor_bits[121];
int ff_wma_init(AVCodecContext * avctx, int flags2); int ff_wma_init(AVCodecContext *avctx, int flags2);
int ff_wma_total_gain_to_bits(int total_gain); int ff_wma_total_gain_to_bits(int total_gain);
int ff_wma_end(AVCodecContext *avctx); int ff_wma_end(AVCodecContext *avctx);
unsigned int ff_wma_get_large_val(GetBitContext* gb); unsigned int ff_wma_get_large_val(GetBitContext *gb);
int ff_wma_run_level_decode(AVCodecContext* avctx, GetBitContext* gb, int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb,
VLC *vlc, VLC *vlc, const float *level_table,
const float *level_table, const uint16_t *run_table, const uint16_t *run_table, int version,
int version, WMACoef *ptr, int offset, WMACoef *ptr, int offset, int num_coefs,
int num_coefs, int block_len, int frame_len_bits, int block_len, int frame_len_bits,
int coef_nb_bits); int coef_nb_bits);
#endif /* AVCODEC_WMA_H */ #endif /* AVCODEC_WMA_H */

21
libavcodec/wma_common.c
Unescape View File

@ -19,6 +19,7 @@
*/ */
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "wma_common.h" #include "wma_common.h"
/** /**
@ -31,31 +32,27 @@
av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version, av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version,
unsigned int decode_flags) unsigned int decode_flags)
{ {
int frame_len_bits; int frame_len_bits;
if (sample_rate <= 16000) { if (sample_rate <= 16000)
frame_len_bits = 9; frame_len_bits = 9;
} else if (sample_rate <= 22050 || else if (sample_rate <= 22050 || (sample_rate <= 32000 && version == 1))
(sample_rate <= 32000 && version == 1)) {
frame_len_bits = 10; frame_len_bits = 10;
} else if (sample_rate <= 48000 || version < 3) { else if (sample_rate <= 48000 || version < 3)
frame_len_bits = 11; frame_len_bits = 11;
} else if (sample_rate <= 96000) { else if (sample_rate <= 96000)
frame_len_bits = 12; frame_len_bits = 12;
} else { else
frame_len_bits = 13; frame_len_bits = 13;
}
if (version == 3) { if (version == 3) {
int tmp = decode_flags & 0x6; int tmp = decode_flags & 0x6;
if (tmp == 0x2) { if (tmp == 0x2)
++frame_len_bits; ++frame_len_bits;
} else if (tmp == 0x4) { else if (tmp == 0x4)
--frame_len_bits; --frame_len_bits;
} else if (tmp == 0x6) { else if (tmp == 0x6)
frame_len_bits -= 2; frame_len_bits -= 2;
}
} }
return frame_len_bits; return frame_len_bits;

2566
libavcodec/wmadata.h
View File

File diff suppressed because it is too large Load Diff

386
libavcodec/wmadec.c
Unescape View File

@ -34,6 +34,7 @@
*/ */
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "avcodec.h" #include "avcodec.h"
#include "internal.h" #include "internal.h"
#include "wma.h" #include "wma.h"
@ -42,20 +43,21 @@
#include <assert.h> #include <assert.h>
#define EXPVLCBITS 8 #define EXPVLCBITS 8
#define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS) #define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
#define HGAINVLCBITS 9 #define HGAINVLCBITS 9
#define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS) #define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len); static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
#ifdef TRACE #ifdef TRACE
static void dump_floats(WMACodecContext *s, const char *name, int prec, const float *tab, int n) static void dump_floats(WMACodecContext *s, const char *name,
int prec, const float *tab, int n)
{ {
int i; int i;
tprintf(s->avctx, "%s[%d]:\n", name, n); tprintf(s->avctx, "%s[%d]:\n", name, n);
for(i=0;i<n;i++) { for (i = 0; i < n; i++) {
if ((i & 7) == 0) if ((i & 7) == 0)
tprintf(s->avctx, "%4d: ", i); tprintf(s->avctx, "%4d: ", i);
tprintf(s->avctx, " %8.*f", prec, tab[i]); tprintf(s->avctx, " %8.*f", prec, tab[i]);
@ -65,9 +67,9 @@ static void dump_floats(WMACodecContext *s, const char *name, int prec, const fl
if ((i & 7) != 0) if ((i & 7) != 0)
tprintf(s->avctx, "\n"); tprintf(s->avctx, "\n");
} }
#endif #endif /* TRACE */
static av_cold int wma_decode_init(AVCodecContext * avctx) static av_cold int wma_decode_init(AVCodecContext *avctx)
{ {
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
int i, flags2; int i, flags2;
@ -81,23 +83,22 @@ static av_cold int wma_decode_init(AVCodecContext * avctx)
s->avctx = avctx; s->avctx = avctx;
/* extract flag infos */ /* extract flag infos */
flags2 = 0; flags2 = 0;
extradata = avctx->extradata; extradata = avctx->extradata;
if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4) { if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)
flags2 = AV_RL16(extradata+2); flags2 = AV_RL16(extradata + 2);
} else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6) { else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)
flags2 = AV_RL16(extradata+4); flags2 = AV_RL16(extradata + 4);
}
s->use_exp_vlc = flags2 & 0x0001; s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002; s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004; s->use_variable_block_len = flags2 & 0x0004;
if(ff_wma_init(avctx, flags2)<0) if (ff_wma_init(avctx, flags2) < 0)
return -1; return -1;
/* init MDCT */ /* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++) for (i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0 / 32768.0); ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0 / 32768.0);
if (s->use_noise_coding) { if (s->use_noise_coding) {
@ -106,13 +107,12 @@ static av_cold int wma_decode_init(AVCodecContext * avctx)
ff_wma_hgain_huffcodes, 2, 2, 0); ff_wma_hgain_huffcodes, 2, 2, 0);
} }
if (s->use_exp_vlc) { if (s->use_exp_vlc)
init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits), //FIXME move out of context init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits), // FIXME move out of context
ff_aac_scalefactor_bits, 1, 1, ff_aac_scalefactor_bits, 1, 1,
ff_aac_scalefactor_code, 4, 4, 0); ff_aac_scalefactor_code, 4, 4, 0);
} else { else
wma_lsp_to_curve_init(s, s->frame_len); wma_lsp_to_curve_init(s, s->frame_len);
}
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
@ -135,12 +135,12 @@ static inline float pow_m1_4(WMACodecContext *s, float x)
float a, b; float a, b;
u.f = x; u.f = x;
e = u.v >> 23; e = u.v >> 23;
m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1); m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
/* build interpolation scale: 1 <= t < 2. */ /* build interpolation scale: 1 <= t < 2. */
t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23); t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
a = s->lsp_pow_m_table1[m]; a = s->lsp_pow_m_table1[m];
b = s->lsp_pow_m_table2[m]; b = s->lsp_pow_m_table2[m];
return s->lsp_pow_e_table[e] * (a + b * t.f); return s->lsp_pow_e_table[e] * (a + b * t.f);
} }
@ -150,25 +150,25 @@ static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
int i, e, m; int i, e, m;
wdel = M_PI / frame_len; wdel = M_PI / frame_len;
for(i=0;i<frame_len;i++) for (i = 0; i < frame_len; i++)
s->lsp_cos_table[i] = 2.0f * cos(wdel * i); s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
/* tables for x^-0.25 computation */ /* tables for x^-0.25 computation */
for(i=0;i<256;i++) { for (i = 0; i < 256; i++) {
e = i - 126; e = i - 126;
s->lsp_pow_e_table[i] = pow(2.0, e * -0.25); s->lsp_pow_e_table[i] = pow(2.0, e * -0.25);
} }
/* NOTE: these two tables are needed to avoid two operations in /* NOTE: these two tables are needed to avoid two operations in
pow_m1_4 */ * pow_m1_4 */
b = 1.0; b = 1.0;
for(i=(1 << LSP_POW_BITS) - 1;i>=0;i--) { for (i = (1 << LSP_POW_BITS) - 1; i >= 0; i--) {
m = (1 << LSP_POW_BITS) + i; m = (1 << LSP_POW_BITS) + i;
a = (float)m * (0.5 / (1 << LSP_POW_BITS)); a = (float) m * (0.5 / (1 << LSP_POW_BITS));
a = pow(a, -0.25); a = pow(a, -0.25);
s->lsp_pow_m_table1[i] = 2 * a - b; s->lsp_pow_m_table1[i] = 2 * a - b;
s->lsp_pow_m_table2[i] = b - a; s->lsp_pow_m_table2[i] = b - a;
b = a; b = a;
} }
} }
@ -176,26 +176,25 @@ static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
* NOTE: We use the same code as Vorbis here * NOTE: We use the same code as Vorbis here
* @todo optimize it further with SSE/3Dnow * @todo optimize it further with SSE/3Dnow
*/ */
static void wma_lsp_to_curve(WMACodecContext *s, static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr,
float *out, float *val_max_ptr,
int n, float *lsp) int n, float *lsp)
{ {
int i, j; int i, j;
float p, q, w, v, val_max; float p, q, w, v, val_max;
val_max = 0; val_max = 0;
for(i=0;i<n;i++) { for (i = 0; i < n; i++) {
p = 0.5f; p = 0.5f;
q = 0.5f; q = 0.5f;
w = s->lsp_cos_table[i]; w = s->lsp_cos_table[i];
for(j=1;j<NB_LSP_COEFS;j+=2){ for (j = 1; j < NB_LSP_COEFS; j += 2) {
q *= w - lsp[j - 1]; q *= w - lsp[j - 1];
p *= w - lsp[j]; p *= w - lsp[j];
} }
p *= p * (2.0f - w); p *= p * (2.0f - w);
q *= q * (2.0f + w); q *= q * (2.0f + w);
v = p + q; v = p + q;
v = pow_m1_4(s, v); v = pow_m1_4(s, v);
if (v > val_max) if (v > val_max)
val_max = v; val_max = v;
out[i] = v; out[i] = v;
@ -211,7 +210,7 @@ static void decode_exp_lsp(WMACodecContext *s, int ch)
float lsp_coefs[NB_LSP_COEFS]; float lsp_coefs[NB_LSP_COEFS];
int val, i; int val, i;
for(i = 0; i < NB_LSP_COEFS; i++) { for (i = 0; i < NB_LSP_COEFS; i++) {
if (i == 0 || i >= 8) if (i == 0 || i >= 8)
val = get_bits(&s->gb, 3); val = get_bits(&s->gb, 3);
else else
@ -315,41 +314,41 @@ static int decode_exp_vlc(WMACodecContext *s, int ch)
float v, max_scale; float v, max_scale;
uint32_t *q, *q_end, iv; uint32_t *q, *q_end, iv;
const float *ptab = pow_tab + 60; const float *ptab = pow_tab + 60;
const uint32_t *iptab = (const uint32_t*)ptab; const uint32_t *iptab = (const uint32_t *) ptab;
ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
q = (uint32_t *)s->exponents[ch]; q = (uint32_t *) s->exponents[ch];
q_end = q + s->block_len; q_end = q + s->block_len;
max_scale = 0; max_scale = 0;
if (s->version == 1) { if (s->version == 1) {
last_exp = get_bits(&s->gb, 5) + 10; last_exp = get_bits(&s->gb, 5) + 10;
v = ptab[last_exp]; v = ptab[last_exp];
iv = iptab[last_exp]; iv = iptab[last_exp];
max_scale = v; max_scale = v;
n = *ptr++; n = *ptr++;
switch (n & 3) do { switch (n & 3) do {
case 0: *q++ = iv; case 0: *q++ = iv;
case 3: *q++ = iv; case 3: *q++ = iv;
case 2: *q++ = iv; case 2: *q++ = iv;
case 1: *q++ = iv; case 1: *q++ = iv;
} while ((n -= 4) > 0); } while ((n -= 4) > 0);
}else } else
last_exp = 36; last_exp = 36;
while (q < q_end) { while (q < q_end) {
code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX); code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
if (code < 0){ if (code < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Exponent vlc invalid\n"); av_log(s->avctx, AV_LOG_ERROR, "Exponent vlc invalid\n");
return -1; return -1;
} }
/* NOTE: this offset is the same as MPEG4 AAC ! */ /* NOTE: this offset is the same as MPEG4 AAC ! */
last_exp += code - 60; last_exp += code - 60;
if ((unsigned)last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) { if ((unsigned) last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) {
av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n", av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",
last_exp); last_exp);
return -1; return -1;
} }
v = ptab[last_exp]; v = ptab[last_exp];
iv = iptab[last_exp]; iv = iptab[last_exp];
if (v > max_scale) if (v > max_scale)
max_scale = v; max_scale = v;
@ -365,7 +364,6 @@ static int decode_exp_vlc(WMACodecContext *s, int ch)
return 0; return 0;
} }
/** /**
* Apply MDCT window and add into output. * Apply MDCT window and add into output.
* *
@ -380,46 +378,44 @@ static void wma_window(WMACodecContext *s, float *out)
/* left part */ /* left part */
if (s->block_len_bits <= s->prev_block_len_bits) { if (s->block_len_bits <= s->prev_block_len_bits) {
block_len = s->block_len; block_len = s->block_len;
bsize = s->frame_len_bits - s->block_len_bits; bsize = s->frame_len_bits - s->block_len_bits;
s->fdsp.vector_fmul_add(out, in, s->windows[bsize], s->fdsp.vector_fmul_add(out, in, s->windows[bsize],
out, block_len); out, block_len);
} else { } else {
block_len = 1 << s->prev_block_len_bits; block_len = 1 << s->prev_block_len_bits;
n = (s->block_len - block_len) / 2; n = (s->block_len - block_len) / 2;
bsize = s->frame_len_bits - s->prev_block_len_bits; bsize = s->frame_len_bits - s->prev_block_len_bits;
s->fdsp.vector_fmul_add(out+n, in+n, s->windows[bsize], s->fdsp.vector_fmul_add(out + n, in + n, s->windows[bsize],
out+n, block_len); out + n, block_len);
memcpy(out+n+block_len, in+n+block_len, n*sizeof(float)); memcpy(out + n + block_len, in + n + block_len, n * sizeof(float));
} }
out += s->block_len; out += s->block_len;
in += s->block_len; in += s->block_len;
/* right part */ /* right part */
if (s->block_len_bits <= s->next_block_len_bits) { if (s->block_len_bits <= s->next_block_len_bits) {
block_len = s->block_len; block_len = s->block_len;
bsize = s->frame_len_bits - s->block_len_bits; bsize = s->frame_len_bits - s->block_len_bits;
s->fdsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len); s->fdsp.vector_fmul_reverse(out, in, s->windows[bsize], block_len);
} else { } else {
block_len = 1 << s->next_block_len_bits; block_len = 1 << s->next_block_len_bits;
n = (s->block_len - block_len) / 2; n = (s->block_len - block_len) / 2;
bsize = s->frame_len_bits - s->next_block_len_bits; bsize = s->frame_len_bits - s->next_block_len_bits;
memcpy(out, in, n*sizeof(float)); memcpy(out, in, n * sizeof(float));
s->fdsp.vector_fmul_reverse(out+n, in+n, s->windows[bsize], block_len); s->fdsp.vector_fmul_reverse(out + n, in + n, s->windows[bsize],
block_len);
memset(out+n+block_len, 0, n*sizeof(float)); memset(out + n + block_len, 0, n * sizeof(float));
} }
} }
/** /**
* @return 0 if OK. 1 if last block of frame. return -1 if * @return 0 if OK. 1 if last block of frame. return -1 if
* unrecorrable error. * unrecorrable error.
@ -433,8 +429,9 @@ static int wma_decode_block(WMACodecContext *s)
FFTContext *mdct; FFTContext *mdct;
#ifdef TRACE #ifdef TRACE
tprintf(s->avctx, "***decode_block: %d:%d\n", s->frame_count - 1, s->block_num); tprintf(s->avctx, "***decode_block: %d:%d\n",
#endif s->frame_count - 1, s->block_num);
#endif /* TRACE */
/* compute current block length */ /* compute current block length */
if (s->use_variable_block_len) { if (s->use_variable_block_len) {
@ -442,26 +439,32 @@ static int wma_decode_block(WMACodecContext *s)
if (s->reset_block_lengths) { if (s->reset_block_lengths) {
s->reset_block_lengths = 0; s->reset_block_lengths = 0;
v = get_bits(&s->gb, n); v = get_bits(&s->gb, n);
if (v >= s->nb_block_sizes){ if (v >= s->nb_block_sizes) {
av_log(s->avctx, AV_LOG_ERROR, "prev_block_len_bits %d out of range\n", s->frame_len_bits - v); av_log(s->avctx, AV_LOG_ERROR,
"prev_block_len_bits %d out of range\n",
s->frame_len_bits - v);
return -1; return -1;
} }
s->prev_block_len_bits = s->frame_len_bits - v; s->prev_block_len_bits = s->frame_len_bits - v;
v = get_bits(&s->gb, n); v = get_bits(&s->gb, n);
if (v >= s->nb_block_sizes){ if (v >= s->nb_block_sizes) {
av_log(s->avctx, AV_LOG_ERROR, "block_len_bits %d out of range\n", s->frame_len_bits - v); av_log(s->avctx, AV_LOG_ERROR,
"block_len_bits %d out of range\n",
s->frame_len_bits - v);
return -1; return -1;
} }
s->block_len_bits = s->frame_len_bits - v; s->block_len_bits = s->frame_len_bits - v;
} else { } else {
/* update block lengths */ /* update block lengths */
s->prev_block_len_bits = s->block_len_bits; s->prev_block_len_bits = s->block_len_bits;
s->block_len_bits = s->next_block_len_bits; s->block_len_bits = s->next_block_len_bits;
} }
v = get_bits(&s->gb, n); v = get_bits(&s->gb, n);
if (v >= s->nb_block_sizes){ if (v >= s->nb_block_sizes) {
av_log(s->avctx, AV_LOG_ERROR, "next_block_len_bits %d out of range\n", s->frame_len_bits - v); av_log(s->avctx, AV_LOG_ERROR,
"next_block_len_bits %d out of range\n",
s->frame_len_bits - v);
return -1; return -1;
} }
s->next_block_len_bits = s->frame_len_bits - v; s->next_block_len_bits = s->frame_len_bits - v;
@ -469,24 +472,23 @@ static int wma_decode_block(WMACodecContext *s)
/* fixed block len */ /* fixed block len */
s->next_block_len_bits = s->frame_len_bits; s->next_block_len_bits = s->frame_len_bits;
s->prev_block_len_bits = s->frame_len_bits; s->prev_block_len_bits = s->frame_len_bits;
s->block_len_bits = s->frame_len_bits; s->block_len_bits = s->frame_len_bits;
} }
/* now check if the block length is coherent with the frame length */ /* now check if the block length is coherent with the frame length */
s->block_len = 1 << s->block_len_bits; s->block_len = 1 << s->block_len_bits;
if ((s->block_pos + s->block_len) > s->frame_len){ if ((s->block_pos + s->block_len) > s->frame_len) {
av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n"); av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");
return -1; return -1;
} }
if (s->avctx->channels == 2) { if (s->avctx->channels == 2)
s->ms_stereo = get_bits1(&s->gb); s->ms_stereo = get_bits1(&s->gb);
}
v = 0; v = 0;
for(ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
a = get_bits1(&s->gb); a = get_bits1(&s->gb);
s->channel_coded[ch] = a; s->channel_coded[ch] = a;
v |= a; v |= a;
} }
bsize = s->frame_len_bits - s->block_len_bits; bsize = s->frame_len_bits - s->block_len_bits;
@ -497,31 +499,30 @@ static int wma_decode_block(WMACodecContext *s)
goto next; goto next;
/* read total gain and extract corresponding number of bits for /* read total gain and extract corresponding number of bits for
coef escape coding */ * coef escape coding */
total_gain = 1; total_gain = 1;
for(;;) { for (;;) {
a = get_bits(&s->gb, 7); a = get_bits(&s->gb, 7);
total_gain += a; total_gain += a;
if (a != 127) if (a != 127)
break; break;
} }
coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
/* compute number of coefficients */ /* compute number of coefficients */
n = s->coefs_end[bsize] - s->coefs_start; n = s->coefs_end[bsize] - s->coefs_start;
for(ch = 0; ch < s->avctx->channels; ch++) for (ch = 0; ch < s->avctx->channels; ch++)
nb_coefs[ch] = n; nb_coefs[ch] = n;
/* complex coding */ /* complex coding */
if (s->use_noise_coding) { if (s->use_noise_coding) {
for (ch = 0; ch < s->avctx->channels; ch++) {
for(ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
int i, n, a; int i, n, a;
n = s->exponent_high_sizes[bsize]; n = s->exponent_high_sizes[bsize];
for(i=0;i<n;i++) { for (i = 0; i < n; i++) {
a = get_bits1(&s->gb); a = get_bits1(&s->gb);
s->high_band_coded[ch][i] = a; s->high_band_coded[ch][i] = a;
/* if noise coding, the coefficients are not transmitted */ /* if noise coding, the coefficients are not transmitted */
if (a) if (a)
@ -529,20 +530,22 @@ static int wma_decode_block(WMACodecContext *s)
} }
} }
} }
for(ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
int i, n, val, code; int i, n, val, code;
n = s->exponent_high_sizes[bsize]; n = s->exponent_high_sizes[bsize];
val = (int)0x80000000; val = (int) 0x80000000;
for(i=0;i<n;i++) { for (i = 0; i < n; i++) {
if (s->high_band_coded[ch][i]) { if (s->high_band_coded[ch][i]) {
if (val == (int)0x80000000) { if (val == (int) 0x80000000) {
val = get_bits(&s->gb, 7) - 19; val = get_bits(&s->gb, 7) - 19;
} else { } else {
code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX); code = get_vlc2(&s->gb, s->hgain_vlc.table,
if (code < 0){ HGAINVLCBITS, HGAINMAX);
av_log(s->avctx, AV_LOG_ERROR, "hgain vlc invalid\n"); if (code < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"hgain vlc invalid\n");
return -1; return -1;
} }
val += code - 18; val += code - 18;
@ -555,9 +558,8 @@ static int wma_decode_block(WMACodecContext *s)
} }
/* exponents can be reused in short blocks. */ /* exponents can be reused in short blocks. */
if ((s->block_len_bits == s->frame_len_bits) || if ((s->block_len_bits == s->frame_len_bits) || get_bits1(&s->gb)) {
get_bits1(&s->gb)) { for (ch = 0; ch < s->avctx->channels; ch++) {
for(ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
if (s->use_exp_vlc) { if (s->use_exp_vlc) {
if (decode_exp_vlc(s, ch) < 0) if (decode_exp_vlc(s, ch) < 0)
@ -574,29 +576,27 @@ static int wma_decode_block(WMACodecContext *s)
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
int tindex; int tindex;
WMACoef* ptr = &s->coefs1[ch][0]; WMACoef *ptr = &s->coefs1[ch][0];
/* special VLC tables are used for ms stereo because /* special VLC tables are used for ms stereo because
there is potentially less energy there */ * there is potentially less energy there */
tindex = (ch == 1 && s->ms_stereo); tindex = (ch == 1 && s->ms_stereo);
memset(ptr, 0, s->block_len * sizeof(WMACoef)); memset(ptr, 0, s->block_len * sizeof(WMACoef));
ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex], ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
s->level_table[tindex], s->run_table[tindex], s->level_table[tindex], s->run_table[tindex],
0, ptr, 0, nb_coefs[ch], 0, ptr, 0, nb_coefs[ch],
s->block_len, s->frame_len_bits, coef_nb_bits); s->block_len, s->frame_len_bits, coef_nb_bits);
} }
if (s->version == 1 && s->avctx->channels >= 2) { if (s->version == 1 && s->avctx->channels >= 2)
align_get_bits(&s->gb); align_get_bits(&s->gb);
}
} }
/* normalize */ /* normalize */
{ {
int n4 = s->block_len / 2; int n4 = s->block_len / 2;
mdct_norm = 1.0 / (float)n4; mdct_norm = 1.0 / (float) n4;
if (s->version == 1) { if (s->version == 1)
mdct_norm *= sqrt(n4); mdct_norm *= sqrt(n4);
}
} }
/* finally compute the MDCT coefficients */ /* finally compute the MDCT coefficients */
@ -607,97 +607,94 @@ static int wma_decode_block(WMACodecContext *s)
int i, j, n, n1, last_high_band, esize; int i, j, n, n1, last_high_band, esize;
float exp_power[HIGH_BAND_MAX_SIZE]; float exp_power[HIGH_BAND_MAX_SIZE];
coefs1 = s->coefs1[ch]; coefs1 = s->coefs1[ch];
exponents = s->exponents[ch]; exponents = s->exponents[ch];
esize = s->exponents_bsize[ch]; esize = s->exponents_bsize[ch];
mult = pow(10, total_gain * 0.05) / s->max_exponent[ch]; mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
mult *= mdct_norm; mult *= mdct_norm;
coefs = s->coefs[ch]; coefs = s->coefs[ch];
if (s->use_noise_coding) { if (s->use_noise_coding) {
mult1 = mult; mult1 = mult;
/* very low freqs : noise */ /* very low freqs : noise */
for(i = 0;i < s->coefs_start; i++) { for (i = 0; i < s->coefs_start; i++) {
*coefs++ = s->noise_table[s->noise_index] * *coefs++ = s->noise_table[s->noise_index] *
exponents[i<<bsize>>esize] * mult1; exponents[i << bsize >> esize] * mult1;
s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); s->noise_index = (s->noise_index + 1) &
(NOISE_TAB_SIZE - 1);
} }
n1 = s->exponent_high_sizes[bsize]; n1 = s->exponent_high_sizes[bsize];
/* compute power of high bands */ /* compute power of high bands */
exponents = s->exponents[ch] + exponents = s->exponents[ch] +
(s->high_band_start[bsize]<<bsize>>esize); (s->high_band_start[bsize] << bsize >> esize);
last_high_band = 0; /* avoid warning */ last_high_band = 0; /* avoid warning */
for(j=0;j<n1;j++) { for (j = 0; j < n1; j++) {
n = s->exponent_high_bands[s->frame_len_bits - n = s->exponent_high_bands[s->frame_len_bits -
s->block_len_bits][j]; s->block_len_bits][j];
if (s->high_band_coded[ch][j]) { if (s->high_band_coded[ch][j]) {
float e2, v; float e2, v;
e2 = 0; e2 = 0;
for(i = 0;i < n; i++) { for (i = 0; i < n; i++) {
v = exponents[i<<bsize>>esize]; v = exponents[i << bsize >> esize];
e2 += v * v; e2 += v * v;
} }
exp_power[j] = e2 / n; exp_power[j] = e2 / n;
last_high_band = j; last_high_band = j;
tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n); tprintf(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
} }
exponents += n<<bsize>>esize; exponents += n << bsize >> esize;
} }
/* main freqs and high freqs */ /* main freqs and high freqs */
exponents = s->exponents[ch] + (s->coefs_start<<bsize>>esize); exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
for(j=-1;j<n1;j++) { for (j = -1; j < n1; j++) {
if (j < 0) { if (j < 0)
n = s->high_band_start[bsize] - n = s->high_band_start[bsize] - s->coefs_start;
s->coefs_start; else
} else {
n = s->exponent_high_bands[s->frame_len_bits - n = s->exponent_high_bands[s->frame_len_bits -
s->block_len_bits][j]; s->block_len_bits][j];
}
if (j >= 0 && s->high_band_coded[ch][j]) { if (j >= 0 && s->high_band_coded[ch][j]) {
/* use noise with specified power */ /* use noise with specified power */
mult1 = sqrt(exp_power[j] / exp_power[last_high_band]); mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
/* XXX: use a table */ /* XXX: use a table */
mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05); mult1 = mult1 * pow(10, s->high_band_values[ch][j] * 0.05);
mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult); mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
mult1 *= mdct_norm; mult1 *= mdct_norm;
for(i = 0;i < n; i++) { for (i = 0; i < n; i++) {
noise = s->noise_table[s->noise_index]; noise = s->noise_table[s->noise_index];
s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
*coefs++ = noise * *coefs++ = noise * exponents[i << bsize >> esize] * mult1;
exponents[i<<bsize>>esize] * mult1;
} }
exponents += n<<bsize>>esize; exponents += n << bsize >> esize;
} else { } else {
/* coded values + small noise */ /* coded values + small noise */
for(i = 0;i < n; i++) { for (i = 0; i < n; i++) {
noise = s->noise_table[s->noise_index]; noise = s->noise_table[s->noise_index];
s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
*coefs++ = ((*coefs1++) + noise) * *coefs++ = ((*coefs1++) + noise) *
exponents[i<<bsize>>esize] * mult; exponents[i << bsize >> esize] * mult;
} }
exponents += n<<bsize>>esize; exponents += n << bsize >> esize;
} }
} }
/* very high freqs : noise */ /* very high freqs : noise */
n = s->block_len - s->coefs_end[bsize]; n = s->block_len - s->coefs_end[bsize];
mult1 = mult * exponents[((-1<<bsize))>>esize]; mult1 = mult * exponents[((-1 << bsize)) >> esize];
for(i = 0; i < n; i++) { for (i = 0; i < n; i++) {
*coefs++ = s->noise_table[s->noise_index] * mult1; *coefs++ = s->noise_table[s->noise_index] * mult1;
s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1); s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
} }
} else { } else {
/* XXX: optimize more */ /* XXX: optimize more */
for(i = 0;i < s->coefs_start; i++) for (i = 0; i < s->coefs_start; i++)
*coefs++ = 0.0; *coefs++ = 0.0;
n = nb_coefs[ch]; n = nb_coefs[ch];
for(i = 0;i < n; i++) { for (i = 0; i < n; i++)
*coefs++ = coefs1[i] * exponents[i<<bsize>>esize] * mult; *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
}
n = s->block_len - s->coefs_end[bsize]; n = s->block_len - s->coefs_end[bsize];
for(i = 0;i < n; i++) for (i = 0; i < n; i++)
*coefs++ = 0.0; *coefs++ = 0.0;
} }
} }
@ -710,12 +707,12 @@ static int wma_decode_block(WMACodecContext *s)
dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len); dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
} }
} }
#endif #endif /* TRACE */
if (s->ms_stereo && s->channel_coded[1]) { if (s->ms_stereo && s->channel_coded[1]) {
/* nominal case for ms stereo: we do it before mdct */ /* nominal case for ms stereo: we do it before mdct */
/* no need to optimize this case because it should almost /* no need to optimize this case because it should almost
never happen */ * never happen */
if (!s->channel_coded[0]) { if (!s->channel_coded[0]) {
tprintf(s->avctx, "rare ms-stereo case happened\n"); tprintf(s->avctx, "rare ms-stereo case happened\n");
memset(s->coefs[0], 0, sizeof(float) * s->block_len); memset(s->coefs[0], 0, sizeof(float) * s->block_len);
@ -732,9 +729,9 @@ next:
int n4, index; int n4, index;
n4 = s->block_len / 2; n4 = s->block_len / 2;
if(s->channel_coded[ch]){ if (s->channel_coded[ch])
mdct->imdct_calc(mdct, s->output, s->coefs[ch]); mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
}else if(!(s->ms_stereo && ch==1)) else if (!(s->ms_stereo && ch == 1))
memset(s->output, 0, sizeof(s->output)); memset(s->output, 0, sizeof(s->output));
/* multiply by the window and add in the frame */ /* multiply by the window and add in the frame */
@ -758,13 +755,14 @@ static int wma_decode_frame(WMACodecContext *s, float **samples,
int ret, ch; int ret, ch;
#ifdef TRACE #ifdef TRACE
tprintf(s->avctx, "***decode_frame: %d size=%d\n", s->frame_count++, s->frame_len); tprintf(s->avctx, "***decode_frame: %d size=%d\n",
#endif s->frame_count++, s->frame_len);
#endif /* TRACE */
/* read each block */ /* read each block */
s->block_num = 0; s->block_num = 0;
s->block_pos = 0; s->block_pos = 0;
for(;;) { for (;;) {
ret = wma_decode_block(s); ret = wma_decode_block(s);
if (ret < 0) if (ret < 0)
return -1; return -1;
@ -781,8 +779,9 @@ static int wma_decode_frame(WMACodecContext *s, float **samples,
s->frame_len * sizeof(*s->frame_out[ch])); s->frame_len * sizeof(*s->frame_out[ch]));
#ifdef TRACE #ifdef TRACE
dump_floats(s, "samples", 6, samples[ch] + samples_offset, s->frame_len); dump_floats(s, "samples", 6, samples[ch] + samples_offset,
#endif s->frame_len);
#endif /* TRACE */
} }
return 0; return 0;
@ -791,9 +790,9 @@ static int wma_decode_frame(WMACodecContext *s, float **samples,
static int wma_decode_superframe(AVCodecContext *avctx, void *data, static int wma_decode_superframe(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt) int *got_frame_ptr, AVPacket *avpkt)
{ {
AVFrame *frame = data; AVFrame *frame = data;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
int nb_frames, bit_offset, i, pos, len, ret; int nb_frames, bit_offset, i, pos, len, ret;
uint8_t *q; uint8_t *q;
@ -802,7 +801,7 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
tprintf(avctx, "***decode_superframe:\n"); tprintf(avctx, "***decode_superframe:\n");
if(buf_size==0){ if (buf_size == 0) {
s->last_superframe_len = 0; s->last_superframe_len = 0;
return 0; return 0;
} }
@ -814,15 +813,14 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
} }
buf_size = avctx->block_align; buf_size = avctx->block_align;
init_get_bits(&s->gb, buf, buf_size*8); init_get_bits(&s->gb, buf, buf_size * 8);
if (s->use_bit_reservoir) { if (s->use_bit_reservoir) {
/* read super frame header */ /* read super frame header */
skip_bits(&s->gb, 4); /* super frame index */ skip_bits(&s->gb, 4); /* super frame index */
nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0); nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
} else { } else
nb_frames = 1; nb_frames = 1;
}
/* get output buffer */ /* get output buffer */
frame->nb_samples = nb_frames * s->frame_len; frame->nb_samples = nb_frames * s->frame_len;
@ -830,7 +828,7 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret; return ret;
} }
samples = (float **)frame->extended_data; samples = (float **) frame->extended_data;
samples_offset = 0; samples_offset = 0;
if (s->use_bit_reservoir) { if (s->use_bit_reservoir) {
@ -847,24 +845,24 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) > if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
MAX_CODED_SUPERFRAME_SIZE) MAX_CODED_SUPERFRAME_SIZE)
goto fail; goto fail;
q = s->last_superframe + s->last_superframe_len; q = s->last_superframe + s->last_superframe_len;
len = bit_offset; len = bit_offset;
while (len > 7) { while (len > 7) {
*q++ = (get_bits)(&s->gb, 8); *q++ = (get_bits) (&s->gb, 8);
len -= 8; len -= 8;
} }
if (len > 0) { if (len > 0)
*q++ = (get_bits)(&s->gb, len) << (8 - len); *q++ = (get_bits) (&s->gb, len) << (8 - len);
}
memset(q, 0, FF_INPUT_BUFFER_PADDING_SIZE); memset(q, 0, FF_INPUT_BUFFER_PADDING_SIZE);
/* XXX: bit_offset bits into last frame */ /* XXX: bit_offset bits into last frame */
init_get_bits(&s->gb, s->last_superframe, s->last_superframe_len * 8 + bit_offset); init_get_bits(&s->gb, s->last_superframe,
s->last_superframe_len * 8 + bit_offset);
/* skip unused bits */ /* skip unused bits */
if (s->last_bitoffset > 0) if (s->last_bitoffset > 0)
skip_bits(&s->gb, s->last_bitoffset); skip_bits(&s->gb, s->last_bitoffset);
/* this frame is stored in the last superframe and in the /* this frame is stored in the last superframe and in the
current one */ * current one */
if (wma_decode_frame(s, samples, samples_offset) < 0) if (wma_decode_frame(s, samples, samples_offset) < 0)
goto fail; goto fail;
samples_offset += s->frame_len; samples_offset += s->frame_len;
@ -875,23 +873,24 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3; pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8) if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3))*8); init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
len = pos & 7; len = pos & 7;
if (len > 0) if (len > 0)
skip_bits(&s->gb, len); skip_bits(&s->gb, len);
s->reset_block_lengths = 1; s->reset_block_lengths = 1;
for(i=0;i<nb_frames;i++) { for (i = 0; i < nb_frames; i++) {
if (wma_decode_frame(s, samples, samples_offset) < 0) if (wma_decode_frame(s, samples, samples_offset) < 0)
goto fail; goto fail;
samples_offset += s->frame_len; samples_offset += s->frame_len;
} }
/* we copy the end of the frame in the last frame buffer */ /* we copy the end of the frame in the last frame buffer */
pos = get_bits_count(&s->gb) + ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7); pos = get_bits_count(&s->gb) +
((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
s->last_bitoffset = pos & 7; s->last_bitoffset = pos & 7;
pos >>= 3; pos >>= 3;
len = buf_size - pos; len = buf_size - pos;
if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) { if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len); av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
goto fail; goto fail;
@ -907,12 +906,13 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
av_dlog(s->avctx, "%d %d %d %d outbytes:%td eaten:%d\n", av_dlog(s->avctx, "%d %d %d %d outbytes:%td eaten:%d\n",
s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len, s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
(int8_t *)samples - (int8_t *)data, avctx->block_align); (int8_t *) samples - (int8_t *) data, avctx->block_align);
*got_frame_ptr = 1; *got_frame_ptr = 1;
return avctx->block_align; return avctx->block_align;
fail:
fail:
/* when error, we reset the bit reservoir */ /* when error, we reset the bit reservoir */
s->last_superframe_len = 0; s->last_superframe_len = 0;
return -1; return -1;
@ -922,8 +922,8 @@ static av_cold void flush(AVCodecContext *avctx)
{ {
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
s->last_bitoffset= s->last_bitoffset =
s->last_superframe_len= 0; s->last_superframe_len = 0;
} }
AVCodec ff_wmav1_decoder = { AVCodec ff_wmav1_decoder = {

278
libavcodec/wmaenc.c
Unescape View File

@ -20,6 +20,7 @@
*/ */
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "avcodec.h" #include "avcodec.h"
#include "internal.h" #include "internal.h"
#include "wma.h" #include "wma.h"
@ -36,8 +37,9 @@ static av_cold int encode_init(AVCodecContext *avctx)
s->avctx = avctx; s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS) { if (avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer", av_log(avctx, AV_LOG_ERROR,
"too many channels: got %i, need %i or fewer",
avctx->channels, MAX_CHANNELS); avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -48,8 +50,9 @@ static av_cold int encode_init(AVCodecContext *avctx)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if(avctx->bit_rate < 24*1000) { if (avctx->bit_rate < 24 * 1000) {
av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n", av_log(avctx, AV_LOG_ERROR,
"bitrate too low: got %i, need 24000 or higher\n",
avctx->bit_rate); avctx->bit_rate);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
@ -58,20 +61,21 @@ static av_cold int encode_init(AVCodecContext *avctx)
flags1 = 0; flags1 = 0;
flags2 = 1; flags2 = 1;
if (avctx->codec->id == AV_CODEC_ID_WMAV1) { if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
extradata= av_malloc(4); extradata = av_malloc(4);
avctx->extradata_size= 4; avctx->extradata_size = 4;
AV_WL16(extradata, flags1); AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2); AV_WL16(extradata + 2, flags2);
} else if (avctx->codec->id == AV_CODEC_ID_WMAV2) { } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
extradata= av_mallocz(10); extradata = av_mallocz(10);
avctx->extradata_size= 10; avctx->extradata_size = 10;
AV_WL32(extradata, flags1); AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2); AV_WL16(extradata + 4, flags2);
}else } else {
assert(0); assert(0);
avctx->extradata= extradata; }
s->use_exp_vlc = flags2 & 0x0001; avctx->extradata = extradata;
s->use_bit_reservoir = flags2 & 0x0002; s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004; s->use_variable_block_len = flags2 & 0x0004;
if (avctx->channels == 2) if (avctx->channels == 2)
s->ms_stereo = 1; s->ms_stereo = 1;
@ -79,57 +83,59 @@ static av_cold int encode_init(AVCodecContext *avctx)
ff_wma_init(avctx, flags2); ff_wma_init(avctx, flags2);
/* init MDCT */ /* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++) for (i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0); ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
block_align = avctx->bit_rate * (int64_t)s->frame_len / block_align = avctx->bit_rate * (int64_t) s->frame_len /
(avctx->sample_rate * 8); (avctx->sample_rate * 8);
block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE); block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
avctx->block_align = block_align; avctx->block_align = block_align;
avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate / avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate /
s->frame_len; s->frame_len;
avctx->frame_size = avctx->delay = s->frame_len; avctx->frame_size =
avctx->delay = s->frame_len;
return 0; return 0;
} }
static void apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
static void apply_window_and_mdct(AVCodecContext * avctx, const AVFrame *frame)
{ {
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
float **audio = (float **)frame->extended_data; float **audio = (float **) frame->extended_data;
int len = frame->nb_samples; int len = frame->nb_samples;
int window_index= s->frame_len_bits - s->block_len_bits; int window_index = s->frame_len_bits - s->block_len_bits;
FFTContext *mdct = &s->mdct_ctx[window_index]; FFTContext *mdct = &s->mdct_ctx[window_index];
int ch; int ch;
const float * win = s->windows[window_index]; const float *win = s->windows[window_index];
int window_len = 1 << s->block_len_bits; int window_len = 1 << s->block_len_bits;
float n = 2.0 * 32768.0 / window_len; float n = 2.0 * 32768.0 / window_len;
for (ch = 0; ch < avctx->channels; ch++) { for (ch = 0; ch < avctx->channels; ch++) {
memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output)); memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
s->fdsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len); s->fdsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
s->fdsp.vector_fmul_reverse(&s->output[window_len], s->frame_out[ch], win, len); s->fdsp.vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
win, len);
s->fdsp.vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len); s->fdsp.vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
mdct->mdct_calc(mdct, s->coefs[ch], s->output); mdct->mdct_calc(mdct, s->coefs[ch], s->output);
} }
} }
//FIXME use for decoding too // FIXME use for decoding too
static void init_exp(WMACodecContext *s, int ch, const int *exp_param){ static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
{
int n; int n;
const uint16_t *ptr; const uint16_t *ptr;
float v, *q, max_scale, *q_end; float v, *q, max_scale, *q_end;
ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
q = s->exponents[ch]; q = s->exponents[ch];
q_end = q + s->block_len; q_end = q + s->block_len;
max_scale = 0; max_scale = 0;
while (q < q_end) { while (q < q_end) {
/* XXX: use a table */ /* XXX: use a table */
v = pow(10, *exp_param++ * (1.0 / 16.0)); v = pow(10, *exp_param++ *(1.0 / 16.0));
max_scale= FFMAX(max_scale, v); max_scale = FFMAX(max_scale, v);
n = *ptr++; n = *ptr++;
do { do {
*q++ = v; *q++ = v;
} while (--n); } while (--n);
@ -137,73 +143,81 @@ static void init_exp(WMACodecContext *s, int ch, const int *exp_param){
s->max_exponent[ch] = max_scale; s->max_exponent[ch] = max_scale;
} }
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param){ static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
{
int last_exp; int last_exp;
const uint16_t *ptr; const uint16_t *ptr;
float *q, *q_end; float *q, *q_end;
ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits]; ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
q = s->exponents[ch]; q = s->exponents[ch];
q_end = q + s->block_len; q_end = q + s->block_len;
if (s->version == 1) { if (s->version == 1) {
last_exp= *exp_param++; last_exp = *exp_param++;
assert(last_exp-10 >= 0 && last_exp-10 < 32); assert(last_exp - 10 >= 0 && last_exp - 10 < 32);
put_bits(&s->pb, 5, last_exp - 10); put_bits(&s->pb, 5, last_exp - 10);
q+= *ptr++; q += *ptr++;
}else } else
last_exp = 36; last_exp = 36;
while (q < q_end) { while (q < q_end) {
int exp = *exp_param++; int exp = *exp_param++;
int code = exp - last_exp + 60; int code = exp - last_exp + 60;
assert(code >= 0 && code < 120); assert(code >= 0 && code < 120);
put_bits(&s->pb, ff_aac_scalefactor_bits[code], ff_aac_scalefactor_code[code]); put_bits(&s->pb, ff_aac_scalefactor_bits[code],
ff_aac_scalefactor_code[code]);
/* XXX: use a table */ /* XXX: use a table */
q+= *ptr++; q += *ptr++;
last_exp= exp; last_exp = exp;
} }
} }
static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], int total_gain){ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
int total_gain)
{
int v, bsize, ch, coef_nb_bits, parse_exponents; int v, bsize, ch, coef_nb_bits, parse_exponents;
float mdct_norm; float mdct_norm;
int nb_coefs[MAX_CHANNELS]; int nb_coefs[MAX_CHANNELS];
static const int fixed_exp[25]={20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20}; static const int fixed_exp[25] = {
20, 20, 20, 20, 20,
//FIXME remove duplication relative to decoder 20, 20, 20, 20, 20,
20, 20, 20, 20, 20,
20, 20, 20, 20, 20,
20, 20, 20, 20, 20
};
// FIXME remove duplication relative to decoder
if (s->use_variable_block_len) { if (s->use_variable_block_len) {
assert(0); //FIXME not implemented assert(0); // FIXME not implemented
}else{ } else {
/* fixed block len */ /* fixed block len */
s->next_block_len_bits = s->frame_len_bits; s->next_block_len_bits = s->frame_len_bits;
s->prev_block_len_bits = s->frame_len_bits; s->prev_block_len_bits = s->frame_len_bits;
s->block_len_bits = s->frame_len_bits; s->block_len_bits = s->frame_len_bits;
} }
s->block_len = 1 << s->block_len_bits; s->block_len = 1 << s->block_len_bits;
// assert((s->block_pos + s->block_len) <= s->frame_len); // assert((s->block_pos + s->block_len) <= s->frame_len);
bsize = s->frame_len_bits - s->block_len_bits; bsize = s->frame_len_bits - s->block_len_bits;
//FIXME factor // FIXME factor
v = s->coefs_end[bsize] - s->coefs_start; v = s->coefs_end[bsize] - s->coefs_start;
for (ch = 0; ch < s->avctx->channels; ch++) for (ch = 0; ch < s->avctx->channels; ch++)
nb_coefs[ch] = v; nb_coefs[ch] = v;
{ {
int n4 = s->block_len / 2; int n4 = s->block_len / 2;
mdct_norm = 1.0 / (float)n4; mdct_norm = 1.0 / (float) n4;
if (s->version == 1) { if (s->version == 1)
mdct_norm *= sqrt(n4); mdct_norm *= sqrt(n4);
}
} }
if (s->avctx->channels == 2) { if (s->avctx->channels == 2)
put_bits(&s->pb, 1, !!s->ms_stereo); put_bits(&s->pb, 1, !!s->ms_stereo);
}
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
s->channel_coded[ch] = 1; //FIXME only set channel_coded when needed, instead of always // FIXME only set channel_coded when needed, instead of always
if (s->channel_coded[ch]) { s->channel_coded[ch] = 1;
if (s->channel_coded[ch])
init_exp(s, ch, fixed_exp); init_exp(s, ch, fixed_exp);
}
} }
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
@ -212,19 +226,19 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
float *coefs, *exponents, mult; float *coefs, *exponents, mult;
int i, n; int i, n;
coefs1 = s->coefs1[ch]; coefs1 = s->coefs1[ch];
exponents = s->exponents[ch]; exponents = s->exponents[ch];
mult = pow(10, total_gain * 0.05) / s->max_exponent[ch]; mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
mult *= mdct_norm; mult *= mdct_norm;
coefs = src_coefs[ch]; coefs = src_coefs[ch];
if (s->use_noise_coding && 0) { if (s->use_noise_coding && 0) {
assert(0); //FIXME not implemented assert(0); // FIXME not implemented
} else { } else {
coefs += s->coefs_start; coefs += s->coefs_start;
n = nb_coefs[ch]; n = nb_coefs[ch];
for(i = 0;i < n; i++){ for (i = 0; i < n; i++) {
double t= *coefs++ / (exponents[i] * mult); double t = *coefs++ / (exponents[i] * mult);
if(t<-32768 || t>32767) if (t < -32768 || t > 32767)
return -1; return -1;
coefs1[i] = lrint(t); coefs1[i] = lrint(t);
@ -243,19 +257,19 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
if (!v) if (!v)
return 1; return 1;
for(v= total_gain-1; v>=127; v-= 127) for (v = total_gain - 1; v >= 127; v -= 127)
put_bits(&s->pb, 7, 127); put_bits(&s->pb, 7, 127);
put_bits(&s->pb, 7, v); put_bits(&s->pb, 7, v);
coef_nb_bits= ff_wma_total_gain_to_bits(total_gain); coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
if (s->use_noise_coding) { if (s->use_noise_coding) {
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
int i, n; int i, n;
n = s->exponent_high_sizes[bsize]; n = s->exponent_high_sizes[bsize];
for(i=0;i<n;i++) { for (i = 0; i < n; i++) {
put_bits(&s->pb, 1, s->high_band_coded[ch][i]= 0); put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
if (0) if (0)
nb_coefs[ch] -= s->exponent_high_bands[bsize][i]; nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
} }
@ -264,9 +278,8 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
} }
parse_exponents = 1; parse_exponents = 1;
if (s->block_len_bits != s->frame_len_bits) { if (s->block_len_bits != s->frame_len_bits)
put_bits(&s->pb, 1, parse_exponents); put_bits(&s->pb, 1, parse_exponents);
}
if (parse_exponents) { if (parse_exponents) {
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
@ -274,69 +287,68 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
if (s->use_exp_vlc) { if (s->use_exp_vlc) {
encode_exp_vlc(s, ch, fixed_exp); encode_exp_vlc(s, ch, fixed_exp);
} else { } else {
assert(0); //FIXME not implemented assert(0); // FIXME not implemented
// encode_exp_lsp(s, ch); // encode_exp_lsp(s, ch);
} }
} }
} }
} else { } else
assert(0); //FIXME not implemented assert(0); // FIXME not implemented
}
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
int run, tindex; int run, tindex;
WMACoef *ptr, *eptr; WMACoef *ptr, *eptr;
tindex = (ch == 1 && s->ms_stereo); tindex = (ch == 1 && s->ms_stereo);
ptr = &s->coefs1[ch][0]; ptr = &s->coefs1[ch][0];
eptr = ptr + nb_coefs[ch]; eptr = ptr + nb_coefs[ch];
run=0; run = 0;
for(;ptr < eptr; ptr++){ for (; ptr < eptr; ptr++) {
if(*ptr){ if (*ptr) {
int level= *ptr; int level = *ptr;
int abs_level= FFABS(level); int abs_level = FFABS(level);
int code= 0; int code = 0;
if(abs_level <= s->coef_vlcs[tindex]->max_level){ if (abs_level <= s->coef_vlcs[tindex]->max_level)
if(run < s->coef_vlcs[tindex]->levels[abs_level-1]) if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
code= run + s->int_table[tindex][abs_level-1]; code = run + s->int_table[tindex][abs_level - 1];
}
assert(code < s->coef_vlcs[tindex]->n); assert(code < s->coef_vlcs[tindex]->n);
put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code], s->coef_vlcs[tindex]->huffcodes[code]); put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
s->coef_vlcs[tindex]->huffcodes[code]);
if(code == 0){ if (code == 0) {
if(1<<coef_nb_bits <= abs_level) if (1 << coef_nb_bits <= abs_level)
return -1; return -1;
put_bits(&s->pb, coef_nb_bits, abs_level); put_bits(&s->pb, coef_nb_bits, abs_level);
put_bits(&s->pb, s->frame_len_bits, run); put_bits(&s->pb, s->frame_len_bits, run);
} }
put_bits(&s->pb, 1, level < 0); //FIXME the sign is fliped somewhere // FIXME the sign is flipped somewhere
run=0; put_bits(&s->pb, 1, level < 0);
}else{ run = 0;
} else
run++; run++;
}
} }
if(run) if (run)
put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1], s->coef_vlcs[tindex]->huffcodes[1]); put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
s->coef_vlcs[tindex]->huffcodes[1]);
} }
if (s->version == 1 && s->avctx->channels >= 2) { if (s->version == 1 && s->avctx->channels >= 2)
avpriv_align_put_bits(&s->pb); avpriv_align_put_bits(&s->pb);
}
} }
return 0; return 0;
} }
static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain){ static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
uint8_t *buf, int buf_size, int total_gain)
{
init_put_bits(&s->pb, buf, buf_size); init_put_bits(&s->pb, buf, buf_size);
if (s->use_bit_reservoir) { if (s->use_bit_reservoir)
assert(0);//FIXME not implemented assert(0); // FIXME not implemented
}else{ else if (encode_block(s, src_coefs, total_gain) < 0)
if(encode_block(s, src_coefs, total_gain) < 0) return INT_MAX;
return INT_MAX;
}
avpriv_align_put_bits(&s->pb); avpriv_align_put_bits(&s->pb);
@ -349,8 +361,8 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
WMACodecContext *s = avctx->priv_data; WMACodecContext *s = avctx->priv_data;
int i, total_gain, ret; int i, total_gain, ret;
s->block_len_bits= s->frame_len_bits; //required by non variable block len s->block_len_bits = s->frame_len_bits; // required by non variable block len
s->block_len = 1 << s->block_len_bits; s->block_len = 1 << s->block_len_bits;
apply_window_and_mdct(avctx, frame); apply_window_and_mdct(avctx, frame);
@ -358,9 +370,9 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
float a, b; float a, b;
int i; int i;
for(i = 0; i < s->block_len; i++) { for (i = 0; i < s->block_len; i++) {
a = s->coefs[0][i]*0.5; a = s->coefs[0][i] * 0.5;
b = s->coefs[1][i]*0.5; b = s->coefs[1][i] * 0.5;
s->coefs[0][i] = a + b; s->coefs[0][i] = a + b;
s->coefs[1][i] = a - b; s->coefs[1][i] = a - b;
} }
@ -372,33 +384,33 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
} }
#if 1 #if 1
total_gain= 128; total_gain = 128;
for(i=64; i; i>>=1){ for (i = 64; i; i >>= 1) {
int error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, int error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
total_gain - i); total_gain - i);
if(error<0) if (error < 0)
total_gain-= i; total_gain -= i;
} }
#else #else
total_gain= 90; total_gain = 90;
best = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain); best = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain);
for(i=32; i; i>>=1){ for (i = 32; i; i >>= 1) {
int scoreL = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain - i); int scoreL = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain - i);
int scoreR = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain + i); int scoreR = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain + i);
av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain); av_log(NULL, AV_LOG_ERROR, "%d %d %d (%d)\n", scoreL, best, scoreR, total_gain);
if(scoreL < FFMIN(best, scoreR)){ if (scoreL < FFMIN(best, scoreR)) {
best = scoreL; best = scoreL;
total_gain -= i; total_gain -= i;
}else if(scoreR < best){ } else if (scoreR < best) {
best = scoreR; best = scoreR;
total_gain += i; total_gain += i;
} }
} }
#endif #endif /* 1 */
if ((i = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain)) >= 0) { if ((i = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain)) >= 0) {
av_log(avctx, AV_LOG_ERROR, "required frame size too large. please " av_log(avctx, AV_LOG_ERROR, "required frame size too large. please "
"use a higher bit rate.\n"); "use a higher bit rate.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
assert((put_bits_count(&s->pb) & 7) == 0); assert((put_bits_count(&s->pb) & 7) == 0);
@ -410,7 +422,7 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
if (frame->pts != AV_NOPTS_VALUE) if (frame->pts != AV_NOPTS_VALUE)
avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay); avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
avpkt->size = avctx->block_align; avpkt->size = avctx->block_align;
*got_packet_ptr = 1; *got_packet_ptr = 1;
return 0; return 0;
} }
@ -424,8 +436,8 @@ AVCodec ff_wmav1_encoder = {
.init = encode_init, .init = encode_init,
.encode2 = encode_superframe, .encode2 = encode_superframe,
.close = ff_wma_end, .close = ff_wma_end,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
}; };
AVCodec ff_wmav2_encoder = { AVCodec ff_wmav2_encoder = {
@ -437,6 +449,6 @@ AVCodec ff_wmav2_encoder = {
.init = encode_init, .init = encode_init,
.encode2 = encode_superframe, .encode2 = encode_superframe,
.close = ff_wma_end, .close = ff_wma_end,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP, .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
}; };

Write Preview
Loading…
Cancel
Save