Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flac.c @ b6204677

History | View | Annotate | Download (23.8 KB)

1 4f52c312 Michael Niedermayer
/*
2
 * FLAC (Free Lossless Audio Codec) decoder
3
 * Copyright (c) 2003 Alex Beregszaszi
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
20
/**
21
 * @file flac.c
22
 * FLAC (Free Lossless Audio Codec) decoder
23
 * @author Alex Beregszaszi
24 9eda2f94 Mike Melanson
 *
25
 * For more information on the FLAC format, visit:
26
 *  http://flac.sourceforge.net/
27
 *
28
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29
 * through, starting from the initial 'fLaC' signature; or by passing the
30
 * 34-byte streaminfo structure through avctx->extradata[_size] followed
31
 * by data starting with the 0xFFF8 marker.
32 4f52c312 Michael Niedermayer
 */
33 115329f1 Diego Biurrun
34 ac2570a8 Michael Niedermayer
#include <limits.h>
35 115329f1 Diego Biurrun
36 4f52c312 Michael Niedermayer
#include "avcodec.h"
37 caa336b4 Michael Niedermayer
#include "bitstream.h"
38 4f52c312 Michael Niedermayer
#include "golomb.h"
39
40 ac2570a8 Michael Niedermayer
#undef NDEBUG
41
#include <assert.h>
42
43 4f52c312 Michael Niedermayer
#define MAX_CHANNELS 8
44
#define MAX_BLOCKSIZE 65535
45 9eda2f94 Mike Melanson
#define FLAC_STREAMINFO_SIZE 34
46 4f52c312 Michael Niedermayer
47 9d656110 Michael Niedermayer
enum decorrelation_type {
48 4f52c312 Michael Niedermayer
    INDEPENDENT,
49
    LEFT_SIDE,
50
    RIGHT_SIDE,
51
    MID_SIDE,
52
};
53
54
typedef struct FLACContext {
55
    AVCodecContext *avctx;
56
    GetBitContext gb;
57
58
    int min_blocksize, max_blocksize;
59
    int min_framesize, max_framesize;
60
    int samplerate, channels;
61 ac2570a8 Michael Niedermayer
    int blocksize/*, last_blocksize*/;
62 4f52c312 Michael Niedermayer
    int bps, curr_bps;
63 9d656110 Michael Niedermayer
    enum decorrelation_type decorrelation;
64 4f52c312 Michael Niedermayer
65 ac2570a8 Michael Niedermayer
    int32_t *decoded[MAX_CHANNELS];
66
    uint8_t *bitstream;
67
    int bitstream_size;
68
    int bitstream_index;
69
    int allocated_bitstream_size;
70 4f52c312 Michael Niedermayer
} FLACContext;
71
72
#define METADATA_TYPE_STREAMINFO 0
73
74
static int sample_rate_table[] =
75
{ 0, 0, 0, 0,
76
  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
77 115329f1 Diego Biurrun
  0, 0, 0, 0 };
78 4f52c312 Michael Niedermayer
79 115329f1 Diego Biurrun
static int sample_size_table[] =
80 4f52c312 Michael Niedermayer
{ 0, 8, 12, 0, 16, 20, 24, 0 };
81
82 0496a034 Michael Niedermayer
static int blocksize_table[] = {
83 115329f1 Diego Biurrun
     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
84
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
85 0496a034 Michael Niedermayer
};
86
87 9d656110 Michael Niedermayer
static const uint8_t table_crc8[256] = {
88
    0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
89
    0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
90
    0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
91
    0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
92
    0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
93
    0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
94
    0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
95
    0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
96
    0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
97
    0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
98
    0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
99
    0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
100
    0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
101
    0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
102
    0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
103
    0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
104
    0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
105
    0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
106
    0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
107
    0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
108
    0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
109
    0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
110
    0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
111
    0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
112
    0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
113
    0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
114
    0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
115
    0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
116
    0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
117
    0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
118
    0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
119
    0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
120
};
121
122 ac2570a8 Michael Niedermayer
static int64_t get_utf8(GetBitContext *gb)
123 4f52c312 Michael Niedermayer
{
124 ac2570a8 Michael Niedermayer
    uint64_t val;
125
    int ones=0, bytes;
126 115329f1 Diego Biurrun
127 ac2570a8 Michael Niedermayer
    while(get_bits1(gb))
128
        ones++;
129 4f52c312 Michael Niedermayer
130 ac2570a8 Michael Niedermayer
    if     (ones==0) bytes=0;
131
    else if(ones==1) return -1;
132
    else             bytes= ones - 1;
133 115329f1 Diego Biurrun
134 ac2570a8 Michael Niedermayer
    val= get_bits(gb, 7-ones);
135
    while(bytes--){
136 4f52c312 Michael Niedermayer
        const int tmp = get_bits(gb, 8);
137 115329f1 Diego Biurrun
138 ac2570a8 Michael Niedermayer
        if((tmp>>6) != 2)
139
            return -1;
140
        val<<=6;
141
        val|= tmp&0x3F;
142 4f52c312 Michael Niedermayer
    }
143 ac2570a8 Michael Niedermayer
    return val;
144 4f52c312 Michael Niedermayer
}
145
146 88730be6 Måns Rullgård
#if 0
147 41aecb13 Alex Beregszaszi
static int skip_utf8(GetBitContext *gb)
148
{
149
    int ones=0, bytes;
150 115329f1 Diego Biurrun

151 41aecb13 Alex Beregszaszi
    while(get_bits1(gb))
152
        ones++;
153

154
    if     (ones==0) bytes=0;
155
    else if(ones==1) return -1;
156
    else             bytes= ones - 1;
157 115329f1 Diego Biurrun

158 41aecb13 Alex Beregszaszi
    skip_bits(gb, 7-ones);
159
    while(bytes--){
160
        const int tmp = get_bits(gb, 8);
161 115329f1 Diego Biurrun

162 41aecb13 Alex Beregszaszi
        if((tmp>>6) != 2)
163
            return -1;
164
    }
165
    return 0;
166
}
167 88730be6 Måns Rullgård
#endif
168 41aecb13 Alex Beregszaszi
169 62c438a2 Zdenek Kabelac
static int get_crc8(const uint8_t *buf, int count){
170 9d656110 Michael Niedermayer
    int crc=0;
171
    int i;
172 115329f1 Diego Biurrun
173 9d656110 Michael Niedermayer
    for(i=0; i<count; i++){
174
        crc = table_crc8[crc ^ buf[i]];
175
    }
176
177
    return crc;
178
}
179
180 9eda2f94 Mike Melanson
static void metadata_streaminfo(FLACContext *s);
181
static void dump_headers(FLACContext *s);
182
183 4f52c312 Michael Niedermayer
static int flac_decode_init(AVCodecContext * avctx)
184
{
185 9eda2f94 Mike Melanson
    FLACContext *s = avctx->priv_data;
186
    s->avctx = avctx;
187
188
    /* initialize based on the demuxer-supplied streamdata header */
189
    if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
190
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
191
        metadata_streaminfo(s);
192
        dump_headers(s);
193
    }
194
195 4f52c312 Michael Niedermayer
    return 0;
196
}
197
198
static void dump_headers(FLACContext *s)
199
{
200 ac2570a8 Michael Niedermayer
    av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
201
    av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
202
    av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
203
    av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
204
    av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
205 4f52c312 Michael Niedermayer
}
206
207 ac2570a8 Michael Niedermayer
static void allocate_buffers(FLACContext *s){
208 4f52c312 Michael Niedermayer
    int i;
209
210 ac2570a8 Michael Niedermayer
    assert(s->max_blocksize);
211
212
    if(s->max_framesize == 0 && s->max_blocksize){
213
        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
214
    }
215
216
    for (i = 0; i < s->channels; i++)
217
    {
218
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
219
    }
220
221
    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
222
}
223
224
static void metadata_streaminfo(FLACContext *s)
225
{
226 4f52c312 Michael Niedermayer
    /* mandatory streaminfo */
227
    s->min_blocksize = get_bits(&s->gb, 16);
228
    s->max_blocksize = get_bits(&s->gb, 16);
229
230
    s->min_framesize = get_bits_long(&s->gb, 24);
231
    s->max_framesize = get_bits_long(&s->gb, 24);
232 115329f1 Diego Biurrun
233 4f52c312 Michael Niedermayer
    s->samplerate = get_bits_long(&s->gb, 20);
234
    s->channels = get_bits(&s->gb, 3) + 1;
235
    s->bps = get_bits(&s->gb, 5) + 1;
236 115329f1 Diego Biurrun
237 4f52c312 Michael Niedermayer
    s->avctx->channels = s->channels;
238
    s->avctx->sample_rate = s->samplerate;
239
240
    skip_bits(&s->gb, 36); /* total num of samples */
241 115329f1 Diego Biurrun
242 4f52c312 Michael Niedermayer
    skip_bits(&s->gb, 64); /* md5 sum */
243
    skip_bits(&s->gb, 64); /* md5 sum */
244 115329f1 Diego Biurrun
245 ac2570a8 Michael Niedermayer
    allocate_buffers(s);
246 4f52c312 Michael Niedermayer
}
247
248
static int decode_residuals(FLACContext *s, int channel, int pred_order)
249
{
250
    int i, tmp, partition, method_type, rice_order;
251
    int sample = 0, samples;
252
253
    method_type = get_bits(&s->gb, 2);
254 ac2570a8 Michael Niedermayer
    if (method_type != 0){
255
        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
256 4f52c312 Michael Niedermayer
        return -1;
257 ac2570a8 Michael Niedermayer
    }
258 115329f1 Diego Biurrun
259 4f52c312 Michael Niedermayer
    rice_order = get_bits(&s->gb, 4);
260
261 ac2570a8 Michael Niedermayer
    samples= s->blocksize >> rice_order;
262 4f52c312 Michael Niedermayer
263 115329f1 Diego Biurrun
    sample=
264 ac2570a8 Michael Niedermayer
    i= pred_order;
265 4f52c312 Michael Niedermayer
    for (partition = 0; partition < (1 << rice_order); partition++)
266
    {
267
        tmp = get_bits(&s->gb, 4);
268 ac2570a8 Michael Niedermayer
        if (tmp == 15)
269 4f52c312 Michael Niedermayer
        {
270 ac2570a8 Michael Niedermayer
            av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
271 4f52c312 Michael Niedermayer
            tmp = get_bits(&s->gb, 5);
272
            for (; i < samples; i++, sample++)
273 4fd12598 Michael Niedermayer
                s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
274 4f52c312 Michael Niedermayer
        }
275
        else
276
        {
277 ac2570a8 Michael Niedermayer
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
278
            for (; i < samples; i++, sample++){
279 4fd12598 Michael Niedermayer
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
280 ac2570a8 Michael Niedermayer
            }
281 4f52c312 Michael Niedermayer
        }
282 ac2570a8 Michael Niedermayer
        i= 0;
283 4f52c312 Michael Niedermayer
    }
284
285 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
286 4f52c312 Michael Niedermayer
287
    return 0;
288 115329f1 Diego Biurrun
}
289 4f52c312 Michael Niedermayer
290
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
291
{
292
    int i;
293 115329f1 Diego Biurrun
294 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
295 115329f1 Diego Biurrun
296 4f52c312 Michael Niedermayer
    /* warm up samples */
297 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
298 115329f1 Diego Biurrun
299 4f52c312 Michael Niedermayer
    for (i = 0; i < pred_order; i++)
300
    {
301 ac2570a8 Michael Niedermayer
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
302
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
303 4f52c312 Michael Niedermayer
    }
304 115329f1 Diego Biurrun
305 4f52c312 Michael Niedermayer
    if (decode_residuals(s, channel, pred_order) < 0)
306
        return -1;
307
308
    switch(pred_order)
309
    {
310
        case 0:
311
            break;
312
        case 1:
313
            for (i = pred_order; i < s->blocksize; i++)
314 4fd12598 Michael Niedermayer
                s->decoded[channel][i] +=   s->decoded[channel][i-1];
315 4f52c312 Michael Niedermayer
            break;
316
        case 2:
317
            for (i = pred_order; i < s->blocksize; i++)
318 4fd12598 Michael Niedermayer
                s->decoded[channel][i] += 2*s->decoded[channel][i-1]
319
                                          - s->decoded[channel][i-2];
320 4f52c312 Michael Niedermayer
            break;
321
        case 3:
322
            for (i = pred_order; i < s->blocksize; i++)
323 115329f1 Diego Biurrun
                s->decoded[channel][i] += 3*s->decoded[channel][i-1]
324 4fd12598 Michael Niedermayer
                                        - 3*s->decoded[channel][i-2]
325
                                        +   s->decoded[channel][i-3];
326 4f52c312 Michael Niedermayer
            break;
327
        case 4:
328
            for (i = pred_order; i < s->blocksize; i++)
329 115329f1 Diego Biurrun
                s->decoded[channel][i] += 4*s->decoded[channel][i-1]
330 4fd12598 Michael Niedermayer
                                        - 6*s->decoded[channel][i-2]
331
                                        + 4*s->decoded[channel][i-3]
332
                                        -   s->decoded[channel][i-4];
333 4f52c312 Michael Niedermayer
            break;
334 ac2570a8 Michael Niedermayer
        default:
335
            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
336
            return -1;
337 4f52c312 Michael Niedermayer
    }
338 ac2570a8 Michael Niedermayer
339 4f52c312 Michael Niedermayer
    return 0;
340
}
341
342
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
343
{
344
    int sum, i, j;
345
    int coeff_prec, qlevel;
346
    int coeffs[pred_order];
347 115329f1 Diego Biurrun
348 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
349 115329f1 Diego Biurrun
350 4f52c312 Michael Niedermayer
    /* warm up samples */
351 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
352 115329f1 Diego Biurrun
353 4f52c312 Michael Niedermayer
    for (i = 0; i < pred_order; i++)
354
    {
355 ac2570a8 Michael Niedermayer
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
356
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
357 4f52c312 Michael Niedermayer
    }
358 115329f1 Diego Biurrun
359 4f52c312 Michael Niedermayer
    coeff_prec = get_bits(&s->gb, 4) + 1;
360
    if (coeff_prec == 16)
361
    {
362 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
363 4f52c312 Michael Niedermayer
        return -1;
364
    }
365 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
366 ac2570a8 Michael Niedermayer
    qlevel = get_sbits(&s->gb, 5);
367 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
368
    if(qlevel < 0){
369
        av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
370
        return -1;
371
    }
372
373 4f52c312 Michael Niedermayer
    for (i = 0; i < pred_order; i++)
374
    {
375 ac2570a8 Michael Niedermayer
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
376
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
377 4f52c312 Michael Niedermayer
    }
378 115329f1 Diego Biurrun
379 4f52c312 Michael Niedermayer
    if (decode_residuals(s, channel, pred_order) < 0)
380
        return -1;
381
382
    for (i = pred_order; i < s->blocksize; i++)
383
    {
384
        sum = 0;
385
        for (j = 0; j < pred_order; j++)
386
            sum += coeffs[j] * s->decoded[channel][i-j-1];
387 4fd12598 Michael Niedermayer
        s->decoded[channel][i] += sum >> qlevel;
388 4f52c312 Michael Niedermayer
    }
389 115329f1 Diego Biurrun
390 4f52c312 Michael Niedermayer
    return 0;
391
}
392
393
static inline int decode_subframe(FLACContext *s, int channel)
394
{
395
    int type, wasted = 0;
396
    int i, tmp;
397 115329f1 Diego Biurrun
398 4f52c312 Michael Niedermayer
    s->curr_bps = s->bps;
399 ac2570a8 Michael Niedermayer
    if(channel == 0){
400 9d656110 Michael Niedermayer
        if(s->decorrelation == RIGHT_SIDE)
401 ac2570a8 Michael Niedermayer
            s->curr_bps++;
402
    }else{
403 9d656110 Michael Niedermayer
        if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
404 ac2570a8 Michael Niedermayer
            s->curr_bps++;
405
    }
406
407 4f52c312 Michael Niedermayer
    if (get_bits1(&s->gb))
408
    {
409 1cef211d Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
410 4f52c312 Michael Niedermayer
        return -1;
411
    }
412
    type = get_bits(&s->gb, 6);
413
//    wasted = get_bits1(&s->gb);
414 115329f1 Diego Biurrun
415 4f52c312 Michael Niedermayer
//    if (wasted)
416
//    {
417
//        while (!get_bits1(&s->gb))
418
//            wasted++;
419
//        if (wasted)
420
//            wasted++;
421
//        s->curr_bps -= wasted;
422
//    }
423 ac2570a8 Michael Niedermayer
#if 0
424
    wasted= 16 - av_log2(show_bits(&s->gb, 17));
425
    skip_bits(&s->gb, wasted+1);
426
    s->curr_bps -= wasted;
427
#else
428 4f52c312 Michael Niedermayer
    if (get_bits1(&s->gb))
429
    {
430
        wasted = 1;
431
        while (!get_bits1(&s->gb))
432
            wasted++;
433
        s->curr_bps -= wasted;
434 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
435 4f52c312 Michael Niedermayer
    }
436 ac2570a8 Michael Niedermayer
#endif
437
//FIXME use av_log2 for types
438 4f52c312 Michael Niedermayer
    if (type == 0)
439
    {
440 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
441
        tmp = get_sbits(&s->gb, s->curr_bps);
442 4f52c312 Michael Niedermayer
        for (i = 0; i < s->blocksize; i++)
443
            s->decoded[channel][i] = tmp;
444
    }
445
    else if (type == 1)
446
    {
447 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
448 4f52c312 Michael Niedermayer
        for (i = 0; i < s->blocksize; i++)
449 ac2570a8 Michael Niedermayer
            s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
450 4f52c312 Michael Niedermayer
    }
451
    else if ((type >= 8) && (type <= 12))
452
    {
453 9d656110 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
454 4f52c312 Michael Niedermayer
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
455
            return -1;
456
    }
457
    else if (type >= 32)
458
    {
459 ac2570a8 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
460 4f52c312 Michael Niedermayer
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
461
            return -1;
462
    }
463
    else
464
    {
465 1cef211d Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
466 4f52c312 Michael Niedermayer
        return -1;
467
    }
468 115329f1 Diego Biurrun
469 4f52c312 Michael Niedermayer
    if (wasted)
470
    {
471
        int i;
472
        for (i = 0; i < s->blocksize; i++)
473
            s->decoded[channel][i] <<= wasted;
474
    }
475
476
    return 0;
477
}
478
479
static int decode_frame(FLACContext *s)
480
{
481 9d656110 Michael Niedermayer
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
482 0496a034 Michael Niedermayer
    int decorrelation, bps, blocksize, samplerate;
483 115329f1 Diego Biurrun
484 4f52c312 Michael Niedermayer
    blocksize_code = get_bits(&s->gb, 4);
485
486
    sample_rate_code = get_bits(&s->gb, 4);
487 115329f1 Diego Biurrun
488 4f52c312 Michael Niedermayer
    assignment = get_bits(&s->gb, 4); /* channel assignment */
489 0496a034 Michael Niedermayer
    if (assignment < 8 && s->channels == assignment+1)
490
        decorrelation = INDEPENDENT;
491
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
492
        decorrelation = LEFT_SIDE + assignment - 8;
493 4f52c312 Michael Niedermayer
    else
494
    {
495 1cef211d Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
496 4f52c312 Michael Niedermayer
        return -1;
497
    }
498 115329f1 Diego Biurrun
499 4f52c312 Michael Niedermayer
    sample_size_code = get_bits(&s->gb, 3);
500 0496a034 Michael Niedermayer
    if(sample_size_code == 0)
501
        bps= s->bps;
502
    else if((sample_size_code != 3) && (sample_size_code != 7))
503
        bps = sample_size_table[sample_size_code];
504 115329f1 Diego Biurrun
    else
505 4f52c312 Michael Niedermayer
    {
506 1cef211d Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
507 4f52c312 Michael Niedermayer
        return -1;
508
    }
509
510
    if (get_bits1(&s->gb))
511
    {
512 1cef211d Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
513 0496a034 Michael Niedermayer
        return -1;
514 4f52c312 Michael Niedermayer
    }
515 115329f1 Diego Biurrun
516 0496a034 Michael Niedermayer
    if(get_utf8(&s->gb) < 0){
517
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
518
        return -1;
519
    }
520 115329f1 Diego Biurrun
#if 0
521 ac2570a8 Michael Niedermayer
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
522
        (s->min_blocksize != s->max_blocksize)){
523
    }else{
524 4f52c312 Michael Niedermayer
    }
525 0496a034 Michael Niedermayer
#endif
526 115329f1 Diego Biurrun
527 ac2570a8 Michael Niedermayer
    if (blocksize_code == 0)
528 0496a034 Michael Niedermayer
        blocksize = s->min_blocksize;
529 ac2570a8 Michael Niedermayer
    else if (blocksize_code == 6)
530 0496a034 Michael Niedermayer
        blocksize = get_bits(&s->gb, 8)+1;
531 ac2570a8 Michael Niedermayer
    else if (blocksize_code == 7)
532 0496a034 Michael Niedermayer
        blocksize = get_bits(&s->gb, 16)+1;
533 115329f1 Diego Biurrun
    else
534 0496a034 Michael Niedermayer
        blocksize = blocksize_table[blocksize_code];
535 4f52c312 Michael Niedermayer
536 0496a034 Michael Niedermayer
    if(blocksize > s->max_blocksize){
537
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
538 ac2570a8 Michael Niedermayer
        return -1;
539
    }
540
541
    if (sample_rate_code == 0){
542 0496a034 Michael Niedermayer
        samplerate= s->samplerate;
543 ac2570a8 Michael Niedermayer
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
544 0496a034 Michael Niedermayer
        samplerate = sample_rate_table[sample_rate_code];
545 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 12)
546 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 8) * 1000;
547 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 13)
548 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 16);
549 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 14)
550 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 16) * 10;
551 ac2570a8 Michael Niedermayer
    else{
552
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
553
        return -1;
554 4f52c312 Michael Niedermayer
    }
555
556 9d656110 Michael Niedermayer
    skip_bits(&s->gb, 8);
557
    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
558
    if(crc8){
559 160d679c Mike Melanson
        av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
560 9d656110 Michael Niedermayer
        return -1;
561
    }
562 115329f1 Diego Biurrun
563 0496a034 Michael Niedermayer
    s->blocksize    = blocksize;
564
    s->samplerate   = samplerate;
565
    s->bps          = bps;
566
    s->decorrelation= decorrelation;
567 4f52c312 Michael Niedermayer
568 ac2570a8 Michael Niedermayer
//    dump_headers(s);
569 4f52c312 Michael Niedermayer
570
    /* subframes */
571
    for (i = 0; i < s->channels; i++)
572
    {
573 ac2570a8 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
574 4f52c312 Michael Niedermayer
        if (decode_subframe(s, i) < 0)
575
            return -1;
576
    }
577 115329f1 Diego Biurrun
578 4f52c312 Michael Niedermayer
    align_get_bits(&s->gb);
579
580
    /* frame footer */
581
    skip_bits(&s->gb, 16); /* data crc */
582
583
    return 0;
584
}
585
586
static int flac_decode_frame(AVCodecContext *avctx,
587
                            void *data, int *data_size,
588
                            uint8_t *buf, int buf_size)
589
{
590
    FLACContext *s = avctx->priv_data;
591 ac2570a8 Michael Niedermayer
    int metadata_last, metadata_type, metadata_size;
592 3f1899a8 Mike Melanson
    int tmp = 0, i, j = 0, input_buf_size = 0;
593
    int16_t *samples = data;
594 4f52c312 Michael Niedermayer
595 ac2570a8 Michael Niedermayer
    if(s->max_framesize == 0){
596 09f20d37 Loren Merritt
        s->max_framesize= 65536; // should hopefully be enough for the first header
597 ac2570a8 Michael Niedermayer
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
598
    }
599
600
    if(1 && s->max_framesize){//FIXME truncated
601 09f20d37 Loren Merritt
            buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
602 ac2570a8 Michael Niedermayer
            input_buf_size= buf_size;
603
604
            if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
605
//                printf("memmove\n");
606
                memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
607
                s->bitstream_index=0;
608
            }
609
            memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
610
            buf= &s->bitstream[s->bitstream_index];
611
            buf_size += s->bitstream_size;
612
            s->bitstream_size= buf_size;
613 115329f1 Diego Biurrun
614 ac2570a8 Michael Niedermayer
            if(buf_size < s->max_framesize){
615
//                printf("wanna more data ...\n");
616
                return input_buf_size;
617
            }
618
    }
619 4f52c312 Michael Niedermayer
620
    init_get_bits(&s->gb, buf, buf_size*8);
621 115329f1 Diego Biurrun
622 4f52c312 Michael Niedermayer
    /* fLaC signature (be) */
623 ac2570a8 Michael Niedermayer
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
624 4f52c312 Michael Niedermayer
    {
625 ac2570a8 Michael Niedermayer
        skip_bits(&s->gb, 32);
626
627
        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
628 4f52c312 Michael Niedermayer
        do {
629 ac2570a8 Michael Niedermayer
            metadata_last = get_bits(&s->gb, 1);
630 4f52c312 Michael Niedermayer
            metadata_type = get_bits(&s->gb, 7);
631
            metadata_size = get_bits_long(&s->gb, 24);
632 115329f1 Diego Biurrun
633 ac2570a8 Michael Niedermayer
            av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
634
                metadata_last, metadata_type,
635 4f52c312 Michael Niedermayer
                metadata_size);
636 ac2570a8 Michael Niedermayer
            if(metadata_size){
637
                switch(metadata_type)
638
                {
639 db2fcbbd Michael Niedermayer
                case METADATA_TYPE_STREAMINFO:{
640 4f52c312 Michael Niedermayer
                    metadata_streaminfo(s);
641 db2fcbbd Michael Niedermayer
642 56b31a8e Loren Merritt
                    /* Buffer might have been reallocated, reinit bitreader */
643
                    if(buf != &s->bitstream[s->bitstream_index])
644
                    {
645
                        int bits_count = get_bits_count(&s->gb);
646
                        buf= &s->bitstream[s->bitstream_index];
647
                        init_get_bits(&s->gb, buf, buf_size*8);
648
                        skip_bits(&s->gb, bits_count);
649
                    }
650 115329f1 Diego Biurrun
651 4f52c312 Michael Niedermayer
                    dump_headers(s);
652 db2fcbbd Michael Niedermayer
                    break;}
653 4f52c312 Michael Niedermayer
                default:
654 ac2570a8 Michael Niedermayer
                    for(i=0; i<metadata_size; i++)
655 4f52c312 Michael Niedermayer
                        skip_bits(&s->gb, 8);
656 ac2570a8 Michael Niedermayer
                }
657 4f52c312 Michael Niedermayer
            }
658 ac2570a8 Michael Niedermayer
        } while(!metadata_last);
659 4f52c312 Michael Niedermayer
    }
660
    else
661
    {
662 115329f1 Diego Biurrun
663 9d656110 Michael Niedermayer
        tmp = show_bits(&s->gb, 16);
664 ac2570a8 Michael Niedermayer
        if(tmp != 0xFFF8){
665
            av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
666
            while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
667
                skip_bits(&s->gb, 8);
668
            goto end; // we may not have enough bits left to decode a frame, so try next time
669
        }
670
        skip_bits(&s->gb, 16);
671 9d656110 Michael Niedermayer
        if (decode_frame(s) < 0){
672
            av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
673
            s->bitstream_size=0;
674
            s->bitstream_index=0;
675 4f52c312 Michael Niedermayer
            return -1;
676 9d656110 Michael Niedermayer
        }
677 4f52c312 Michael Niedermayer
    }
678 ac2570a8 Michael Niedermayer
679 115329f1 Diego Biurrun
680 4f52c312 Michael Niedermayer
#if 0
681
    /* fix the channel order here */
682
    if (s->order == MID_SIDE)
683
    {
684
        short *left = samples;
685
        short *right = samples + s->blocksize;
686
        for (i = 0; i < s->blocksize; i += 2)
687
        {
688
            uint32_t x = s->decoded[0][i];
689
            uint32_t y = s->decoded[0][i+1];
690

691
            right[i] = x - (y / 2);
692
            left[i] = right[i] + y;
693
        }
694
        *data_size = 2 * s->blocksize;
695
    }
696
    else
697
    {
698
    for (i = 0; i < s->channels; i++)
699
    {
700
        switch(s->order)
701
        {
702
            case INDEPENDENT:
703
                for (j = 0; j < s->blocksize; j++)
704
                    samples[(s->blocksize*i)+j] = s->decoded[i][j];
705
                break;
706
            case LEFT_SIDE:
707
            case RIGHT_SIDE:
708
                if (i == 0)
709
                    for (j = 0; j < s->blocksize; j++)
710
                        samples[(s->blocksize*i)+j] = s->decoded[0][j];
711
                else
712
                    for (j = 0; j < s->blocksize; j++)
713
                        samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
714
                break;
715
//            case MID_SIDE:
716 ac2570a8 Michael Niedermayer
//                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
717 4f52c312 Michael Niedermayer
        }
718
        *data_size += s->blocksize;
719
    }
720
    }
721
#else
722 9d656110 Michael Niedermayer
    switch(s->decorrelation)
723 4f52c312 Michael Niedermayer
    {
724
        case INDEPENDENT:
725 ac2570a8 Michael Niedermayer
            for (j = 0; j < s->blocksize; j++)
726 4f52c312 Michael Niedermayer
            {
727 ac2570a8 Michael Niedermayer
                for (i = 0; i < s->channels; i++)
728 4f52c312 Michael Niedermayer
                    *(samples++) = s->decoded[i][j];
729
            }
730
            break;
731
        case LEFT_SIDE:
732
            assert(s->channels == 2);
733
            for (i = 0; i < s->blocksize; i++)
734
            {
735
                *(samples++) = s->decoded[0][i];
736
                *(samples++) = s->decoded[0][i] - s->decoded[1][i];
737
            }
738
            break;
739
        case RIGHT_SIDE:
740
            assert(s->channels == 2);
741
            for (i = 0; i < s->blocksize; i++)
742
            {
743
                *(samples++) = s->decoded[0][i] + s->decoded[1][i];
744
                *(samples++) = s->decoded[1][i];
745
            }
746
            break;
747
        case MID_SIDE:
748
            assert(s->channels == 2);
749
            for (i = 0; i < s->blocksize; i++)
750
            {
751 ac2570a8 Michael Niedermayer
                int mid, side;
752 4f52c312 Michael Niedermayer
                mid = s->decoded[0][i];
753
                side = s->decoded[1][i];
754 9d656110 Michael Niedermayer
755
#if 1 //needs to be checked but IMHO it should be binary identical
756
                mid -= side>>1;
757
                *(samples++) = mid + side;
758
                *(samples++) = mid;
759
#else
760 115329f1 Diego Biurrun
761 4f52c312 Michael Niedermayer
                mid <<= 1;
762
                if (side & 1)
763
                    mid++;
764
                *(samples++) = (mid + side) >> 1;
765
                *(samples++) = (mid - side) >> 1;
766 9d656110 Michael Niedermayer
#endif
767 4f52c312 Michael Niedermayer
            }
768
            break;
769
    }
770
#endif
771
772 ac2570a8 Michael Niedermayer
    *data_size = (int8_t *)samples - (int8_t *)data;
773 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
774 4f52c312 Michael Niedermayer
775 ac2570a8 Michael Niedermayer
//    s->last_blocksize = s->blocksize;
776
end:
777
    i= (get_bits_count(&s->gb)+7)/8;;
778
    if(i > buf_size){
779
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
780 9d656110 Michael Niedermayer
        s->bitstream_size=0;
781
        s->bitstream_index=0;
782 ac2570a8 Michael Niedermayer
        return -1;
783
    }
784 4f52c312 Michael Niedermayer
785 ac2570a8 Michael Niedermayer
    if(s->bitstream_size){
786
        s->bitstream_index += i;
787
        s->bitstream_size  -= i;
788
        return input_buf_size;
789 115329f1 Diego Biurrun
    }else
790 ac2570a8 Michael Niedermayer
        return i;
791 4f52c312 Michael Niedermayer
}
792
793
static int flac_decode_close(AVCodecContext *avctx)
794
{
795
    FLACContext *s = avctx->priv_data;
796
    int i;
797 115329f1 Diego Biurrun
798 4f52c312 Michael Niedermayer
    for (i = 0; i < s->channels; i++)
799
    {
800 ac2570a8 Michael Niedermayer
        av_freep(&s->decoded[i]);
801 4f52c312 Michael Niedermayer
    }
802 ac2570a8 Michael Niedermayer
    av_freep(&s->bitstream);
803 115329f1 Diego Biurrun
804 4f52c312 Michael Niedermayer
    return 0;
805
}
806
807 1e31d32c Michael Niedermayer
static void flac_flush(AVCodecContext *avctx){
808
    FLACContext *s = avctx->priv_data;
809
810
    s->bitstream_size=
811
    s->bitstream_index= 0;
812
}
813
814 4f52c312 Michael Niedermayer
AVCodec flac_decoder = {
815
    "flac",
816
    CODEC_TYPE_AUDIO,
817
    CODEC_ID_FLAC,
818
    sizeof(FLACContext),
819
    flac_decode_init,
820
    NULL,
821
    flac_decode_close,
822
    flac_decode_frame,
823 115329f1 Diego Biurrun
    .flush= flac_flush,
824 4f52c312 Michael Niedermayer
};