Revision 861c63a2

View differences:

libavcodec/adpcm.c
34 34
 * EA IMA EACS decoder by Peter Ross (pross@xvid.org)
35 35
 * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)
36 36
 * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)
37
 * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)
37 38
 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)
38 39
 *
39 40
 * Features and limitations:
......
666 667
static av_cold int adpcm_decode_init(AVCodecContext * avctx)
667 668
{
668 669
    ADPCMContext *c = avctx->priv_data;
669
    unsigned int max_channels = 2;
670
    unsigned int max_channels = 2, channel;
670 671

  
671 672
    switch(avctx->codec->id) {
672 673
    case CODEC_ID_ADPCM_EA_R1:
......
900 901
    int32_t coeff1l, coeff2l, coeff1r, coeff2r;
901 902
    uint8_t shift_left, shift_right;
902 903
    int count1, count2;
904
    int coeff[2][2], shift[2];//used in EA MAXIS ADPCM
903 905

  
904 906
    if (!buf_size)
905 907
        return 0;
......
1235 1237
            }
1236 1238
        }
1237 1239
        break;
1240
    case CODEC_ID_ADPCM_EA_MAXIS_XA:
1241
        for(channel = 0; channel < avctx->channels; channel++) {
1242
            for (i=0; i<2; i++)
1243
                coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i];
1244
            shift[channel] = (*src & 0x0F) + 8;
1245
            src++;
1246
        }
1247
        for (count1 = 0; count1 < (buf_size - avctx->channels) / avctx->channels; count1++) {
1248
            for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */
1249
                for(channel = 0; channel < avctx->channels; channel++) {
1250
                    int32_t sample = (int32_t)(((*(src+channel) >> i) & 0x0F) << 0x1C) >> shift[channel];
1251
                    sample = (sample +
1252
                             c->status[channel].sample1 * coeff[channel][0] +
1253
                             c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
1254
                    c->status[channel].sample2 = c->status[channel].sample1;
1255
                    c->status[channel].sample1 = av_clip_int16(sample);
1256
                    *samples++ = c->status[channel].sample1;
1257
                }
1258
            }
1259
            src+=avctx->channels;
1260
        }
1261
        break;
1238 1262
    case CODEC_ID_ADPCM_EA_R1:
1239 1263
    case CODEC_ID_ADPCM_EA_R2:
1240 1264
    case CODEC_ID_ADPCM_EA_R3: {
......
1613 1637
ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm);
1614 1638
ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct);
1615 1639
ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea);
1640
ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
1616 1641
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1);
1617 1642
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2);
1618 1643
ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3);
libavcodec/allcodecs.c
244 244
    REGISTER_ENCDEC  (ADPCM_ADX, adpcm_adx);
245 245
    REGISTER_DECODER (ADPCM_CT, adpcm_ct);
246 246
    REGISTER_DECODER (ADPCM_EA, adpcm_ea);
247
    REGISTER_DECODER (ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
247 248
    REGISTER_DECODER (ADPCM_EA_R1, adpcm_ea_r1);
248 249
    REGISTER_DECODER (ADPCM_EA_R2, adpcm_ea_r2);
249 250
    REGISTER_DECODER (ADPCM_EA_R3, adpcm_ea_r3);
libavcodec/avcodec.h
235 235
    CODEC_ID_ADPCM_IMA_EA_SEAD,
236 236
    CODEC_ID_ADPCM_IMA_EA_EACS,
237 237
    CODEC_ID_ADPCM_EA_XAS,
238
    CODEC_ID_ADPCM_EA_MAXIS_XA,
238 239

  
239 240
    /* AMR */
240 241
    CODEC_ID_AMR_NB= 0x12000,
libavformat/Makefile
180 180
OBJS-$(CONFIG_WSAUD_DEMUXER)             += westwood.o
181 181
OBJS-$(CONFIG_WSVQA_DEMUXER)             += westwood.o
182 182
OBJS-$(CONFIG_WV_DEMUXER)                += wv.o
183
OBJS-$(CONFIG_XA_DEMUXER)                += xa.o
183 184
OBJS-$(CONFIG_YUV4MPEGPIPE_MUXER)        += yuv4mpeg.o
184 185
OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER)      += yuv4mpeg.o
185 186

  
libavformat/allformats.c
170 170
    REGISTER_DEMUXER  (WSAUD, wsaud);
171 171
    REGISTER_DEMUXER  (WSVQA, wsvqa);
172 172
    REGISTER_DEMUXER  (WV, wv);
173
    REGISTER_DEMUXER  (XA, xa);
173 174
    REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);
174 175

  
175 176
    /* external libraries */
libavformat/xa.c
1
/*
2
 * Maxis XA (.xa) File Demuxer
3
 * Copyright (c) 2008 Robert Marston
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

  
22
/**
23
 * @file xa.c
24
 * Maxis XA File Demuxer
25
 * by Robert Marston (rmarston@gmail.com)
26
 * for more information on the XA audio format see
27
 *   http://wiki.multimedia.cx/index.php?title=Maxis_XA
28
 */
29

  
30
#include "avformat.h"
31

  
32
#define XA00_TAG MKTAG('X', 'A', 0, 0)
33
#define XAI0_TAG MKTAG('X', 'A', 'I', 0)
34
#define XAJ0_TAG MKTAG('X', 'A', 'J', 0)
35

  
36
typedef struct MaxisXADemuxContext {
37
    uint32_t out_size;
38
    uint32_t sent_bytes;
39
    uint32_t audio_frame_counter;
40
} MaxisXADemuxContext;
41

  
42
static int xa_probe(AVProbeData *p)
43
{
44
    switch(AV_RL32(p->buf)) {
45
    case XA00_TAG:
46
    case XAI0_TAG:
47
    case XAJ0_TAG:
48
        return AVPROBE_SCORE_MAX;
49
    }
50
    return 0;
51
}
52

  
53
static int xa_read_header(AVFormatContext *s,
54
               AVFormatParameters *ap)
55
{
56
    MaxisXADemuxContext *xa = s->priv_data;
57
    ByteIOContext *pb = s->pb;
58
    AVStream *st;
59

  
60
    /*Set up the XA Audio Decoder*/
61
    st = av_new_stream(s, 0);
62
    if (!st)
63
        return AVERROR(ENOMEM);
64

  
65
    st->codec->codec_type   = CODEC_TYPE_AUDIO;
66
    st->codec->codec_id     = CODEC_ID_ADPCM_EA_MAXIS_XA;
67
    url_fskip(pb, 4);       /* Skip the XA ID */
68
    xa->out_size            =  get_le32(pb);
69
    url_fskip(pb, 2);       /* Skip the tag */
70
    st->codec->channels     = get_le16(pb);
71
    st->codec->sample_rate  = get_le32(pb);
72
    /* Value in file is average byte rate*/
73
    st->codec->bit_rate     = get_le32(pb) * 8;
74
    st->codec->block_align  = get_le16(pb);
75
    st->codec->bits_per_sample = get_le16(pb);
76

  
77
    av_set_pts_info(st, 64, 1, st->codec->sample_rate);
78

  
79
    return 0;
80
}
81

  
82
static int xa_read_packet(AVFormatContext *s,
83
                          AVPacket *pkt)
84
{
85
    MaxisXADemuxContext *xa = s->priv_data;
86
    AVStream *st = s->streams[0];
87
    ByteIOContext *pb = s->pb;
88
    unsigned int packet_size;
89
    int ret;
90

  
91
    if(xa->sent_bytes > xa->out_size)
92
        return AVERROR(EIO);
93
    /* 1 byte header and 14 bytes worth of samples * number channels per block */
94
    packet_size = 15*st->codec->channels;
95

  
96
    ret = av_get_packet(pb, pkt, packet_size);
97
    if(ret != packet_size)
98
        return AVERROR(EIO);
99

  
100
    pkt->stream_index = st->index;
101
    xa->sent_bytes += packet_size;
102
    pkt->pts = xa->audio_frame_counter;
103
    /* 14 bytes Samples per channel with 2 samples per byte */
104
    xa->audio_frame_counter += 28 * st->codec->channels;
105

  
106
    return ret;
107
}
108

  
109
AVInputFormat xa_demuxer = {
110
    "xa",
111
    "Maxis XA File Format",
112
    sizeof(MaxisXADemuxContext),
113
    xa_probe,
114
    xa_read_header,
115
    xa_read_packet,
116
};

Also available in: Unified diff