path: root/libavcodec/mpegaudiodec.c

/*
 * MPEG Audio decoder
 * Copyright (c) 2001 Gerard Lantau.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "avcodec.h"
#include "mpglib/mpg123.h"

/*
 * TODO: 
 *  - add free format
 *  - do not rely anymore on mpglib (first step: implement dct64 and decoding filter)
 */

#define HEADER_SIZE 4
#define BACKSTEP_SIZE 512

typedef struct MPADecodeContext {
    struct mpstr mpstr;
    UINT8 inbuf1[2][MAXFRAMESIZE + BACKSTEP_SIZE];	/* input buffer */
    int inbuf_index;
    UINT8 *inbuf_ptr, *inbuf;
    int frame_size;
    int error_protection;
    int layer;
    int sample_rate;
    int bit_rate;
    int old_frame_size;
    GetBitContext gb;
} MPADecodeContext;

/* XXX: suppress that mess */
struct mpstr *gmp;
GetBitContext *gmp_gb;
static MPADecodeContext *gmp_s;

/* XXX: merge constants with encoder */
static const unsigned short mp_bitrate_tab[2][3][15] = {
    { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
      {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
      {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },
    { {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256},
      {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160},
      {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
    }
};

static unsigned short mp_freq_tab[3] = { 44100, 48000, 32000 };

static int decode_init(AVCodecContext * avctx)
{
    MPADecodeContext *s = avctx->priv_data;
    struct mpstr *mp = &s->mpstr;
    static int init;

    mp->fr.single = -1;
    mp->synth_bo = 1;

    if(!init) {
        init = 1;
        make_decode_tables(32767);
        init_layer2();
        init_layer3(SBLIMIT);
    }

    s->inbuf_index = 0;
    s->inbuf = &s->inbuf1[s->inbuf_index][BACKSTEP_SIZE];
    s->inbuf_ptr = s->inbuf;
    
    return 0;
}

/* fast header check for resync */
static int check_header(UINT32 header)
{
    /* header */
    if ((header & 0xffe00000) != 0xffe00000)
	return -1;
    /* layer check */
    if (((header >> 17) & 3) == 0)
	return -1;
    /* bit rate : currently no free format supported */
    if (((header >> 12) & 0xf) == 0xf ||
        ((header >> 12) & 0xf) == 0x0)
	return -1;
    /* frequency */
    if (((header >> 10) & 3) == 3)
	return -1;
    return 0;
}

/* header decoding. MUST check the header before because no
   consistency check is done there */
static void decode_header(MPADecodeContext *s, UINT32 header)
{
    struct frame *fr = &s->mpstr.fr;
    int sample_rate, frame_size;

    if (header & (1<<20)) {
        fr->lsf = (header & (1<<19)) ? 0 : 1;
        fr->mpeg25 = 0;
    } else {
        fr->lsf = 1;
        fr->mpeg25 = 1;
    }
    
    s->layer = 4 - ((header >> 17) & 3);
    /* extract frequency */
    fr->sampling_frequency = ((header >> 10) & 3);
    sample_rate = mp_freq_tab[fr->sampling_frequency] >> (fr->lsf + fr->mpeg25);
    fr->sampling_frequency += 3 * (fr->lsf + fr->mpeg25);

    s->error_protection = ((header>>16) & 1) ^ 1;

    fr->bitrate_index = ((header>>12)&0xf);
    fr->padding   = ((header>>9)&0x1);
    fr->extension = ((header>>8)&0x1);
    fr->mode      = ((header>>6)&0x3);
    fr->mode_ext  = ((header>>4)&0x3);
    fr->copyright = ((header>>3)&0x1);
    fr->original  = ((header>>2)&0x1);
    fr->emphasis  = header & 0x3;

    fr->stereo    = (fr->mode == MPG_MD_MONO) ? 1 : 2;

    
    frame_size = mp_bitrate_tab[fr->lsf][s->layer - 1][fr->bitrate_index];
    s->bit_rate = frame_size * 1000;
    switch(s->layer) {
    case 1:
        frame_size = (frame_size * 12000) / sample_rate;
        frame_size = ((frame_size + fr->padding) << 2);
        break;
    case 2:
        frame_size = (frame_size * 144000) / sample_rate;
        frame_size += fr->padding;
        break;
    case 3:
        frame_size = (frame_size * 144000) / (sample_rate << fr->lsf);
        frame_size += fr->padding;
        break;
    }
    s->frame_size = frame_size;
    s->sample_rate = sample_rate;

#if 0
    printf("layer%d, %d Hz, %d kbits/s, %s\n",
           s->layer, s->sample_rate, s->bit_rate, fr->stereo ? "stereo" : "mono");
#endif
}

static int mp_decode_frame(MPADecodeContext *s, 
                           short *samples)
{
    int nb_bytes;
    
    init_get_bits(&s->gb, s->inbuf + HEADER_SIZE, s->inbuf_ptr - s->inbuf - HEADER_SIZE);
    
    /* skip error protection field */
    if (s->error_protection)
        get_bits(&s->gb, 16);

    /* XXX: horrible: global! */
    gmp = &s->mpstr;
    gmp_s = s;
    gmp_gb = &s->gb;

    nb_bytes = 0;
    switch(s->layer) {
    case 1:
        do_layer1(&s->mpstr.fr,(unsigned char *)samples, &nb_bytes);
        break;
    case 2:
        do_layer2(&s->mpstr.fr,(unsigned char *)samples, &nb_bytes);
        break;
    case 3:
        do_layer3(&s->mpstr.fr,(unsigned char *)samples, &nb_bytes);
        s->inbuf_index ^= 1;
        s->inbuf = &s->inbuf1[s->inbuf_index][BACKSTEP_SIZE];
        s->old_frame_size = s->frame_size;
        break;
    default:
        break;
    }
    return nb_bytes;
}

/*
 * seek back in the stream for backstep bytes (at most 511 bytes, and
 * at most in last frame). Note that this is slightly incorrect (data
 * can span more than one block!)  
 */
int set_pointer(long backstep)
{
    UINT8 *ptr;

    /* compute current position in stream */
    ptr = gmp_gb->buf_ptr - (gmp_gb->bit_cnt >> 3);
    /* copy old data before current one */
    ptr -= backstep;
    memcpy(ptr, gmp_s->inbuf1[gmp_s->inbuf_index ^ 1] + 
           BACKSTEP_SIZE + gmp_s->old_frame_size - backstep, backstep);
    /* init get bits again */
    init_get_bits(gmp_gb, ptr, gmp_s->frame_size + backstep);

    return 0;
}

static int decode_frame(AVCodecContext * avctx,
			void *data, int *data_size,
			UINT8 * buf, int buf_size)
{
    MPADecodeContext *s = avctx->priv_data;
    UINT32 header;
    UINT8 *buf_ptr;
    int len, out_size;
    short *out_samples = data;

    *data_size = 0;
    buf_ptr = buf;
    while (buf_size > 0) {
	len = s->inbuf_ptr - s->inbuf;
	if (s->frame_size == 0) {
	    /* no header seen : find one. We need at least 7 bytes to parse it */
	    len = HEADER_SIZE - len;
	    if (len > buf_size)
		len = buf_size;
	    memcpy(s->inbuf_ptr, buf_ptr, len);
	    buf_ptr += len;
	    s->inbuf_ptr += len;
	    buf_size -= len;
	    if ((s->inbuf_ptr - s->inbuf) == HEADER_SIZE) {
		header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
		    (s->inbuf[2] << 8) | s->inbuf[3];
		if (check_header(header) < 0) {
		    /* no sync found : move by one byte (inefficient, but simple!) */
		    memcpy(s->inbuf, s->inbuf + 1, HEADER_SIZE - 1);
		    s->inbuf_ptr--;
		} else {
		    decode_header(s, header);
		    /* update codec info */
		    avctx->sample_rate = s->sample_rate;
                    avctx->channels = s->mpstr.fr.stereo ? 2 : 1;
		    avctx->bit_rate = s->bit_rate;
		}
	    }
	} else if (len < s->frame_size) {
	    len = s->frame_size - len;
	    if (len > buf_size)
		len = buf_size;

	    memcpy(s->inbuf_ptr, buf_ptr, len);
	    buf_ptr += len;
	    s->inbuf_ptr += len;
	    buf_size -= len;
	} else {
            out_size = mp_decode_frame(s, out_samples);
	    s->inbuf_ptr = s->inbuf;
	    s->frame_size = 0;
	    *data_size = out_size;
	    break;
	}
    }
    return buf_ptr - buf;
}

AVCodec mp3_decoder =
{
    "mpegaudio",
    CODEC_TYPE_AUDIO,
    CODEC_ID_MP2,
    sizeof(MPADecodeContext),
    decode_init,
    NULL,
    NULL,
    decode_frame,
};