Libav 0.7.1
libavcodec/atrac1.c
Go to the documentation of this file.
00001 /*
00002  * Atrac 1 compatible decoder
00003  * Copyright (c) 2009 Maxim Poliakovski
00004  * Copyright (c) 2009 Benjamin Larsson
00005  *
00006  * This file is part of Libav.
00007  *
00008  * Libav is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * Libav is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with Libav; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00029 /* Many thanks to Tim Craig for all the help! */
00030 
00031 #include <math.h>
00032 #include <stddef.h>
00033 #include <stdio.h>
00034 
00035 #include "avcodec.h"
00036 #include "get_bits.h"
00037 #include "dsputil.h"
00038 #include "fft.h"
00039 #include "sinewin.h"
00040 
00041 #include "atrac.h"
00042 #include "atrac1data.h"
00043 
00044 #define AT1_MAX_BFU      52                 ///< max number of block floating units in a sound unit
00045 #define AT1_SU_SIZE      212                ///< number of bytes in a sound unit
00046 #define AT1_SU_SAMPLES   512                ///< number of samples in a sound unit
00047 #define AT1_FRAME_SIZE   AT1_SU_SIZE * 2
00048 #define AT1_SU_MAX_BITS  AT1_SU_SIZE * 8
00049 #define AT1_MAX_CHANNELS 2
00050 
00051 #define AT1_QMF_BANDS    3
00052 #define IDX_LOW_BAND     0
00053 #define IDX_MID_BAND     1
00054 #define IDX_HIGH_BAND    2
00055 
00059 typedef struct {
00060     int                 log2_block_count[AT1_QMF_BANDS];    
00061     int                 num_bfus;                           
00062     float*              spectrum[2];
00063     DECLARE_ALIGNED(32, float, spec1)[AT1_SU_SAMPLES];     
00064     DECLARE_ALIGNED(32, float, spec2)[AT1_SU_SAMPLES];     
00065     DECLARE_ALIGNED(32, float, fst_qmf_delay)[46];         
00066     DECLARE_ALIGNED(32, float, snd_qmf_delay)[46];         
00067     DECLARE_ALIGNED(32, float, last_qmf_delay)[256+23];    
00068 } AT1SUCtx;
00069 
00073 typedef struct {
00074     AT1SUCtx            SUs[AT1_MAX_CHANNELS];              
00075     DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES];      
00076 
00077     DECLARE_ALIGNED(32, float,  low)[256];
00078     DECLARE_ALIGNED(32, float,  mid)[256];
00079     DECLARE_ALIGNED(32, float, high)[512];
00080     float*              bands[3];
00081     DECLARE_ALIGNED(32, float, out_samples)[AT1_MAX_CHANNELS][AT1_SU_SAMPLES];
00082     FFTContext          mdct_ctx[3];
00083     int                 channels;
00084     DSPContext          dsp;
00085 } AT1Ctx;
00086 
00088 static const uint16_t samples_per_band[3] = {128, 128, 256};
00089 static const uint8_t   mdct_long_nbits[3] = {7, 7, 8};
00090 
00091 
00092 static void at1_imdct(AT1Ctx *q, float *spec, float *out, int nbits,
00093                       int rev_spec)
00094 {
00095     FFTContext* mdct_context = &q->mdct_ctx[nbits - 5 - (nbits > 6)];
00096     int transf_size = 1 << nbits;
00097 
00098     if (rev_spec) {
00099         int i;
00100         for (i = 0; i < transf_size / 2; i++)
00101             FFSWAP(float, spec[i], spec[transf_size - 1 - i]);
00102     }
00103     mdct_context->imdct_half(mdct_context, out, spec);
00104 }
00105 
00106 
00107 static int at1_imdct_block(AT1SUCtx* su, AT1Ctx *q)
00108 {
00109     int          band_num, band_samples, log2_block_count, nbits, num_blocks, block_size;
00110     unsigned int start_pos, ref_pos = 0, pos = 0;
00111 
00112     for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
00113         float *prev_buf;
00114         int j;
00115 
00116         band_samples = samples_per_band[band_num];
00117         log2_block_count = su->log2_block_count[band_num];
00118 
00119         /* number of mdct blocks in the current QMF band: 1 - for long mode */
00120         /* 4 for short mode(low/middle bands) and 8 for short mode(high band)*/
00121         num_blocks = 1 << log2_block_count;
00122 
00123         if (num_blocks == 1) {
00124             /* mdct block size in samples: 128 (long mode, low & mid bands), */
00125             /* 256 (long mode, high band) and 32 (short mode, all bands) */
00126             block_size = band_samples >> log2_block_count;
00127 
00128             /* calc transform size in bits according to the block_size_mode */
00129             nbits = mdct_long_nbits[band_num] - log2_block_count;
00130 
00131             if (nbits != 5 && nbits != 7 && nbits != 8)
00132                 return -1;
00133         } else {
00134             block_size = 32;
00135             nbits = 5;
00136         }
00137 
00138         start_pos = 0;
00139         prev_buf = &su->spectrum[1][ref_pos + band_samples - 16];
00140         for (j=0; j < num_blocks; j++) {
00141             at1_imdct(q, &q->spec[pos], &su->spectrum[0][ref_pos + start_pos], nbits, band_num);
00142 
00143             /* overlap and window */
00144             q->dsp.vector_fmul_window(&q->bands[band_num][start_pos], prev_buf,
00145                                       &su->spectrum[0][ref_pos + start_pos], ff_sine_32, 16);
00146 
00147             prev_buf = &su->spectrum[0][ref_pos+start_pos + 16];
00148             start_pos += block_size;
00149             pos += block_size;
00150         }
00151 
00152         if (num_blocks == 1)
00153             memcpy(q->bands[band_num] + 32, &su->spectrum[0][ref_pos + 16], 240 * sizeof(float));
00154 
00155         ref_pos += band_samples;
00156     }
00157 
00158     /* Swap buffers so the mdct overlap works */
00159     FFSWAP(float*, su->spectrum[0], su->spectrum[1]);
00160 
00161     return 0;
00162 }
00163 
00168 static int at1_parse_bsm(GetBitContext* gb, int log2_block_cnt[AT1_QMF_BANDS])
00169 {
00170     int log2_block_count_tmp, i;
00171 
00172     for (i = 0; i < 2; i++) {
00173         /* low and mid band */
00174         log2_block_count_tmp = get_bits(gb, 2);
00175         if (log2_block_count_tmp & 1)
00176             return -1;
00177         log2_block_cnt[i] = 2 - log2_block_count_tmp;
00178     }
00179 
00180     /* high band */
00181     log2_block_count_tmp = get_bits(gb, 2);
00182     if (log2_block_count_tmp != 0 && log2_block_count_tmp != 3)
00183         return -1;
00184     log2_block_cnt[IDX_HIGH_BAND] = 3 - log2_block_count_tmp;
00185 
00186     skip_bits(gb, 2);
00187     return 0;
00188 }
00189 
00190 
00191 static int at1_unpack_dequant(GetBitContext* gb, AT1SUCtx* su,
00192                               float spec[AT1_SU_SAMPLES])
00193 {
00194     int bits_used, band_num, bfu_num, i;
00195     uint8_t idwls[AT1_MAX_BFU];                 
00196     uint8_t idsfs[AT1_MAX_BFU];                 
00197 
00198     /* parse the info byte (2nd byte) telling how much BFUs were coded */
00199     su->num_bfus = bfu_amount_tab1[get_bits(gb, 3)];
00200 
00201     /* calc number of consumed bits:
00202         num_BFUs * (idwl(4bits) + idsf(6bits)) + log2_block_count(8bits) + info_byte(8bits)
00203         + info_byte_copy(8bits) + log2_block_count_copy(8bits) */
00204     bits_used = su->num_bfus * 10 + 32 +
00205                 bfu_amount_tab2[get_bits(gb, 2)] +
00206                 (bfu_amount_tab3[get_bits(gb, 3)] << 1);
00207 
00208     /* get word length index (idwl) for each BFU */
00209     for (i = 0; i < su->num_bfus; i++)
00210         idwls[i] = get_bits(gb, 4);
00211 
00212     /* get scalefactor index (idsf) for each BFU */
00213     for (i = 0; i < su->num_bfus; i++)
00214         idsfs[i] = get_bits(gb, 6);
00215 
00216     /* zero idwl/idsf for empty BFUs */
00217     for (i = su->num_bfus; i < AT1_MAX_BFU; i++)
00218         idwls[i] = idsfs[i] = 0;
00219 
00220     /* read in the spectral data and reconstruct MDCT spectrum of this channel */
00221     for (band_num = 0; band_num < AT1_QMF_BANDS; band_num++) {
00222         for (bfu_num = bfu_bands_t[band_num]; bfu_num < bfu_bands_t[band_num+1]; bfu_num++) {
00223             int pos;
00224 
00225             int num_specs = specs_per_bfu[bfu_num];
00226             int word_len  = !!idwls[bfu_num] + idwls[bfu_num];
00227             float scale_factor = ff_atrac_sf_table[idsfs[bfu_num]];
00228             bits_used += word_len * num_specs; /* add number of bits consumed by current BFU */
00229 
00230             /* check for bitstream overflow */
00231             if (bits_used > AT1_SU_MAX_BITS)
00232                 return -1;
00233 
00234             /* get the position of the 1st spec according to the block size mode */
00235             pos = su->log2_block_count[band_num] ? bfu_start_short[bfu_num] : bfu_start_long[bfu_num];
00236 
00237             if (word_len) {
00238                 float   max_quant = 1.0 / (float)((1 << (word_len - 1)) - 1);
00239 
00240                 for (i = 0; i < num_specs; i++) {
00241                     /* read in a quantized spec and convert it to
00242                      * signed int and then inverse quantization
00243                      */
00244                     spec[pos+i] = get_sbits(gb, word_len) * scale_factor * max_quant;
00245                 }
00246             } else { /* word_len = 0 -> empty BFU, zero all specs in the emty BFU */
00247                 memset(&spec[pos], 0, num_specs * sizeof(float));
00248             }
00249         }
00250     }
00251 
00252     return 0;
00253 }
00254 
00255 
00256 static void at1_subband_synthesis(AT1Ctx *q, AT1SUCtx* su, float *pOut)
00257 {
00258     float temp[256];
00259     float iqmf_temp[512 + 46];
00260 
00261     /* combine low and middle bands */
00262     atrac_iqmf(q->bands[0], q->bands[1], 128, temp, su->fst_qmf_delay, iqmf_temp);
00263 
00264     /* delay the signal of the high band by 23 samples */
00265     memcpy( su->last_qmf_delay,    &su->last_qmf_delay[256], sizeof(float) *  23);
00266     memcpy(&su->last_qmf_delay[23], q->bands[2],             sizeof(float) * 256);
00267 
00268     /* combine (low + middle) and high bands */
00269     atrac_iqmf(temp, su->last_qmf_delay, 256, pOut, su->snd_qmf_delay, iqmf_temp);
00270 }
00271 
00272 
00273 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
00274                                int *data_size, AVPacket *avpkt)
00275 {
00276     const uint8_t *buf = avpkt->data;
00277     int buf_size       = avpkt->size;
00278     AT1Ctx *q          = avctx->priv_data;
00279     int ch, ret, i;
00280     GetBitContext gb;
00281     float* samples = data;
00282 
00283 
00284     if (buf_size < 212 * q->channels) {
00285         av_log(q,AV_LOG_ERROR,"Not enought data to decode!\n");
00286         return -1;
00287     }
00288 
00289     for (ch = 0; ch < q->channels; ch++) {
00290         AT1SUCtx* su = &q->SUs[ch];
00291 
00292         init_get_bits(&gb, &buf[212 * ch], 212 * 8);
00293 
00294         /* parse block_size_mode, 1st byte */
00295         ret = at1_parse_bsm(&gb, su->log2_block_count);
00296         if (ret < 0)
00297             return ret;
00298 
00299         ret = at1_unpack_dequant(&gb, su, q->spec);
00300         if (ret < 0)
00301             return ret;
00302 
00303         ret = at1_imdct_block(su, q);
00304         if (ret < 0)
00305             return ret;
00306         at1_subband_synthesis(q, su, q->out_samples[ch]);
00307     }
00308 
00309     /* interleave; FIXME, should create/use a DSP function */
00310     if (q->channels == 1) {
00311         /* mono */
00312         memcpy(samples, q->out_samples[0], AT1_SU_SAMPLES * 4);
00313     } else {
00314         /* stereo */
00315         for (i = 0; i < AT1_SU_SAMPLES; i++) {
00316             samples[i * 2]     = q->out_samples[0][i];
00317             samples[i * 2 + 1] = q->out_samples[1][i];
00318         }
00319     }
00320 
00321     *data_size = q->channels * AT1_SU_SAMPLES * sizeof(*samples);
00322     return avctx->block_align;
00323 }
00324 
00325 
00326 static av_cold int atrac1_decode_init(AVCodecContext *avctx)
00327 {
00328     AT1Ctx *q = avctx->priv_data;
00329 
00330     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00331 
00332     q->channels = avctx->channels;
00333 
00334     /* Init the mdct transforms */
00335     ff_mdct_init(&q->mdct_ctx[0], 6, 1, -1.0/ (1 << 15));
00336     ff_mdct_init(&q->mdct_ctx[1], 8, 1, -1.0/ (1 << 15));
00337     ff_mdct_init(&q->mdct_ctx[2], 9, 1, -1.0/ (1 << 15));
00338 
00339     ff_init_ff_sine_windows(5);
00340 
00341     atrac_generate_tables();
00342 
00343     dsputil_init(&q->dsp, avctx);
00344 
00345     q->bands[0] = q->low;
00346     q->bands[1] = q->mid;
00347     q->bands[2] = q->high;
00348 
00349     /* Prepare the mdct overlap buffers */
00350     q->SUs[0].spectrum[0] = q->SUs[0].spec1;
00351     q->SUs[0].spectrum[1] = q->SUs[0].spec2;
00352     q->SUs[1].spectrum[0] = q->SUs[1].spec1;
00353     q->SUs[1].spectrum[1] = q->SUs[1].spec2;
00354 
00355     return 0;
00356 }
00357 
00358 
00359 static av_cold int atrac1_decode_end(AVCodecContext * avctx) {
00360     AT1Ctx *q = avctx->priv_data;
00361 
00362     ff_mdct_end(&q->mdct_ctx[0]);
00363     ff_mdct_end(&q->mdct_ctx[1]);
00364     ff_mdct_end(&q->mdct_ctx[2]);
00365     return 0;
00366 }
00367 
00368 
00369 AVCodec ff_atrac1_decoder = {
00370     .name = "atrac1",
00371     .type = AVMEDIA_TYPE_AUDIO,
00372     .id = CODEC_ID_ATRAC1,
00373     .priv_data_size = sizeof(AT1Ctx),
00374     .init = atrac1_decode_init,
00375     .close = atrac1_decode_end,
00376     .decode = atrac1_decode_frame,
00377     .long_name = NULL_IF_CONFIG_SMALL("Atrac 1 (Adaptive TRansform Acoustic Coding)"),
00378 };