/*
- * Atrac 1 compatible decoder
+ * ATRAC1 compatible decoder
* Copyright (c) 2009 Maxim Poliakovski
* Copyright (c) 2009 Benjamin Larsson
*
/**
* @file
- * Atrac 1 compatible decoder.
+ * ATRAC1 compatible decoder.
* This decoder handles raw ATRAC1 data and probably SDDS data.
*/
#include <stddef.h>
#include <stdio.h>
+#include "libavutil/float_dsp.h"
+
#include "avcodec.h"
-#include "get_bits.h"
-#include "dsputil.h"
+#include "bitstream.h"
#include "fft.h"
-#include "fmtconvert.h"
+#include "internal.h"
#include "sinewin.h"
#include "atrac.h"
/**
* Sound unit struct, one unit is used per channel
*/
-typedef struct {
+typedef struct AT1SUCtx {
int log2_block_count[AT1_QMF_BANDS]; ///< log2 number of blocks in a band
int num_bfus; ///< number of Block Floating Units
float* spectrum[2];
/**
* The atrac1 context, holds all needed parameters for decoding
*/
-typedef struct {
- AVFrame frame;
+typedef struct AT1Ctx {
AT1SUCtx SUs[AT1_MAX_CHANNELS]; ///< channel sound unit
DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES]; ///< the mdct spectrum buffer
DECLARE_ALIGNED(32, float, mid)[256];
DECLARE_ALIGNED(32, float, high)[512];
float* bands[3];
- float *out_samples[AT1_MAX_CHANNELS];
FFTContext mdct_ctx[3];
- int channels;
- DSPContext dsp;
- FmtConvertContext fmt_conv;
+ AVFloatDSPContext fdsp;
} AT1Ctx;
/** size of the transform in samples in the long mode for each QMF band */
at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
/* overlap and window */
- q->dsp.vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
- &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
+ q->fdsp.vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
+ &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
start_pos += block_size;
* Parse the block size mode byte
*/
-static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
+static int at1_parse_bsm(BitstreamContext *bc,
+ int log2_block_cnt[AT1_QMF_BANDS])
{
int log2_block_count_tmp, i;
for (i = 0; i < 2; i++) {
/* low and mid band */
- log2_block_count_tmp = get_bits(gb, 2);
+ log2_block_count_tmp = bitstream_read(bc, 2);
if (log2_block_count_tmp & 1)
return AVERROR_INVALIDDATA;
log2_block_cnt[i] = 2 - log2_block_count_tmp;
}
/* high band */
- log2_block_count_tmp = get_bits(gb, 2);
+ log2_block_count_tmp = bitstream_read(bc, 2);
if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
return AVERROR_INVALIDDATA;
log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
- skip_bits(gb, 2);
+ bitstream_skip(bc, 2);
return 0;
}
-static int at1_unpack_dequant(GetBitContext* gb, AT1SUCtx* su,
+static int at1_unpack_dequant(BitstreamContext *bc, AT1SUCtx *su,
float spec[AT1_SU_SAMPLES])
{
int bits_used, band_num, bfu_num, i;
uint8_t idsfs[AT1_MAX_BFU]; ///< the scalefactor indexes for each BFU
/* parse the info byte (2nd byte) telling how much BFUs were coded */
- su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
+ su->num_bfus = bfu_amount_tab1[bitstream_read(bc, 3)];
/* calc number of consumed bits:
num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
+ info_byte_copy(8bits) + log2_block_count_copy(8bits) */
bits_used = su->num_bfus * 10 + 32 +
- bfu_amount_tab2[get_bits(gb, 2)] +
- (bfu_amount_tab3[get_bits(gb, 3)] << 1);
+ bfu_amount_tab2[bitstream_read(bc, 2)] +
+ (bfu_amount_tab3[bitstream_read(bc, 3)] << 1);
/* get word length index (idwl) for each BFU */
for (i = 0; i < su->num_bfus; i++)
- idwls[i] = get_bits(gb, 4);
+ idwls[i] = bitstream_read(bc, 4);
/* get scalefactor index (idsf) for each BFU */
for (i = 0; i < su->num_bfus; i++)
- idsfs[i] = get_bits(gb, 6);
+ idsfs[i] = bitstream_read(bc, 6);
/* zero idwl/idsf for empty BFUs */
for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
/* read in a quantized spec and convert it to
* signed int and then inverse quantization
*/
- spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
+ spec[pos+i] = bitstream_read_signed(bc, word_len) * scale_factor * max_quant;
}
} else { /* word_len = 0 -> empty BFU, zero all specs in the emty BFU */
memset(&spec[pos], 0, num_specs * sizeof(float));
static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
+ AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AT1Ctx *q = avctx->priv_data;
int ch, ret;
- GetBitContext gb;
- float *samples;
+ BitstreamContext bc;
- if (buf_size < 212 * q->channels) {
+ if (buf_size < 212 * avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "Not enough data to decode!\n");
return AVERROR_INVALIDDATA;
}
/* get output buffer */
- q->frame.nb_samples = AT1_SU_SAMPLES;
- if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
+ frame->nb_samples = AT1_SU_SAMPLES;
+ if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
- samples = (float *)q->frame.data[0];
- for (ch = 0; ch < q->channels; ch++) {
+ for (ch = 0; ch < avctx->channels; ch++) {
AT1SUCtx* su = &q->SUs[ch];
- init_get_bits(&gb, &buf[212 * ch], 212 * 8);
+ bitstream_init8(&bc, &buf[212 * ch], 212);
/* parse block_size_mode, 1st byte */
- ret = at1_parse_bsm(&gb, su->log2_block_count);
+ ret = at1_parse_bsm(&bc, su->log2_block_count);
if (ret < 0)
return ret;
- ret = at1_unpack_dequant(&gb, su, q->spec);
+ ret = at1_unpack_dequant(&bc, su, q->spec);
if (ret < 0)
return ret;
ret = at1_imdct_block(su, q);
if (ret < 0)
return ret;
- at1_subband_synthesis(q, su, q->channels == 1 ? samples : q->out_samples[ch]);
- }
-
- /* interleave */
- if (q->channels == 2) {
- q->fmt_conv.float_interleave(samples, (const float **)q->out_samples,
- AT1_SU_SAMPLES, 2);
+ at1_subband_synthesis(q, su, (float *)frame->extended_data[ch]);
}
- *got_frame_ptr = 1;
- *(AVFrame *)data = q->frame;
+ *got_frame_ptr = 1;
return avctx->block_align;
}
{
AT1Ctx *q = avctx->priv_data;
- av_freep(&q->out_samples[0]);
-
ff_mdct_end(&q->mdct_ctx[0]);
ff_mdct_end(&q->mdct_ctx[1]);
ff_mdct_end(&q->mdct_ctx[2]);
AT1Ctx *q = avctx->priv_data;
int ret;
- avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
+ avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
avctx->channels);
return AVERROR(EINVAL);
}
- q->channels = avctx->channels;
-
- if (avctx->channels == 2) {
- q->out_samples[0] = av_malloc(2 * AT1_SU_SAMPLES * sizeof(*q->out_samples[0]));
- q->out_samples[1] = q->out_samples[0] + AT1_SU_SAMPLES;
- if (!q->out_samples[0]) {
- av_freep(&q->out_samples[0]);
- return AVERROR(ENOMEM);
- }
- }
/* Init the mdct transforms */
if ((ret = ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15))) ||
ff_atrac_generate_tables();
- ff_dsputil_init(&q->dsp, avctx);
- ff_fmt_convert_init(&q->fmt_conv, avctx);
+ avpriv_float_dsp_init(&q->fdsp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
q->bands[0] = q->low;
q->bands[1] = q->mid;
q->SUs[1].spectrum[0] = q->SUs[1].spec1;
q->SUs[1].spectrum[1] = q->SUs[1].spec2;
- avcodec_get_frame_defaults(&q->frame);
- avctx->coded_frame = &q->frame;
-
return 0;
}
AVCodec ff_atrac1_decoder = {
.name = "atrac1",
+ .long_name = NULL_IF_CONFIG_SMALL("ATRAC1 (Adaptive TRansform Acoustic Coding)"),
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_ATRAC1,
+ .id = AV_CODEC_ID_ATRAC1,
.priv_data_size = sizeof(AT1Ctx),
.init = atrac1_decode_init,
.close = atrac1_decode_end,
.decode = atrac1_decode_frame,
- .capabilities = CODEC_CAP_DR1,
- .long_name = NULL_IF_CONFIG_SMALL("Atrac 1 (Adaptive TRansform Acoustic Coding)"),
+ .capabilities = AV_CODEC_CAP_DR1,
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+ AV_SAMPLE_FMT_NONE },
};
projects / ffmpeg / blobdiff