~ubuntu-branches/ubuntu/intrepid/gstreamer0.10-ffmpeg/intrepid

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 */

 

/**

 * @file mpegaudiodec.c

 * MPEG Audio decoder.

 

//#define DEBUG

#include "avcodec.h"

struct GranuleDef;

 

typedef struct MPADecodeContext {

    int inbuf_index;

    uint8_t *inbuf_ptr, *inbuf;

    int frame_size;

    int free_format_frame_size; /* frame size in case of free format

                                   (zero if currently unknown) */

    /* next header (used in free format parsing) */

    int error_protection;

    int layer;

    int sample_rate;

static void compute_antialias_float(MPADecodeContext *s, GranuleDef *g);

 

/* vlc structure for decoding layer 3 huffman tables */

static uint8_t *huff_code_table[16];

static VLC huff_quad_vlc[2];

/* computed from band_size_long */

 

void ff_mpa_synth_init(MPA_INT *window);

static MPA_INT window[512] __attribute__((aligned(16)));

/* layer 1 unscaling */

/* n = number of bits of the mantissa minus 1 */

static inline int l1_unscale(int n, int mant, int scale_factor)

{

    int e, er, eq, j;

    int a, a1;

    /* renormalize */

    a = i;

    e = POW_FRAC_BITS;

    avctx->sample_fmt= SAMPLE_FMT_S32;

#else

    avctx->sample_fmt= SAMPLE_FMT_S16;

    if(avctx->antialias_algo != FF_AA_FLOAT)

        s->compute_antialias= compute_antialias_integer;

    else

            scale_factor_mult[i][1] = MULL(FIXR(0.7937005259 * 2.0), norm);

            scale_factor_mult[i][2] = MULL(FIXR(0.6299605249 * 2.0), norm);

            dprintf("%d: norm=%x s=%x %x %x\n",

                    scale_factor_mult[i][0],

                    scale_factor_mult[i][1],

                    scale_factor_mult[i][2]);

        }

        /* huffman decode tables */

        huff_code_table[0] = NULL;

        for(i=1;i<16;i++) {

            const HuffTable *h = &mpa_huff_tables[i];

            unsigned int n;

            uint8_t *code_table;

 

            xsize = h->xsize;

            n = xsize * xsize;

            /* XXX: fail test */

                     h->bits, 1, 1, h->codes, 2, 2, 1);

            code_table = av_mallocz(n);

            j = 0;

            for(x=0;x<xsize;x++) {

            huff_code_table[i] = code_table;

        }

        for(i=0;i<2;i++) {

                     mpa_quad_bits[i], 1, 1, mpa_quad_codes[i], 1, 1, 1);

        }

 

            band_index_long[i][22] = k;

        }

 

        if(!table_4_3_exp)

        if(!table_4_3_value)

            return -1;

        int_pow_init();

        for(i=1;i<TABLE_4_3_SIZE;i++) {

            double f, fm;

//            av_log(NULL, AV_LOG_DEBUG, "%d %d %f\n", i, m, pow((double)i, 4.0 / 3.0));

            table_4_3_exp[i] = -e;

        }

        for(i=0;i<7;i++) {

            float f;

            int v;

                k = i & 1;

                is_table_lsf[j][k ^ 1][i] = FIXR(f);

                is_table_lsf[j][k][i] = FIXR(1.0);

                        i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);

            }

        }

            csa_table[i][0] = FIXHR(cs/4);

            csa_table[i][1] = FIXHR(ca/4);

            csa_table[i][2] = FIXHR(ca/4) + FIXHR(cs/4);

            csa_table_float[i][0] = cs;

            csa_table_float[i][1] = ca;

            csa_table_float[i][2] = ca + cs;

//            printf("%d %d %d %d\n", FIX(cs), FIX(cs-1), FIX(ca), FIX(cs)-FIX(ca));

//            av_log(NULL, AV_LOG_DEBUG,"%f %f %f %f\n", cs, ca, ca+cs, ca-cs);

        }

        for(i=0;i<36;i++) {

            for(j=0; j<4; j++){

                double d;

                if(j==2 && i%3 != 1)

                    continue;

                d= sin(M_PI * (i + 0.5) / 36.0);

                if(j==1){

                    if     (i>=30) d= 0;

    BF(5, 10, COS1_5);

    BF(6,  9, COS1_6);

    BF(7,  8, COS1_7);

    BF(16, 31, -COS1_0);

    BF(17, 30, -COS1_1);

    BF(18, 29, -COS1_2);

    BF(21, 26, -COS1_5);

    BF(22, 25, -COS1_6);

    BF(23, 24, -COS1_7);

    /* pass 3 */

    BF(0, 7, COS2_0);

    BF(1, 6, COS2_1);

    BF(2, 5, COS2_2);

    BF(3, 4, COS2_3);

    BF(8, 15, -COS2_0);

    BF(9, 14, -COS2_1);

    BF(10, 13, -COS2_2);

    BF(11, 12, -COS2_3);

    BF(16, 23, COS2_0);

    BF(17, 22, COS2_1);

    BF(18, 21, COS2_2);

    BF(19, 20, COS2_3);

    BF(24, 31, -COS2_0);

    BF(25, 30, -COS2_1);

    BF(26, 29, -COS2_2);

    /* pass 4 */

    BF(0, 3, COS3_0);

    BF(1, 2, COS3_1);

    BF(4, 7, -COS3_0);

    BF(5, 6, -COS3_1);

    BF(8, 11, COS3_0);

    BF(9, 10, COS3_1);

    BF(12, 15, -COS3_0);

    BF(13, 14, -COS3_1);

    BF(16, 19, COS3_0);

    BF(17, 18, COS3_1);

    BF(20, 23, -COS3_0);

    BF(21, 22, -COS3_1);

    BF(24, 27, COS3_0);

    BF(25, 26, COS3_1);

    BF(28, 31, -COS3_0);

    BF(29, 30, -COS3_1);

    /* pass 5 */

    BF1(0, 1, 2, 3);

    BF2(4, 5, 6, 7);

    BF2(20, 21, 22, 23);

    BF1(24, 25, 26, 27);

    BF2(28, 29, 30, 31);

    /* pass 6 */

    ADD( 8, 12);

    ADD(12, 10);

    ADD(10, 14);

    out[22] = tab[13];

    out[14] = tab[14];

    out[30] = tab[15];

    ADD(24, 28);

    ADD(28, 26);

    ADD(26, 30);

 

#else

 

{

    int sum1;

    sum1 = (int)((*sum) >> OUT_SHIFT);

            v = -v;

        if (i != 0)

            window[512 - i] = v;

}

 

/* 32 sub band synthesis filter. Input: 32 sub band samples, Output:

   32 samples. */

/* XXX: optimize by avoiding ring buffer usage */

void ff_mpa_synth_filter(MPA_INT *synth_buf_ptr, int *synth_buf_offset,

                         int32_t sb_samples[SBLIMIT])

{

    int32_t tmp[32];

#endif

 

    dct32(tmp, sb_samples);

    offset = *synth_buf_offset;

    synth_buf = synth_buf_ptr + offset;

 

        w++;

        w2--;

    }

    p = synth_buf + 32;

    SUM8(sum, -=, w + 32, p);

    *samples = round_sample(&sum);

 

    in2= MULH(2*in2, C3);

    in3= MULH(2*in3, C3);

    t1 = in0 - in4;

    t2 = MULL(in1 - in5, icos36[4]);

 

    out[10]= t1 + t2;

    out[ 1]=

    out[ 4]= t1 - t2;

    in0 += in4>>1;

    in4 = in0 + in2;

    in1 += in5>>1;

    out[ 9]= in4 + in5;

    out[ 2]=

    out[ 3]= in4 - in5;

    in0 -= in2;

    in1 = MULL(in1 - in3, icos36[7]);

    out[ 0]=

    out[ 5]= in0 - in1;

    out[ 6]=

}

 

/* cos(pi*i/18) */

//more accurate but slower

        int64_t t0, t1, t2, t3;

        t2 = in1[2*4] + in1[2*8] - in1[2*2];

        t3 = (in1[2*0] + (int64_t)(in1[2*6]>>1))<<32;

        t1 = in1[2*0] - in1[2*6];

        tmp1[ 6] = t1 - (t2>>1);

        t0 = MUL64(2*(in1[2*2] + in1[2*4]),    C2);

        t1 = MUL64(   in1[2*4] - in1[2*8] , -2*C8);

        t2 = MUL64(2*(in1[2*2] + in1[2*8]),   -C4);

        tmp1[10] = (t3 - t0 - t2) >> 32;

        tmp1[ 2] = (t3 + t0 + t1) >> 32;

        tmp1[14] = (t3 + t2 - t1) >> 32;

        tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);

        t2 = MUL64(2*(in1[2*1] + in1[2*5]),    C1);

        t3 = MUL64(   in1[2*5] - in1[2*7] , -2*C7);

        tmp1[ 8] = (t3 - t1 - t0) >> 32;

#else

        t2 = in1[2*4] + in1[2*8] - in1[2*2];

        t3 = in1[2*0] + (in1[2*6]>>1);

        t1 = in1[2*0] - in1[2*6];

        tmp1[ 6] = t1 - (t2>>1);

        t0 = MULH(2*(in1[2*2] + in1[2*4]),    C2);

        t1 = MULH(   in1[2*4] - in1[2*8] , -2*C8);

        t2 = MULH(2*(in1[2*2] + in1[2*8]),   -C4);

        tmp1[10] = t3 - t0 - t2;

        tmp1[ 2] = t3 + t0 + t1;

        tmp1[14] = t3 + t2 - t1;

        tmp1[ 4] = MULH(2*(in1[2*5] + in1[2*7] - in1[2*1]), -C3);

        t2 = MULH(2*(in1[2*1] + in1[2*5]),    C1);

        t3 = MULH(   in1[2*5] - in1[2*7] , -2*C7);

        t3 = tmp[i + 3];

        s1 = MULL(t3 + t2, icos36[j]);

        s3 = MULL(t3 - t2, icos36[8 - j]);

        t0 = s0 + s1;

        t1 = s0 - s1;

        out[(9 + j)*SBLIMIT] =  MULH(t1, win[9 + j]) + buf[9 + j];

        out[(8 - j)*SBLIMIT] =  MULH(t1, win[8 - j]) + buf[8 - j];

        buf[9 + j] = MULH(t0, win[18 + 9 + j]);

        buf[8 - j] = MULH(t0, win[18 + 8 - j]);

        t0 = s2 + s3;

        t1 = s2 - s3;

        out[(9 + 8 - j)*SBLIMIT] =  MULH(t1, win[9 + 8 - j]) + buf[9 + 8 - j];

        s->lsf = 1;

        mpeg25 = 1;

    }

    s->layer = 4 - ((header >> 17) & 3);

    /* extract frequency */

    sample_rate_index = (header >> 10) & 3;

        s->nb_channels = 1;

    else

        s->nb_channels = 2;

    if (bitrate_index != 0) {

        frame_size = mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index];

        s->bit_rate = frame_size * 1000;

            break;

        }

    }

#if defined(DEBUG)

    printf("layer%d, %d Hz, %d kbits/s, ",

           s->layer, s->sample_rate, s->bit_rate);

    uint8_t allocation[MPA_MAX_CHANNELS][SBLIMIT];

    uint8_t scale_factors[MPA_MAX_CHANNELS][SBLIMIT];

 

        bound = (s->mode_ext + 1) * 4;

    else

        bound = SBLIMIT;

            scale_factors[1][i] = get_bits(&s->gb, 6);

        }

    }

    /* compute samples */

    for(j=0;j<12;j++) {

        for(i=0;i<bound;i++) {

int l2_select_table(int bitrate, int nb_channels, int freq, int lsf)

{

    int ch_bitrate, table;

    ch_bitrate = bitrate / nb_channels;

    if (!lsf) {

        if ((freq == 48000 && ch_bitrate >= 56) ||

            table = 0;

            table = 1;

            table = 2;

            table = 3;

    } else {

        table = 4;

    int scale, qindex, bits, steps, k, l, m, b;

 

    /* select decoding table */

                            s->sample_rate, s->lsf);

    sblimit = sblimit_table[table];

    alloc_table = alloc_tables[table];

 

        bound = (s->mode_ext + 1) * 4;

    else

        bound = sblimit;

    /* scale codes */

    for(i=0;i<sblimit;i++) {

        for(ch=0;ch<s->nb_channels;ch++) {

                scale_code[ch][i] = get_bits(&s->gb, 2);

        }

    }

    /* scale factors */

    for(i=0;i<sblimit;i++) {

        for(ch=0;ch<s->nb_channels;ch++) {

                            /* 3 values at the same time */

                            v = get_bits(&s->gb, -bits);

                            steps = quant_steps[qindex];

                                l2_unscale_group(steps, v, scale);

                        } else {

                            for(m=0;m<3;m++) {

                    }

                }

                /* next subband in alloc table */

            }

            /* XXX: find a way to avoid this duplication of code */

            for(i=bound;i<sblimit;i++) {

                        steps = quant_steps[qindex];

                        mant = v % steps;

                        v = v / steps;

                            l2_unscale_group(steps, mant, scale0);

                            l2_unscale_group(steps, mant, scale1);

                        mant = v % steps;

                        v = v / steps;

                            l2_unscale_group(steps, mant, scale0);

                            l2_unscale_group(steps, mant, scale1);

                            l2_unscale_group(steps, v, scale0);

                            l2_unscale_group(steps, v, scale1);

                    } else {

                        for(m=0;m<3;m++) {

                            mant = get_bits(&s->gb, bits);

                                l1_unscale(bits - 1, mant, scale0);

                                l1_unscale(bits - 1, mant, scale1);

                        }

                    }

                    s->sb_samples[1][k * 12 + l + 2][i] = 0;

                }

                /* next subband in alloc table */

            }

            /* fill remaining samples to zero */

            for(i=sblimit;i<SBLIMIT;i++) {

 

    /* copy old data before current one */

    ptr -= backstep;

           BACKSTEP_SIZE + s->old_frame_size - backstep, backstep);

    /* init get bits again */

    init_get_bits(&s->gb, ptr, (s->frame_size + backstep)*8);

    slen[0] = sf;

}

 

                                         GranuleDef *g,

                                         int16_t *exponents)

{

            if (get_bits_count(&s->gb) >= end_pos)

                break;

            if (code_table) {

                if (code < 0)

                    return -1;

                y = code_table[code];

                x = 0;

                y = 0;

            }

                    i, g->region_size[i] - j, x, y, exponents[s_index]);

            if (x) {

                if (x == 15)

            g->sb_hybrid[s_index++] = v;

        }

    }

    /* high frequencies */

    vlc = &huff_quad_vlc[g->count1table_select];

    last_gb.buffer = NULL;

        }

        last_gb= s->gb;

 

        dprintf("t=%d code=%d\n", g->count1table_select, code);

        if (code < 0)

            return -1;

    } else {

        ptr = g->sb_hybrid;

    }

    for(i=g->short_start;i<13;i++) {

        len = band_size_short[s->sample_rate_index][i];

        ptr1 = ptr;

            is_tab = is_table_lsf[g1->scalefac_compress & 1];

            sf_max = 16;

        }

        tab0 = g0->sb_hybrid + 576;

        tab1 = g1->sb_hybrid + 576;

 

            }

        }

 

            non_zero_found_short[2];

 

        for(i = g1->long_end - 1;i >= 0;i--) {

    } else {

        n = SBLIMIT - 1;

    }

    ptr = g->sb_hybrid + 18;

    for(i = n;i > 0;i--) {

        int tmp0, tmp1, tmp2;

        INT_AA(5)

        INT_AA(6)

        INT_AA(7)

    }

}

 

    } else {

        n = SBLIMIT - 1;

    }

    ptr = g->sb_hybrid + 18;

    for(i = n;i > 0;i--) {

        float tmp0, tmp1;

#define FLOAT_AA(j)\

        tmp0= ptr[-1-j];\

        tmp1= ptr[   j];\

        ptr[-1-j] = lrintf(tmp0 * csa[0+4*j] - tmp1 * csa[1+4*j]);\

        ptr[   j] = lrintf(tmp0 * csa[1+4*j] + tmp1 * csa[0+4*j]);

        FLOAT_AA(0)

        FLOAT_AA(1)

        FLOAT_AA(2)

        FLOAT_AA(6)

        FLOAT_AA(7)

 

    }

}

 

static void compute_imdct(MPADecodeContext *s,

                          int32_t *sb_samples,

                          int32_t *mdct_buf)

{

        /* select frequency inversion */

        win = mdct_win[2] + ((4 * 36) & -(j & 1));

        out_ptr = sb_samples + j;

        for(i=0; i<6; i++){

            *out_ptr = buf[i];

            out_ptr += SBLIMIT;

    char buf[512];

    int i;

    int32_t v;

    f = files[fnum];

    if (!f) {

#ifdef USE_HIGHPRECISION

                "hp"

#else

            return;

        files[fnum] = f;

    }

    if (fnum == 0) {

        static int pos = 0;

        av_log(NULL, AV_LOG_DEBUG, "pos=%d\n", pos);

            granules[ch][1].scfsi = get_bits(&s->gb, 4);

        }

    }

    for(gr=0;gr<nb_granules;gr++) {

        for(ch=0;ch<s->nb_channels;ch++) {

            dprintf("gr=%d ch=%d: side_info\n", gr, ch);

            g->global_gain = get_bits(&s->gb, 8);

            /* if MS stereo only is selected, we precompute the

               1/sqrt(2) renormalization factor */

                MODE_EXT_MS_STEREO)

                g->global_gain -= 2;

            if (s->lsf)

                g->switch_point = get_bits(&s->gb, 1);

                for(i=0;i<2;i++)

                    g->table_select[i] = get_bits(&s->gb, 5);

                    g->subblock_gain[i] = get_bits(&s->gb, 3);

                /* compute huffman coded region sizes */

                if (g->block_type == 2)

                    g->region_size[0] = (36 / 2);

                else {

                        g->region_size[0] = (36 / 2);

                        g->region_size[0] = (54 / 2);

                    else

                        g->region_size[0] = (108 / 2);

                /* compute huffman coded region sizes */

                region_address1 = get_bits(&s->gb, 4);

                region_address2 = get_bits(&s->gb, 3);

                        region_address1, region_address2);

                    band_index_long[s->sample_rate_index][region_address1 + 1] >> 1;

                l = region_address1 + region_address2 + 2;

                /* should not overflow */

                if (l > 22)

                    l = 22;

                    band_index_long[s->sample_rate_index][l] >> 1;

            }

            /* convert region offsets to region sizes and truncate

                        g->long_end = 6;

                    else

                        g->long_end = 4; /* 8000 Hz */

                    if (s->sample_rate_index != 8)

                        g->short_start = 3;

                    else

                } else {

                    g->long_end = 0;

                    g->short_start = 0;

                g->short_start = 13;

                g->long_end = 22;

            }

            g->preflag = 0;

            if (!s->lsf)

                g->preflag = get_bits(&s->gb, 1);

    for(gr=0;gr<nb_granules;gr++) {

        for(ch=0;ch<s->nb_channels;ch++) {

            g = &granules[ch][gr];

            bits_pos = get_bits_count(&s->gb);

            if (!s->lsf) {

                uint8_t *sc;

                int slen, slen1, slen2;

                }

#if defined(DEBUG)

                {

                           g->scfsi, gr, ch);

                    for(i=0;i<j;i++)

                        printf(" %d", g->scale_factors[i]);

                    g->scale_factors[j] = 0;

#if defined(DEBUG)

                {

                           gr, ch);

                    for(i=0;i<40;i++)

                        printf(" %d", g->scale_factors[i]);

#if defined(DEBUG)

            sample_dump(1, g->sb_hybrid, 576);

#endif

#if defined(DEBUG)

            sample_dump(2, &s->sb_samples[ch][18 * gr][0], 576);

#endif

    return nb_granules * 18;

}

 

                           OUT_INT *samples)

{

    int i, nb_frames, ch;

    OUT_INT *samples_ptr;

 

                  (s->inbuf_ptr - s->inbuf - HEADER_SIZE)*8);

    /* skip error protection field */

    if (s->error_protection)

        get_bits(&s->gb, 16);

        samples_ptr = samples + ch;

        for(i=0;i<nb_frames;i++) {

            ff_mpa_synth_filter(s->synth_buf[ch], &(s->synth_buf_offset[ch]),

                         s->sb_samples[ch][i]);

            samples_ptr += 32 * s->nb_channels;

        }

    }

#ifdef DEBUG

#endif

    return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;

}

 

static int decode_frame(AVCodecContext * avctx,

{

    MPADecodeContext *s = avctx->priv_data;

    uint32_t header;

 

    buf_ptr = buf;

    while (buf_size > 0) {

            /* special case for next header for first frame in free

               format case (XXX: find a simpler method) */

            if (s->free_format_next_header != 0) {

                s->free_format_next_header = 0;

                goto got_header;

            }

               bytes to parse it */

            got_header:

 

                    dprintf("skip %x\n", header);

                    /* reset free format frame size to give a chance

                       to get a new bitrate */

                    s->free_format_frame_size = 0;

                        /* free format: prepare to compute frame size */

                    }

                    /* update codec info */

                    avctx->sample_rate = s->sample_rate;

                            avctx->frame_size = 1152;

                        break;

                    }

        } else if (s->frame_size == -1) {

            /* free format : find next sync to compute frame size */

            if (len == 0) {

                s->frame_size = 0;

            } else {

                uint8_t *p, *pend;

                uint32_t header1;

                            s->free_format_frame_size -= padding * 4;

                        else

                            s->free_format_frame_size -= padding;

                                s->free_format_frame_size, padding);

                        decode_header(s, header1);

                        goto next_data;

                s->inbuf_ptr += len;

                buf_size -= len;

            }

            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)

                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;

    next_data:

            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {

            if (avctx->parse_only) {

                /* simply return the frame data */

            } else {

                out_size = mp_decode_frame(s, out_samples);

            }

            if(out_size>=0)

            else

                av_log(avctx, AV_LOG_DEBUG, "Error while decoding mpeg audio frame\n"); //FIXME return -1 / but also return the number of bytes consumed

    }

    return buf_ptr - buf;

}

 

 

static int decode_frame_adu(AVCodecContext * avctx,

{

    MPADecodeContext *s = avctx->priv_data;

    uint32_t header;

 

 

static int decode_frame_mp3on4(AVCodecContext * avctx,

{

    MP3On4DecodeContext *s = avctx->priv_data;

    MPADecodeContext *m;