← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/mpc.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/mpc.c
1
1
/*
2
 
 * Musepack decoder
 
2
 * Musepack decoder core
3
3
 * Copyright (c) 2006 Konstantin Shishkov
4
4
 *
5
5
 * This file is part of FFmpeg.
17
17
 * You should have received a copy of the GNU Lesser General Public
18
18
 * License along with FFmpeg; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 
 *
21
20
 */
22
21
 
23
22
/**
24
 
 * @file mpc.c Musepack decoder
 
23
 * @file mpc.c Musepack decoder core
25
24
 * MPEG Audio Layer 1/2 -like codec with frames of 1152 samples
26
25
 * divided into 32 subbands.
27
26
 */
36
35
#endif
37
36
#include "mpegaudio.h"
38
37
 
 
38
#include "mpc.h"
39
39
#include "mpcdata.h"
40
40
 
41
 
#define BANDS            32
42
 
#define SAMPLES_PER_BAND 36
43
 
#define MPC_FRAME_SIZE   (BANDS * SAMPLES_PER_BAND)
44
 
 
45
 
static VLC scfi_vlc, dscf_vlc, hdr_vlc, quant_vlc[MPC7_QUANT_VLC_TABLES][2];
46
 
 
47
41
static DECLARE_ALIGNED_16(MPA_INT, mpa_window[512]);
48
42
 
49
 
typedef struct {
50
 
    DSPContext dsp;
51
 
    int IS, MSS, gapless;
52
 
    int lastframelen, bands;
53
 
    int oldDSCF[2][BANDS];
54
 
    AVRandomState rnd;
55
 
    int frames_to_skip;
56
 
    /* for synthesis */
57
 
    DECLARE_ALIGNED_16(MPA_INT, synth_buf[MPA_MAX_CHANNELS][512*2]);
58
 
    int synth_buf_offset[MPA_MAX_CHANNELS];
59
 
    DECLARE_ALIGNED_16(int32_t, sb_samples[MPA_MAX_CHANNELS][36][SBLIMIT]);
60
 
} MPCContext;
61
 
 
62
 
/** Subband structure - hold all variables for each subband */
63
 
typedef struct {
64
 
    int msf; ///< mid-stereo flag
65
 
    int res[2];
66
 
    int scfi[2];
67
 
    int scf_idx[2][3];
68
 
    int Q[2];
69
 
}Band;
70
 
 
71
 
static int mpc7_decode_init(AVCodecContext * avctx)
 
43
void ff_mpc_init()
72
44
{
73
 
    int i, j;
74
 
    MPCContext *c = avctx->priv_data;
75
 
    GetBitContext gb;
76
 
    uint8_t buf[16];
77
 
    float f1=1.20050805774840750476 * 256;
78
 
    static int vlc_inited = 0;
79
 
 
80
 
    if(avctx->extradata_size < 16){
81
 
        av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
82
 
        return -1;
83
 
    }
84
 
    memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
85
 
    av_init_random(0xDEADBEEF, &c->rnd);
86
 
    dsputil_init(&c->dsp, avctx);
87
 
    c->dsp.bswap_buf(buf, avctx->extradata, 4);
88
45
    ff_mpa_synth_init(mpa_window);
89
 
    init_get_bits(&gb, buf, 128);
90
 
 
91
 
    c->IS = get_bits1(&gb);
92
 
    c->MSS = get_bits1(&gb);
93
 
    c->bands = get_bits(&gb, 6);
94
 
    if(c->bands >= BANDS){
95
 
        av_log(avctx, AV_LOG_ERROR, "Too many bands: %i\n", c->bands);
96
 
        return -1;
97
 
    }
98
 
    skip_bits(&gb, 88);
99
 
    c->gapless = get_bits1(&gb);
100
 
    c->lastframelen = get_bits(&gb, 11);
101
 
    av_log(avctx, AV_LOG_DEBUG, "IS: %d, MSS: %d, TG: %d, LFL: %d, bands: %d\n",
102
 
            c->IS, c->MSS, c->gapless, c->lastframelen, c->bands);
103
 
    c->frames_to_skip = 0;
104
 
 
105
 
    if(vlc_inited) return 0;
106
 
    av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
107
 
    if(init_vlc(&scfi_vlc, MPC7_SCFI_BITS, MPC7_SCFI_SIZE,
108
 
                &mpc7_scfi[1], 2, 1,
109
 
                &mpc7_scfi[0], 2, 1, INIT_VLC_USE_STATIC)){
110
 
        av_log(avctx, AV_LOG_ERROR, "Cannot init SCFI VLC\n");
111
 
        return -1;
112
 
    }
113
 
    if(init_vlc(&dscf_vlc, MPC7_DSCF_BITS, MPC7_DSCF_SIZE,
114
 
                &mpc7_dscf[1], 2, 1,
115
 
                &mpc7_dscf[0], 2, 1, INIT_VLC_USE_STATIC)){
116
 
        av_log(avctx, AV_LOG_ERROR, "Cannot init DSCF VLC\n");
117
 
        return -1;
118
 
    }
119
 
    if(init_vlc(&hdr_vlc, MPC7_HDR_BITS, MPC7_HDR_SIZE,
120
 
                &mpc7_hdr[1], 2, 1,
121
 
                &mpc7_hdr[0], 2, 1, INIT_VLC_USE_STATIC)){
122
 
        av_log(avctx, AV_LOG_ERROR, "Cannot init HDR VLC\n");
123
 
        return -1;
124
 
    }
125
 
    for(i = 0; i < MPC7_QUANT_VLC_TABLES; i++){
126
 
        for(j = 0; j < 2; j++){
127
 
            if(init_vlc(&quant_vlc[i][j], 9, mpc7_quant_vlc_sizes[i],
128
 
                        &mpc7_quant_vlc[i][j][1], 4, 2,
129
 
                        &mpc7_quant_vlc[i][j][0], 4, 2, INIT_VLC_USE_STATIC)){
130
 
                av_log(avctx, AV_LOG_ERROR, "Cannot init QUANT VLC %i,%i\n",i,j);
131
 
                return -1;
132
 
            }
133
 
        }
134
 
    }
135
 
    vlc_inited = 1;
136
 
    return 0;
137
46
}
138
47
 
139
48
/**
140
49
 * Process decoded Musepack data and produce PCM
141
 
 * @todo make it available for MPC8 and MPC6
142
50
 */
143
51
static void mpc_synth(MPCContext *c, int16_t *out)
144
52
{
160
68
        *out++=samples[i];
161
69
}
162
70
 
163
 
/**
164
 
 * Fill samples for given subband
165
 
 */
166
 
static void inline idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int *dst)
167
 
{
168
 
    int i, i1, t;
169
 
    switch(idx){
170
 
    case -1:
171
 
        for(i = 0; i < SAMPLES_PER_BAND; i++){
172
 
            *dst++ = (av_random(&c->rnd) & 0x3FC) - 510;
173
 
        }
174
 
        break;
175
 
    case 1:
176
 
        i1 = get_bits1(gb);
177
 
        for(i = 0; i < SAMPLES_PER_BAND/3; i++){
178
 
            t = get_vlc2(gb, quant_vlc[0][i1].table, 9, 2);
179
 
            *dst++ = mpc_idx30[t];
180
 
            *dst++ = mpc_idx31[t];
181
 
            *dst++ = mpc_idx32[t];
182
 
        }
183
 
        break;
184
 
    case 2:
185
 
        i1 = get_bits1(gb);
186
 
        for(i = 0; i < SAMPLES_PER_BAND/2; i++){
187
 
            t = get_vlc2(gb, quant_vlc[1][i1].table, 9, 2);
188
 
            *dst++ = mpc_idx50[t];
189
 
            *dst++ = mpc_idx51[t];
190
 
        }
191
 
        break;
192
 
    case  3: case  4: case  5: case  6: case  7:
193
 
        i1 = get_bits1(gb);
194
 
        for(i = 0; i < SAMPLES_PER_BAND; i++)
195
 
            *dst++ = get_vlc2(gb, quant_vlc[idx-1][i1].table, 9, 2) - mpc7_quant_vlc_off[idx-1];
196
 
        break;
197
 
    case  8: case  9: case 10: case 11: case 12:
198
 
    case 13: case 14: case 15: case 16: case 17:
199
 
        t = (1 << (idx - 2)) - 1;
200
 
        for(i = 0; i < SAMPLES_PER_BAND; i++)
201
 
            *dst++ = get_bits(gb, idx - 1) - t;
202
 
        break;
203
 
    default: // case 0 and -2..-17
204
 
        return;
205
 
    }
206
 
}
207
 
 
208
 
static int mpc7_decode_frame(AVCodecContext * avctx,
209
 
                            void *data, int *data_size,
210
 
                            uint8_t * buf, int buf_size)
211
 
{
212
 
    MPCContext *c = avctx->priv_data;
213
 
    GetBitContext gb;
214
 
    uint8_t *bits;
215
 
    int i, j, ch, t;
216
 
    int mb = -1;
217
 
    Band bands[BANDS];
218
 
    int Q[2][MPC_FRAME_SIZE];
 
71
void ff_mpc_dequantize_and_synth(MPCContext * c, int maxband, void *data)
 
72
{
 
73
    int i, j, ch;
 
74
    Band *bands = c->bands;
219
75
    int off;
220
76
    float mul;
221
 
    int bits_used, bits_avail;
222
 
 
223
 
    memset(bands, 0, sizeof(bands));
224
 
    if(buf_size <= 4){
225
 
        av_log(avctx, AV_LOG_ERROR, "Too small buffer passed (%i bytes)\n", buf_size);
226
 
    }
227
 
 
228
 
    bits = av_malloc(((buf_size - 1) & ~3) + FF_INPUT_BUFFER_PADDING_SIZE);
229
 
    c->dsp.bswap_buf(bits, buf + 4, (buf_size - 4) >> 2);
230
 
    init_get_bits(&gb, bits, (buf_size - 4)* 8);
231
 
    skip_bits(&gb, buf[0]);
232
 
 
233
 
    /* read subband indexes */
234
 
    for(i = 0; i <= c->bands; i++){
235
 
        for(ch = 0; ch < 2; ch++){
236
 
            if(i) t = get_vlc2(&gb, hdr_vlc.table, MPC7_HDR_BITS, 1) - 5;
237
 
            if(!i || (t == 4)) bands[i].res[ch] = get_bits(&gb, 4);
238
 
            else bands[i].res[ch] = bands[i-1].res[ch] + t;
239
 
        }
240
 
 
241
 
        if(bands[i].res[0] || bands[i].res[1]){
242
 
            mb = i;
243
 
            if(c->MSS) bands[i].msf = get_bits1(&gb);
244
 
        }
245
 
    }
246
 
    /* get scale indexes coding method */
247
 
    for(i = 0; i <= mb; i++)
248
 
        for(ch = 0; ch < 2; ch++)
249
 
            if(bands[i].res[ch]) bands[i].scfi[ch] = get_vlc2(&gb, scfi_vlc.table, MPC7_SCFI_BITS, 1);
250
 
    /* get scale indexes */
251
 
    for(i = 0; i <= mb; i++){
252
 
        for(ch = 0; ch < 2; ch++){
253
 
            if(bands[i].res[ch]){
254
 
                bands[i].scf_idx[ch][2] = c->oldDSCF[ch][i];
255
 
                t = get_vlc2(&gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
256
 
                bands[i].scf_idx[ch][0] = (t == 8) ? get_bits(&gb, 6) : (bands[i].scf_idx[ch][2] + t);
257
 
                switch(bands[i].scfi[ch]){
258
 
                case 0:
259
 
                    t = get_vlc2(&gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
260
 
                    bands[i].scf_idx[ch][1] = (t == 8) ? get_bits(&gb, 6) : (bands[i].scf_idx[ch][0] + t);
261
 
                    t = get_vlc2(&gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
262
 
                    bands[i].scf_idx[ch][2] = (t == 8) ? get_bits(&gb, 6) : (bands[i].scf_idx[ch][1] + t);
263
 
                    break;
264
 
                case 1:
265
 
                    t = get_vlc2(&gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
266
 
                    bands[i].scf_idx[ch][1] = (t == 8) ? get_bits(&gb, 6) : (bands[i].scf_idx[ch][0] + t);
267
 
                    bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1];
268
 
                    break;
269
 
                case 2:
270
 
                    bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];
271
 
                    t = get_vlc2(&gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
272
 
                    bands[i].scf_idx[ch][2] = (t == 8) ? get_bits(&gb, 6) : (bands[i].scf_idx[ch][1] + t);
273
 
                    break;
274
 
                case 3:
275
 
                    bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];
276
 
                    break;
277
 
                }
278
 
                c->oldDSCF[ch][i] = bands[i].scf_idx[ch][2];
279
 
            }
280
 
        }
281
 
    }
282
 
    /* get quantizers */
283
 
    memset(Q, 0, sizeof(Q));
284
 
    off = 0;
285
 
    for(i = 0; i < BANDS; i++, off += SAMPLES_PER_BAND)
286
 
        for(ch = 0; ch < 2; ch++)
287
 
            idx_to_quant(c, &gb, bands[i].res[ch], Q[ch] + off);
 
77
 
288
78
    /* dequantize */
289
79
    memset(c->sb_samples, 0, sizeof(c->sb_samples));
290
80
    off = 0;
291
 
    for(i = 0; i <= mb; i++, off += SAMPLES_PER_BAND){
 
81
    for(i = 0; i <= maxband; i++, off += SAMPLES_PER_BAND){
292
82
        for(ch = 0; ch < 2; ch++){
293
83
            if(bands[i].res[ch]){
294
84
                j = 0;
295
 
                mul = mpc_CC[bands[i].res[ch]] * mpc7_SCF[bands[i].scf_idx[ch][0]];
 
85
                mul = mpc_CC[bands[i].res[ch]] * mpc_SCF[bands[i].scf_idx[ch][0]];
296
86
                for(; j < 12; j++)
297
 
                    c->sb_samples[ch][j][i] = mul * Q[ch][j + off];
298
 
                mul = mpc_CC[bands[i].res[ch]] * mpc7_SCF[bands[i].scf_idx[ch][1]];
 
87
                    c->sb_samples[ch][j][i] = mul * c->Q[ch][j + off];
 
88
                mul = mpc_CC[bands[i].res[ch]] * mpc_SCF[bands[i].scf_idx[ch][1]];
299
89
                for(; j < 24; j++)
300
 
                    c->sb_samples[ch][j][i] = mul * Q[ch][j + off];
301
 
                mul = mpc_CC[bands[i].res[ch]] * mpc7_SCF[bands[i].scf_idx[ch][2]];
 
90
                    c->sb_samples[ch][j][i] = mul * c->Q[ch][j + off];
 
91
                mul = mpc_CC[bands[i].res[ch]] * mpc_SCF[bands[i].scf_idx[ch][2]];
302
92
                for(; j < 36; j++)
303
 
                    c->sb_samples[ch][j][i] = mul * Q[ch][j + off];
 
93
                    c->sb_samples[ch][j][i] = mul * c->Q[ch][j + off];
304
94
            }
305
95
        }
306
96
        if(bands[i].msf){
315
105
    }
316
106
 
317
107
    mpc_synth(c, data);
318
 
 
319
 
    av_free(bits);
320
 
 
321
 
    bits_used = get_bits_count(&gb);
322
 
    bits_avail = (buf_size - 4) * 8;
323
 
    if(!buf[1] && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))){
324
 
        av_log(NULL,0, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail);
325
 
        return -1;
326
 
    }
327
 
    if(c->frames_to_skip){
328
 
        c->frames_to_skip--;
329
 
        *data_size = 0;
330
 
        return buf_size;
331
 
    }
332
 
    *data_size = (buf[1] ? c->lastframelen : MPC_FRAME_SIZE) * 4;
333
 
 
334
 
    return buf_size;
335
 
}
336
 
 
337
 
static void mpc7_decode_flush(AVCodecContext *avctx)
338
 
{
339
 
    MPCContext *c = avctx->priv_data;
340
 
 
341
 
    memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
342
 
    c->frames_to_skip = 32;
343
 
}
344
 
 
345
 
AVCodec mpc7_decoder = {
346
 
    "mpc sv7",
347
 
    CODEC_TYPE_AUDIO,
348
 
    CODEC_ID_MUSEPACK7,
349
 
    sizeof(MPCContext),
350
 
    mpc7_decode_init,
351
 
    NULL,
352
 
    NULL,
353
 
    mpc7_decode_frame,
354
 
    .flush = mpc7_decode_flush,
355
 
};
 
108
}