00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00034 #include "libavutil/channel_layout.h"
00035 #include "libavutil/lfg.h"
00036 #include "libavutil/random_seed.h"
00037 #include "avcodec.h"
00038 #include "dsputil.h"
00039 #include "fft.h"
00040 #include "fmtconvert.h"
00041 #include "internal.h"
00042 #include "nellymoser.h"
00043 #include "sinewin.h"
00044
00045 #define BITSTREAM_READER_LE
00046 #include "get_bits.h"
00047
00048
00049 typedef struct NellyMoserDecodeContext {
00050 AVCodecContext* avctx;
00051 AVFrame frame;
00052 AVLFG random_state;
00053 GetBitContext gb;
00054 float scale_bias;
00055 DSPContext dsp;
00056 FFTContext imdct_ctx;
00057 DECLARE_ALIGNED(32, float, imdct_buf)[2][NELLY_BUF_LEN];
00058 float *imdct_out;
00059 float *imdct_prev;
00060 } NellyMoserDecodeContext;
00061
00062 static void nelly_decode_block(NellyMoserDecodeContext *s,
00063 const unsigned char block[NELLY_BLOCK_LEN],
00064 float audio[NELLY_SAMPLES])
00065 {
00066 int i,j;
00067 float buf[NELLY_FILL_LEN], pows[NELLY_FILL_LEN];
00068 float *aptr, *bptr, *pptr, val, pval;
00069 int bits[NELLY_BUF_LEN];
00070 unsigned char v;
00071
00072 init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
00073
00074 bptr = buf;
00075 pptr = pows;
00076 val = ff_nelly_init_table[get_bits(&s->gb, 6)];
00077 for (i=0 ; i<NELLY_BANDS ; i++) {
00078 if (i > 0)
00079 val += ff_nelly_delta_table[get_bits(&s->gb, 5)];
00080 pval = -pow(2, val/2048) * s->scale_bias;
00081 for (j = 0; j < ff_nelly_band_sizes_table[i]; j++) {
00082 *bptr++ = val;
00083 *pptr++ = pval;
00084 }
00085
00086 }
00087
00088 ff_nelly_get_sample_bits(buf, bits);
00089
00090 for (i = 0; i < 2; i++) {
00091 aptr = audio + i * NELLY_BUF_LEN;
00092
00093 init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
00094 skip_bits_long(&s->gb, NELLY_HEADER_BITS + i*NELLY_DETAIL_BITS);
00095
00096 for (j = 0; j < NELLY_FILL_LEN; j++) {
00097 if (bits[j] <= 0) {
00098 aptr[j] = M_SQRT1_2*pows[j];
00099 if (av_lfg_get(&s->random_state) & 1)
00100 aptr[j] *= -1.0;
00101 } else {
00102 v = get_bits(&s->gb, bits[j]);
00103 aptr[j] = ff_nelly_dequantization_table[(1<<bits[j])-1+v]*pows[j];
00104 }
00105 }
00106 memset(&aptr[NELLY_FILL_LEN], 0,
00107 (NELLY_BUF_LEN - NELLY_FILL_LEN) * sizeof(float));
00108
00109 s->imdct_ctx.imdct_half(&s->imdct_ctx, s->imdct_out, aptr);
00110 s->dsp.vector_fmul_window(aptr, s->imdct_prev + NELLY_BUF_LEN/2, s->imdct_out, ff_sine_128, NELLY_BUF_LEN/2);
00111 FFSWAP(float *, s->imdct_out, s->imdct_prev);
00112 }
00113 }
00114
00115 static av_cold int decode_init(AVCodecContext * avctx) {
00116 NellyMoserDecodeContext *s = avctx->priv_data;
00117
00118 s->avctx = avctx;
00119 s->imdct_out = s->imdct_buf[0];
00120 s->imdct_prev = s->imdct_buf[1];
00121 av_lfg_init(&s->random_state, 0);
00122 ff_mdct_init(&s->imdct_ctx, 8, 1, 1.0);
00123
00124 ff_dsputil_init(&s->dsp, avctx);
00125
00126 s->scale_bias = 1.0/(32768*8);
00127 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00128
00129
00130 if (!ff_sine_128[127])
00131 ff_init_ff_sine_windows(7);
00132
00133 avctx->channels = 1;
00134 avctx->channel_layout = AV_CH_LAYOUT_MONO;
00135
00136 avcodec_get_frame_defaults(&s->frame);
00137 avctx->coded_frame = &s->frame;
00138
00139 return 0;
00140 }
00141
00142 static int decode_tag(AVCodecContext *avctx, void *data,
00143 int *got_frame_ptr, AVPacket *avpkt)
00144 {
00145 const uint8_t *buf = avpkt->data;
00146 const uint8_t *side=av_packet_get_side_data(avpkt, 'F', NULL);
00147 int buf_size = avpkt->size;
00148 NellyMoserDecodeContext *s = avctx->priv_data;
00149 int blocks, i, ret;
00150 float *samples_flt;
00151
00152 blocks = buf_size / NELLY_BLOCK_LEN;
00153
00154 if (blocks <= 0) {
00155 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
00156 return AVERROR_INVALIDDATA;
00157 }
00158
00159 if (buf_size % NELLY_BLOCK_LEN) {
00160 av_log(avctx, AV_LOG_WARNING, "Leftover bytes: %d.\n",
00161 buf_size % NELLY_BLOCK_LEN);
00162 }
00163
00164
00165
00166
00167
00168
00169
00170 if(side && blocks>1 && avctx->sample_rate%11025==0 && (1<<((side[0]>>2)&3)) == blocks)
00171 avctx->sample_rate= 11025*(blocks/2);
00172
00173
00174 s->frame.nb_samples = NELLY_SAMPLES * blocks;
00175 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
00176 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00177 return ret;
00178 }
00179 samples_flt = (float *)s->frame.data[0];
00180
00181 for (i=0 ; i<blocks ; i++) {
00182 nelly_decode_block(s, buf, samples_flt);
00183 samples_flt += NELLY_SAMPLES;
00184 buf += NELLY_BLOCK_LEN;
00185 }
00186
00187 *got_frame_ptr = 1;
00188 *(AVFrame *)data = s->frame;
00189
00190 return buf_size;
00191 }
00192
00193 static av_cold int decode_end(AVCodecContext * avctx) {
00194 NellyMoserDecodeContext *s = avctx->priv_data;
00195
00196 ff_mdct_end(&s->imdct_ctx);
00197
00198 return 0;
00199 }
00200
00201 AVCodec ff_nellymoser_decoder = {
00202 .name = "nellymoser",
00203 .type = AVMEDIA_TYPE_AUDIO,
00204 .id = AV_CODEC_ID_NELLYMOSER,
00205 .priv_data_size = sizeof(NellyMoserDecodeContext),
00206 .init = decode_init,
00207 .close = decode_end,
00208 .decode = decode_tag,
00209 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_PARAM_CHANGE,
00210 .long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
00211 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
00212 AV_SAMPLE_FMT_NONE },
00213 };