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. 137
      libavcodec/wma.c
  2. 15
      libavcodec/wma.h
  3. 21
      libavcodec/wma_common.c
  4. 34
      libavcodec/wmadata.h
  5. 118
      libavcodec/wmadec.c
  6. 86
      libavcodec/wmaenc.c

137
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"
@ -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,9 +109,8 @@ 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;
@ -120,66 +119,61 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
/* 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 /
(float) (avctx->channels * avctx->sample_rate);
s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2; 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",
s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate, s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
@ -194,11 +188,10 @@ 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;
@ -223,14 +216,13 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
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++;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
@ -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++)
@ -335,35 +325,39 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
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]);
@ -404,11 +396,10 @@ 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);
} }
@ -429,10 +420,10 @@ unsigned int ff_wma_get_large_val(GetBitContext* gb)
* @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;
@ -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);

15
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
@ -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];
@ -150,10 +151,10 @@ 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,32 +32,28 @@
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;
} }

34
libavcodec/wmadata.h
Unescape View File

@ -28,6 +28,7 @@
#define AVCODEC_WMADATA_H #define AVCODEC_WMADATA_H
#include <stdint.h> #include <stdint.h>
#include "wma.h" #include "wma.h"
const uint16_t ff_wma_critical_freqs[25] = { const uint16_t ff_wma_critical_freqs[25] = {
@ -41,7 +42,8 @@ const uint16_t ff_wma_critical_freqs[25] = {
static const uint8_t exponent_band_22050[3][25] = { static const uint8_t exponent_band_22050[3][25] = {
{ 10, 4, 8, 4, 8, 8, 12, 20, 24, 24, 16, }, { 10, 4, 8, 4, 8, 8, 12, 20, 24, 24, 16, },
{ 14, 4, 8, 8, 4, 12, 12, 16, 24, 16, 20, 24, 32, 40, 36, }, { 14, 4, 8, 8, 4, 12, 12, 16, 24, 16, 20, 24, 32, 40, 36, },
{ 23, 4, 4, 4, 8, 4, 4, 8, 8, 8, 8, 8, 12, 12, 16, 16, 24, 24, 32, 44, 48, 60, 84, 72, }, { 23, 4, 4, 4, 8, 4, 4, 8, 8, 8, 8, 8, 12, 12, 16, 16,
24, 24, 32, 44, 48, 60, 84, 72, },
}; };
static const uint8_t exponent_band_32000[3][25] = { static const uint8_t exponent_band_32000[3][25] = {
@ -65,10 +67,8 @@ const uint16_t ff_wma_hgain_huffcodes[37] = {
}; };
const uint8_t ff_wma_hgain_huffbits[37] = { const uint8_t ff_wma_hgain_huffbits[37] = {
10, 12, 10, 13, 9, 13, 9, 8, 10, 12, 10, 13, 9, 13, 9, 8, 7, 5, 5, 4, 4, 3, 3, 3,
7, 5, 5, 4, 4, 3, 3, 3, 4, 3, 4, 4, 5, 5, 6, 8, 7, 10, 8, 10, 9, 8, 9, 9,
4, 3, 4, 4, 5, 5, 6, 8,
7, 10, 8, 10, 9, 8, 9, 9,
13, 10, 13, 13, 13, 13, 10, 13, 13, 13,
}; };
@ -1380,24 +1380,12 @@ static const uint16_t levels5[40] = {
}; };
static const CoefVLCTable coef_vlcs[6] = { static const CoefVLCTable coef_vlcs[6] = {
{ { sizeof(coef0_huffbits), sizeof(levels0) / 2, coef0_huffcodes, coef0_huffbits, levels0, },
sizeof(coef0_huffbits), sizeof(levels0)/2, coef0_huffcodes, coef0_huffbits, levels0, { sizeof(coef1_huffbits), sizeof(levels1) / 2, coef1_huffcodes, coef1_huffbits, levels1, },
}, { sizeof(coef2_huffbits), sizeof(levels2) / 2, coef2_huffcodes, coef2_huffbits, levels2, },
{ { sizeof(coef3_huffbits), sizeof(levels3) / 2, coef3_huffcodes, coef3_huffbits, levels3, },
sizeof(coef1_huffbits), sizeof(levels1)/2, coef1_huffcodes, coef1_huffbits, levels1, { sizeof(coef4_huffbits), sizeof(levels4) / 2, coef4_huffcodes, coef4_huffbits, levels4, },
}, { sizeof(coef5_huffbits), sizeof(levels5) / 2, coef5_huffcodes, coef5_huffbits, levels5, },
{
sizeof(coef2_huffbits), sizeof(levels2)/2, coef2_huffcodes, coef2_huffbits, levels2,
},
{
sizeof(coef3_huffbits), sizeof(levels3)/2, coef3_huffcodes, coef3_huffbits, levels3,
},
{
sizeof(coef4_huffbits), sizeof(levels4)/2, coef4_huffcodes, coef4_huffbits, levels4,
},
{
sizeof(coef5_huffbits), sizeof(levels5)/2, coef5_huffcodes, coef5_huffbits, levels5,
},
}; };
#endif /* AVCODEC_WMADATA_H */ #endif /* AVCODEC_WMADATA_H */

118
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"
@ -50,7 +51,8 @@
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;
@ -65,7 +67,7 @@ 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)
{ {
@ -83,11 +85,10 @@ static av_cold int wma_decode_init(AVCodecContext * 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;
@ -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;
@ -160,7 +160,7 @@ static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
} }
/* 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;
@ -176,8 +176,7 @@ 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;
@ -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.
* *
@ -384,7 +382,6 @@ static void wma_window(WMACodecContext *s, float *out)
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;
@ -405,7 +402,6 @@ static void wma_window(WMACodecContext *s, float *out)
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;
@ -413,13 +409,13 @@ static void wma_window(WMACodecContext *s, float *out)
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) {
@ -444,13 +441,17 @@ static int wma_decode_block(WMACodecContext *s)
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;
@ -461,7 +462,9 @@ static int wma_decode_block(WMACodecContext *s)
} }
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;
@ -479,9 +482,8 @@ static int wma_decode_block(WMACodecContext *s)
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);
@ -497,7 +499,7 @@ 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);
@ -515,7 +517,6 @@ static int wma_decode_block(WMACodecContext *s)
/* 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;
@ -540,9 +541,11 @@ static int wma_decode_block(WMACodecContext *s)
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,
HGAINVLCBITS, HGAINMAX);
if (code < 0) { if (code < 0) {
av_log(s->avctx, AV_LOG_ERROR, "hgain vlc invalid\n"); av_log(s->avctx, AV_LOG_ERROR,
"hgain vlc invalid\n");
return -1; return -1;
} }
val += code - 18; val += code - 18;
@ -555,8 +558,7 @@ 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) {
@ -577,7 +579,7 @@ static int wma_decode_block(WMACodecContext *s)
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],
@ -585,19 +587,17 @@ static int wma_decode_block(WMACodecContext *s)
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 */
for (ch = 0; ch < s->avctx->channels; ch++) { for (ch = 0; ch < s->avctx->channels; ch++) {
@ -619,7 +619,8 @@ static int wma_decode_block(WMACodecContext *s)
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];
@ -648,13 +649,11 @@ static int wma_decode_block(WMACodecContext *s)
/* 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]);
@ -665,8 +664,7 @@ static int wma_decode_block(WMACodecContext *s)
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 {
@ -693,9 +691,8 @@ static int wma_decode_block(WMACodecContext *s)
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,8 +755,9 @@ 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;
@ -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;
@ -820,9 +819,8 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
/* 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;
@ -853,18 +851,18 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
*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;
@ -888,7 +886,8 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
} }
/* 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;
@ -912,6 +911,7 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
*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;

86
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"
@ -37,7 +38,8 @@ 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);
} }
@ -49,7 +51,8 @@ static av_cold int encode_init(AVCodecContext *avctx)
} }
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);
} }
@ -67,8 +70,9 @@ static av_cold int encode_init(AVCodecContext *avctx)
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; avctx->extradata = extradata;
s->use_exp_vlc = flags2 & 0x0001; s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002; s->use_bit_reservoir = flags2 & 0x0002;
@ -88,12 +92,12 @@ static av_cold int encode_init(AVCodecContext *avctx)
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;
@ -109,14 +113,16 @@ static void apply_window_and_mdct(AVCodecContext * avctx, const AVFrame *frame)
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;
@ -137,7 +143,8 @@ 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;
@ -156,18 +163,27 @@ static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param){
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,
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 // FIXME remove duplication relative to decoder
if (s->use_variable_block_len) { if (s->use_variable_block_len) {
@ -190,21 +206,19 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
{ {
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++) {
if (s->channel_coded[ch]) { if (s->channel_coded[ch]) {
@ -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++) {
@ -279,9 +292,8 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
} }
} }
} }
} 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]) {
@ -297,13 +309,13 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
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)
@ -312,31 +324,31 @@ static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
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
put_bits(&s->pb, 1, level < 0);
run = 0; run = 0;
}else{ } 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);
@ -394,7 +406,7 @@ static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
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 "

Write Preview
Loading…
Cancel
Save