00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00031 #include "libavutil/channel_layout.h"
00032 #include "avcodec.h"
00033 #define BITSTREAM_READER_LE
00034 #include "get_bits.h"
00035 #include "dsputil.h"
00036 #include "dct.h"
00037 #include "rdft.h"
00038 #include "fmtconvert.h"
00039 #include "internal.h"
00040 #include "libavutil/intfloat.h"
00041
00042 extern const uint16_t ff_wma_critical_freqs[25];
00043
00044 static float quant_table[96];
00045
00046 #define MAX_CHANNELS 2
00047 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
00048
00049 typedef struct {
00050 AVFrame frame;
00051 GetBitContext gb;
00052 int version_b;
00053 int first;
00054 int channels;
00055 int frame_len;
00056 int overlap_len;
00057 int block_size;
00058 int num_bands;
00059 unsigned int *bands;
00060 float root;
00061 DECLARE_ALIGNED(32, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];
00062 float previous[MAX_CHANNELS][BINK_BLOCK_MAX_SIZE / 16];
00063 uint8_t *packet_buffer;
00064 union {
00065 RDFTContext rdft;
00066 DCTContext dct;
00067 } trans;
00068 } BinkAudioContext;
00069
00070
00071 static av_cold int decode_init(AVCodecContext *avctx)
00072 {
00073 BinkAudioContext *s = avctx->priv_data;
00074 int sample_rate = avctx->sample_rate;
00075 int sample_rate_half;
00076 int i;
00077 int frame_len_bits;
00078
00079
00080 if (avctx->sample_rate < 22050) {
00081 frame_len_bits = 9;
00082 } else if (avctx->sample_rate < 44100) {
00083 frame_len_bits = 10;
00084 } else {
00085 frame_len_bits = 11;
00086 }
00087
00088 if (avctx->channels < 1 || avctx->channels > MAX_CHANNELS) {
00089 av_log(avctx, AV_LOG_ERROR, "invalid number of channels: %d\n", avctx->channels);
00090 return AVERROR_INVALIDDATA;
00091 }
00092 avctx->channel_layout = avctx->channels == 1 ? AV_CH_LAYOUT_MONO :
00093 AV_CH_LAYOUT_STEREO;
00094
00095 s->version_b = avctx->extradata_size >= 4 && avctx->extradata[3] == 'b';
00096
00097 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT) {
00098
00099 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00100 sample_rate *= avctx->channels;
00101 s->channels = 1;
00102 if (!s->version_b)
00103 frame_len_bits += av_log2(avctx->channels);
00104 } else {
00105 s->channels = avctx->channels;
00106 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
00107 }
00108
00109 s->frame_len = 1 << frame_len_bits;
00110 s->overlap_len = s->frame_len / 16;
00111 s->block_size = (s->frame_len - s->overlap_len) * s->channels;
00112 sample_rate_half = (sample_rate + 1) / 2;
00113 if (avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
00114 s->root = 2.0 / (sqrt(s->frame_len) * 32768.0);
00115 else
00116 s->root = s->frame_len / (sqrt(s->frame_len) * 32768.0);
00117 for (i = 0; i < 96; i++) {
00118
00119 quant_table[i] = expf(i * 0.15289164787221953823f) * s->root;
00120 }
00121
00122
00123 for (s->num_bands = 1; s->num_bands < 25; s->num_bands++)
00124 if (sample_rate_half <= ff_wma_critical_freqs[s->num_bands - 1])
00125 break;
00126
00127 s->bands = av_malloc((s->num_bands + 1) * sizeof(*s->bands));
00128 if (!s->bands)
00129 return AVERROR(ENOMEM);
00130
00131
00132 s->bands[0] = 2;
00133 for (i = 1; i < s->num_bands; i++)
00134 s->bands[i] = (ff_wma_critical_freqs[i - 1] * s->frame_len / sample_rate_half) & ~1;
00135 s->bands[s->num_bands] = s->frame_len;
00136
00137 s->first = 1;
00138
00139 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
00140 ff_rdft_init(&s->trans.rdft, frame_len_bits, DFT_C2R);
00141 else if (CONFIG_BINKAUDIO_DCT_DECODER)
00142 ff_dct_init(&s->trans.dct, frame_len_bits, DCT_III);
00143 else
00144 return -1;
00145
00146 avcodec_get_frame_defaults(&s->frame);
00147 avctx->coded_frame = &s->frame;
00148
00149 return 0;
00150 }
00151
00152 static float get_float(GetBitContext *gb)
00153 {
00154 int power = get_bits(gb, 5);
00155 float f = ldexpf(get_bits_long(gb, 23), power - 23);
00156 if (get_bits1(gb))
00157 f = -f;
00158 return f;
00159 }
00160
00161 static const uint8_t rle_length_tab[16] = {
00162 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64
00163 };
00164
00170 static int decode_block(BinkAudioContext *s, float **out, int use_dct)
00171 {
00172 int ch, i, j, k;
00173 float q, quant[25];
00174 int width, coeff;
00175 GetBitContext *gb = &s->gb;
00176
00177 if (use_dct)
00178 skip_bits(gb, 2);
00179
00180 for (ch = 0; ch < s->channels; ch++) {
00181 FFTSample *coeffs = out[ch];
00182
00183 if (s->version_b) {
00184 if (get_bits_left(gb) < 64)
00185 return AVERROR_INVALIDDATA;
00186 coeffs[0] = av_int2float(get_bits_long(gb, 32)) * s->root;
00187 coeffs[1] = av_int2float(get_bits_long(gb, 32)) * s->root;
00188 } else {
00189 if (get_bits_left(gb) < 58)
00190 return AVERROR_INVALIDDATA;
00191 coeffs[0] = get_float(gb) * s->root;
00192 coeffs[1] = get_float(gb) * s->root;
00193 }
00194
00195 if (get_bits_left(gb) < s->num_bands * 8)
00196 return AVERROR_INVALIDDATA;
00197 for (i = 0; i < s->num_bands; i++) {
00198 int value = get_bits(gb, 8);
00199 quant[i] = quant_table[FFMIN(value, 95)];
00200 }
00201
00202 k = 0;
00203 q = quant[0];
00204
00205
00206 i = 2;
00207 while (i < s->frame_len) {
00208 if (s->version_b) {
00209 j = i + 16;
00210 } else {
00211 int v = get_bits1(gb);
00212 if (v) {
00213 v = get_bits(gb, 4);
00214 j = i + rle_length_tab[v] * 8;
00215 } else {
00216 j = i + 8;
00217 }
00218 }
00219
00220 j = FFMIN(j, s->frame_len);
00221
00222 width = get_bits(gb, 4);
00223 if (width == 0) {
00224 memset(coeffs + i, 0, (j - i) * sizeof(*coeffs));
00225 i = j;
00226 while (s->bands[k] < i)
00227 q = quant[k++];
00228 } else {
00229 while (i < j) {
00230 if (s->bands[k] == i)
00231 q = quant[k++];
00232 coeff = get_bits(gb, width);
00233 if (coeff) {
00234 int v;
00235 v = get_bits1(gb);
00236 if (v)
00237 coeffs[i] = -q * coeff;
00238 else
00239 coeffs[i] = q * coeff;
00240 } else {
00241 coeffs[i] = 0.0f;
00242 }
00243 i++;
00244 }
00245 }
00246 }
00247
00248 if (CONFIG_BINKAUDIO_DCT_DECODER && use_dct) {
00249 coeffs[0] /= 0.5;
00250 s->trans.dct.dct_calc(&s->trans.dct, coeffs);
00251 }
00252 else if (CONFIG_BINKAUDIO_RDFT_DECODER)
00253 s->trans.rdft.rdft_calc(&s->trans.rdft, coeffs);
00254 }
00255
00256 for (ch = 0; ch < s->channels; ch++) {
00257 int j;
00258 int count = s->overlap_len * s->channels;
00259 if (!s->first) {
00260 j = ch;
00261 for (i = 0; i < s->overlap_len; i++, j += s->channels)
00262 out[ch][i] = (s->previous[ch][i] * (count - j) +
00263 out[ch][i] * j) / count;
00264 }
00265 memcpy(s->previous[ch], &out[ch][s->frame_len - s->overlap_len],
00266 s->overlap_len * sizeof(*s->previous[ch]));
00267 }
00268
00269 s->first = 0;
00270
00271 return 0;
00272 }
00273
00274 static av_cold int decode_end(AVCodecContext *avctx)
00275 {
00276 BinkAudioContext * s = avctx->priv_data;
00277 av_freep(&s->bands);
00278 av_freep(&s->packet_buffer);
00279 if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
00280 ff_rdft_end(&s->trans.rdft);
00281 else if (CONFIG_BINKAUDIO_DCT_DECODER)
00282 ff_dct_end(&s->trans.dct);
00283
00284 return 0;
00285 }
00286
00287 static void get_bits_align32(GetBitContext *s)
00288 {
00289 int n = (-get_bits_count(s)) & 31;
00290 if (n) skip_bits(s, n);
00291 }
00292
00293 static int decode_frame(AVCodecContext *avctx, void *data,
00294 int *got_frame_ptr, AVPacket *avpkt)
00295 {
00296 BinkAudioContext *s = avctx->priv_data;
00297 GetBitContext *gb = &s->gb;
00298 int ret, consumed = 0;
00299
00300 if (!get_bits_left(gb)) {
00301 uint8_t *buf;
00302
00303 if (!avpkt->size) {
00304 *got_frame_ptr = 0;
00305 return 0;
00306 }
00307 if (avpkt->size < 4) {
00308 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
00309 return AVERROR_INVALIDDATA;
00310 }
00311 buf = av_realloc(s->packet_buffer, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
00312 if (!buf)
00313 return AVERROR(ENOMEM);
00314 s->packet_buffer = buf;
00315 memcpy(s->packet_buffer, avpkt->data, avpkt->size);
00316 init_get_bits(gb, s->packet_buffer, avpkt->size * 8);
00317 consumed = avpkt->size;
00318
00319
00320 skip_bits_long(gb, 32);
00321 }
00322
00323
00324 s->frame.nb_samples = s->frame_len;
00325 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
00326 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00327 return ret;
00328 }
00329
00330 if (decode_block(s, (float **)s->frame.extended_data,
00331 avctx->codec->id == AV_CODEC_ID_BINKAUDIO_DCT)) {
00332 av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
00333 return AVERROR_INVALIDDATA;
00334 }
00335 get_bits_align32(gb);
00336
00337 s->frame.nb_samples = s->block_size / avctx->channels;
00338 *got_frame_ptr = 1;
00339 *(AVFrame *)data = s->frame;
00340
00341 return consumed;
00342 }
00343
00344 AVCodec ff_binkaudio_rdft_decoder = {
00345 .name = "binkaudio_rdft",
00346 .type = AVMEDIA_TYPE_AUDIO,
00347 .id = AV_CODEC_ID_BINKAUDIO_RDFT,
00348 .priv_data_size = sizeof(BinkAudioContext),
00349 .init = decode_init,
00350 .close = decode_end,
00351 .decode = decode_frame,
00352 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,
00353 .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
00354 };
00355
00356 AVCodec ff_binkaudio_dct_decoder = {
00357 .name = "binkaudio_dct",
00358 .type = AVMEDIA_TYPE_AUDIO,
00359 .id = AV_CODEC_ID_BINKAUDIO_DCT,
00360 .priv_data_size = sizeof(BinkAudioContext),
00361 .init = decode_init,
00362 .close = decode_end,
00363 .decode = decode_frame,
00364 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_DR1,
00365 .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
00366 };