Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vorbis.c @ 6636b7e8

History | View | Annotate | Download (60 KB)

1 0bde73d9 Michael Niedermayer
/**
2
 * @file vorbis.c
3
 * Vorbis I decoder
4
 * @author Denes Balatoni  ( dbalatoni programozo hu )
5 84a96d6a Denes Balatoni

6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 84a96d6a Denes Balatoni
 *
20 0bde73d9 Michael Niedermayer
 */
21
22
#undef V_DEBUG
23 8dcf48a8 Benjamin Larsson
//#define V_DEBUG
24
//#define AV_DEBUG(...) av_log(NULL, AV_LOG_INFO, __VA_ARGS__)
25 0bde73d9 Michael Niedermayer
26
#include <math.h>
27
28
#define ALT_BITSTREAM_READER_LE
29
#include "avcodec.h"
30
#include "bitstream.h"
31
#include "dsputil.h"
32
33
#include "vorbis.h"
34
35 5a408f91 Michael Niedermayer
#define V_NB_BITS 8
36
#define V_NB_BITS2 11
37 0bde73d9 Michael Niedermayer
#define V_MAX_VLCS (1<<16)
38
39
#ifndef V_DEBUG
40
#define AV_DEBUG(...)
41
#endif
42
43 f4e61cd1 Michael Niedermayer
#undef NDEBUG
44
#include <assert.h>
45 0bde73d9 Michael Niedermayer
46
/* Helper functions */
47
48
/**
49
 *  reads 0-32 bits when using the ALT_BITSTREAM_READER_LE bitstream reader
50
 */
51 ceaf1909 Dieter
static unsigned int get_bits_long_le(GetBitContext *s, int n){
52 0bde73d9 Michael Niedermayer
    if(n<=17) return get_bits(s, n);
53
    else{
54
        int ret= get_bits(s, 16);
55
        return ret | (get_bits(s, n-16) << 16);
56
    }
57
}
58
59 e19ca845 Michael Niedermayer
#define ilog(i) av_log2(2*(i))
60 0bde73d9 Michael Niedermayer
61 43eb5908 Alexander Strasser
#define BARK(x) \
62
    (13.1f*atan(0.00074f*(x))+2.24f*atan(1.85e-8f*(x)*(x))+1e-4f*(x))
63
64 0bde73d9 Michael Niedermayer
static unsigned int nth_root(unsigned int x, unsigned int n) {   // x^(1/n)
65
    unsigned int ret=0, i, j;
66
67
    do {
68
        ++ret;
69
        for(i=0,j=ret;i<n-1;i++) j*=ret;
70
    } while (j<=x);
71
72
    return (ret-1);
73
}
74
75
static float vorbisfloat2float(uint_fast32_t val) {
76
    double mant=val&0x1fffff;
77
    long exp=(val&0x7fe00000L)>>21;
78
    if (val&0x80000000) mant=-mant;
79
    return(ldexp(mant, exp-20-768));
80
}
81
82
83
// Generate vlc codes from vorbis huffman code lengths
84
85
static int vorbis_len2vlc(vorbis_context *vc, uint_fast8_t *bits, uint_fast32_t *codes, uint_fast32_t num) {
86
    uint_fast32_t exit_at_level[33]={404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
87
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
88
89
    uint_fast8_t i,j;
90
    uint_fast32_t code,p;
91
92
#ifdef V_DEBUG
93
    GetBitContext gb;
94
#endif
95
96
    for(p=0;(bits[p]==0) && (p<num);++p);
97
    if (p==num) {
98
//        av_log(vc->avccontext, AV_LOG_INFO, "An empty codebook. Heh?! \n");
99
        return 0;
100
    }
101
102
    codes[p]=0;
103
    for(i=0;i<bits[p];++i) {
104
        exit_at_level[i+1]=1<<i;
105
    }
106
107
#ifdef V_DEBUG
108
    av_log(vc->avccontext, AV_LOG_INFO, " %d. of %d code len %d code %d - ", p, num, bits[p], codes[p]);
109
    init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]);
110
    for(i=0;i<bits[p];++i) {
111
        av_log(vc->avccontext, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0");
112
    }
113
    av_log(vc->avccontext, AV_LOG_INFO, "\n");
114
#endif
115
116
    ++p;
117
118
    for(;p<num;++p) {
119
        if (bits[p]==0) continue;
120
        // find corresponding exit(node which the tree can grow further from)
121
        for(i=bits[p];i>0;--i) {
122
            if (exit_at_level[i]) break;
123
        }
124
        if (!i) return 1; // overspecified tree
125
        code=exit_at_level[i];
126
        exit_at_level[i]=0;
127
        // construct code (append 0s to end) and introduce new exits
128
        for(j=i+1;j<=bits[p];++j) {
129
            exit_at_level[j]=code+(1<<(j-1));
130
        }
131
        codes[p]=code;
132
133
#ifdef V_DEBUG
134
        av_log(vc->avccontext, AV_LOG_INFO, " %d. code len %d code %d - ", p, bits[p], codes[p]);
135
        init_get_bits(&gb, (uint_fast8_t *)&codes[p], bits[p]);
136
        for(i=0;i<bits[p];++i) {
137
            av_log(vc->avccontext, AV_LOG_INFO, "%s", get_bits1(&gb) ? "1" : "0");
138
        }
139
        av_log(vc->avccontext, AV_LOG_INFO, "\n");
140
#endif
141
142
    }
143
144
    //FIXME no exits should be left (underspecified tree - ie. unused valid vlcs - not allowed by SPEC)
145
146
    return 0;
147
}
148
149
// Free all allocated memory -----------------------------------------
150
151
static void vorbis_free(vorbis_context *vc) {
152
    int_fast16_t i;
153
154
    av_freep(&vc->channel_residues);
155
    av_freep(&vc->channel_floors);
156
    av_freep(&vc->saved);
157
    av_freep(&vc->ret);
158 13c2469d Michael Niedermayer
    av_freep(&vc->buf);
159
    av_freep(&vc->buf_tmp);
160 0bde73d9 Michael Niedermayer
161
    av_freep(&vc->residues);
162
    av_freep(&vc->modes);
163
164
    ff_mdct_end(&vc->mdct0);
165
    ff_mdct_end(&vc->mdct1);
166
167
    for(i=0;i<vc->codebook_count;++i) {
168
        av_free(vc->codebooks[i].codevectors);
169
        free_vlc(&vc->codebooks[i].vlc);
170
    }
171
    av_freep(&vc->codebooks);
172
173
    for(i=0;i<vc->floor_count;++i) {
174 43eb5908 Alexander Strasser
        if(vc->floors[i].floor_type==0) {
175 04c669ba Alexander Strasser
            av_free(vc->floors[i].data.t0.map[0]);
176
            av_free(vc->floors[i].data.t0.map[1]);
177 43eb5908 Alexander Strasser
            av_free(vc->floors[i].data.t0.book_list);
178
            av_free(vc->floors[i].data.t0.lsp);
179
        }
180
        else {
181
            av_free(vc->floors[i].data.t1.x_list);
182
            av_free(vc->floors[i].data.t1.x_list_order);
183
            av_free(vc->floors[i].data.t1.low_neighbour);
184
            av_free(vc->floors[i].data.t1.high_neighbour);
185
        }
186 0bde73d9 Michael Niedermayer
    }
187
    av_freep(&vc->floors);
188
189
    for(i=0;i<vc->mapping_count;++i) {
190
        av_free(vc->mappings[i].magnitude);
191
        av_free(vc->mappings[i].angle);
192
        av_free(vc->mappings[i].mux);
193
    }
194
    av_freep(&vc->mappings);
195
}
196
197
// Parse setup header -------------------------------------------------
198
199
// Process codebooks part
200
201
static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc) {
202
    uint_fast16_t cb;
203 84a96d6a Denes Balatoni
    uint_fast8_t *tmp_vlc_bits;
204
    uint_fast32_t *tmp_vlc_codes;
205 0bde73d9 Michael Niedermayer
    GetBitContext *gb=&vc->gb;
206
207
    vc->codebook_count=get_bits(gb,8)+1;
208
209
    AV_DEBUG(" Codebooks: %d \n", vc->codebook_count);
210
211
    vc->codebooks=(vorbis_codebook *)av_mallocz(vc->codebook_count * sizeof(vorbis_codebook));
212 84a96d6a Denes Balatoni
    tmp_vlc_bits=(uint_fast8_t *)av_mallocz(V_MAX_VLCS * sizeof(uint_fast8_t));
213
    tmp_vlc_codes=(uint_fast32_t *)av_mallocz(V_MAX_VLCS * sizeof(uint_fast32_t));
214 0bde73d9 Michael Niedermayer
215
    for(cb=0;cb<vc->codebook_count;++cb) {
216
        vorbis_codebook *codebook_setup=&vc->codebooks[cb];
217
        uint_fast8_t ordered;
218
        uint_fast32_t t, used_entries=0;
219
        uint_fast32_t entries;
220
221
        AV_DEBUG(" %d. Codebook \n", cb);
222
223
        if (get_bits(gb, 24)!=0x564342) {
224 4733abcb Måns Rullgård
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook setup data corrupt. \n", cb);
225 84a96d6a Denes Balatoni
            goto error;
226 0bde73d9 Michael Niedermayer
        }
227
228
        codebook_setup->dimensions=get_bits(gb, 16);
229
        if (codebook_setup->dimensions>16) {
230 4733abcb Måns Rullgård
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook's dimension is too large (%d). \n", cb, codebook_setup->dimensions);
231 84a96d6a Denes Balatoni
            goto error;
232 0bde73d9 Michael Niedermayer
        }
233
        entries=get_bits(gb, 24);
234
        if (entries>V_MAX_VLCS) {
235 4733abcb Måns Rullgård
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook has too many entries (%"PRIdFAST32"). \n", cb, entries);
236 84a96d6a Denes Balatoni
            goto error;
237 0bde73d9 Michael Niedermayer
        }
238
239
        ordered=get_bits1(gb);
240
241
        AV_DEBUG(" codebook_dimensions %d, codebook_entries %d \n", codebook_setup->dimensions, entries);
242
243
        if (!ordered) {
244
            uint_fast16_t ce;
245
            uint_fast8_t flag;
246
            uint_fast8_t sparse=get_bits1(gb);
247
248
            AV_DEBUG(" not ordered \n");
249
250
            if (sparse) {
251
                AV_DEBUG(" sparse \n");
252
253
                used_entries=0;
254
                for(ce=0;ce<entries;++ce) {
255
                    flag=get_bits1(gb);
256
                    if (flag) {
257
                        tmp_vlc_bits[ce]=get_bits(gb, 5)+1;
258
                        ++used_entries;
259
                    }
260
                    else tmp_vlc_bits[ce]=0;
261
                }
262
            } else {
263
                AV_DEBUG(" not sparse \n");
264
265
                used_entries=entries;
266
                for(ce=0;ce<entries;++ce) {
267
                    tmp_vlc_bits[ce]=get_bits(gb, 5)+1;
268
                }
269
            }
270
        } else {
271
            uint_fast16_t current_entry=0;
272
            uint_fast8_t current_length=get_bits(gb, 5)+1;
273
274
            AV_DEBUG(" ordered, current length: %d \n", current_length);  //FIXME
275
276
            used_entries=entries;
277
            for(;current_entry<used_entries;++current_length) {
278
                uint_fast16_t i, number;
279
280
                AV_DEBUG(" number bits: %d ", ilog(entries - current_entry));
281
282
                number=get_bits(gb, ilog(entries - current_entry));
283
284
                AV_DEBUG(" number: %d \n", number);
285
286
                for(i=current_entry;i<number+current_entry;++i) {
287
                    if (i<used_entries) tmp_vlc_bits[i]=current_length;
288
                }
289
290
                current_entry+=number;
291
            }
292
            if (current_entry>used_entries) {
293
                av_log(vc->avccontext, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
294 84a96d6a Denes Balatoni
                goto error;
295 0bde73d9 Michael Niedermayer
            }
296
        }
297
298
        codebook_setup->lookup_type=get_bits(gb, 4);
299
300
        AV_DEBUG(" lookup type: %d : %s \n", codebook_setup->lookup_type, codebook_setup->lookup_type ? "vq" : "no lookup" );
301
302
// If the codebook is used for (inverse) VQ, calculate codevectors.
303
304
        if (codebook_setup->lookup_type==1) {
305
            uint_fast16_t i, j, k;
306
            uint_fast16_t codebook_lookup_values=nth_root(entries, codebook_setup->dimensions);
307
            uint_fast16_t codebook_multiplicands[codebook_lookup_values];
308
309
            float codebook_minimum_value=vorbisfloat2float(get_bits_long_le(gb, 32));
310
            float codebook_delta_value=vorbisfloat2float(get_bits_long_le(gb, 32));
311
            uint_fast8_t codebook_value_bits=get_bits(gb, 4)+1;
312
            uint_fast8_t codebook_sequence_p=get_bits1(gb);
313
314
            AV_DEBUG(" We expect %d numbers for building the codevectors. \n", codebook_lookup_values);
315
            AV_DEBUG("  delta %f minmum %f \n", codebook_delta_value, codebook_minimum_value);
316
317
            for(i=0;i<codebook_lookup_values;++i) {
318
                codebook_multiplicands[i]=get_bits(gb, codebook_value_bits);
319
320
                AV_DEBUG(" multiplicands*delta+minmum : %e \n", (float)codebook_multiplicands[i]*codebook_delta_value+codebook_minimum_value);
321
                AV_DEBUG(" multiplicand %d \n", codebook_multiplicands[i]);
322
            }
323
324
// Weed out unused vlcs and build codevector vector
325
            codebook_setup->codevectors=(float *)av_mallocz(used_entries*codebook_setup->dimensions * sizeof(float));
326
            for(j=0, i=0;i<entries;++i) {
327
                uint_fast8_t dim=codebook_setup->dimensions;
328
329
                if (tmp_vlc_bits[i]) {
330
                    float last=0.0;
331
                    uint_fast32_t lookup_offset=i;
332
333
#ifdef V_DEBUG
334
                    av_log(vc->avccontext, AV_LOG_INFO, "Lookup offset %d ,", i);
335
#endif
336
337
                    for(k=0;k<dim;++k) {
338
                        uint_fast32_t multiplicand_offset = lookup_offset % codebook_lookup_values;
339
                        codebook_setup->codevectors[j*dim+k]=codebook_multiplicands[multiplicand_offset]*codebook_delta_value+codebook_minimum_value+last;
340
                        if (codebook_sequence_p) {
341
                            last=codebook_setup->codevectors[j*dim+k];
342
                        }
343
                        lookup_offset/=codebook_lookup_values;
344
                    }
345
                    tmp_vlc_bits[j]=tmp_vlc_bits[i];
346
347
#ifdef V_DEBUG
348
                    av_log(vc->avccontext, AV_LOG_INFO, "real lookup offset %d, vector: ", j);
349
                    for(k=0;k<dim;++k) {
350
                        av_log(vc->avccontext, AV_LOG_INFO, " %f ", codebook_setup->codevectors[j*dim+k]);
351
                    }
352
                    av_log(vc->avccontext, AV_LOG_INFO, "\n");
353
#endif
354
355
                    ++j;
356
                }
357
            }
358
            if (j!=used_entries) {
359
                av_log(vc->avccontext, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
360 84a96d6a Denes Balatoni
                goto error;
361 0bde73d9 Michael Niedermayer
            }
362
            entries=used_entries;
363
        }
364
        else if (codebook_setup->lookup_type>=2) {
365
            av_log(vc->avccontext, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
366 84a96d6a Denes Balatoni
            goto error;
367 0bde73d9 Michael Niedermayer
        }
368
369
// Initialize VLC table
370
        if (vorbis_len2vlc(vc, tmp_vlc_bits, tmp_vlc_codes, entries)) {
371
            av_log(vc->avccontext, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
372 84a96d6a Denes Balatoni
            goto error;
373 0bde73d9 Michael Niedermayer
        }
374
        codebook_setup->maxdepth=0;
375
        for(t=0;t<entries;++t)
376
            if (tmp_vlc_bits[t]>=codebook_setup->maxdepth) codebook_setup->maxdepth=tmp_vlc_bits[t];
377
378 5a408f91 Michael Niedermayer
        if(codebook_setup->maxdepth > 3*V_NB_BITS) codebook_setup->nb_bits=V_NB_BITS2;
379
        else                                       codebook_setup->nb_bits=V_NB_BITS;
380 0bde73d9 Michael Niedermayer
381 5a408f91 Michael Niedermayer
        codebook_setup->maxdepth=(codebook_setup->maxdepth+codebook_setup->nb_bits-1)/codebook_setup->nb_bits;
382 115329f1 Diego Biurrun
383 5a408f91 Michael Niedermayer
        if (init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits, entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits), sizeof(*tmp_vlc_bits), tmp_vlc_codes, sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes), INIT_VLC_LE)) {
384 0bde73d9 Michael Niedermayer
            av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n");
385 84a96d6a Denes Balatoni
            goto error;
386 0bde73d9 Michael Niedermayer
        }
387
    }
388 84a96d6a Denes Balatoni
389
    av_free(tmp_vlc_bits);
390
    av_free(tmp_vlc_codes);
391 0bde73d9 Michael Niedermayer
    return 0;
392 84a96d6a Denes Balatoni
393
// Error:
394
error:
395
    av_free(tmp_vlc_bits);
396
    av_free(tmp_vlc_codes);
397
    return 1;
398 0bde73d9 Michael Niedermayer
}
399
400
// Process time domain transforms part (unused in Vorbis I)
401
402
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc) {
403
    GetBitContext *gb=&vc->gb;
404
    uint_fast8_t i;
405
    uint_fast8_t vorbis_time_count=get_bits(gb, 6)+1;
406
407
    for(i=0;i<vorbis_time_count;++i) {
408
        uint_fast16_t vorbis_tdtransform=get_bits(gb, 16);
409
410
        AV_DEBUG(" Vorbis time domain transform %d: %d \n", vorbis_time_count, vorbis_tdtransform);
411
412
        if (vorbis_tdtransform) {
413
            av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
414
            return 1;
415
        }
416
    }
417
    return 0;
418
}
419
420 43eb5908 Alexander Strasser
// Process floors part
421 0bde73d9 Michael Niedermayer
422 43eb5908 Alexander Strasser
static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
423
                                         vorbis_floor_data *vfu, float *vec);
424 04c669ba Alexander Strasser
static void create_map( vorbis_context * vc, uint_fast8_t floor_number );
425 43eb5908 Alexander Strasser
static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc,
426
                                         vorbis_floor_data *vfu, float *vec);
427 0bde73d9 Michael Niedermayer
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc) {
428
    GetBitContext *gb=&vc->gb;
429
    uint_fast16_t i,j,k;
430
431
    vc->floor_count=get_bits(gb, 6)+1;
432
433
    vc->floors=(vorbis_floor *)av_mallocz(vc->floor_count * sizeof(vorbis_floor));
434
435
    for (i=0;i<vc->floor_count;++i) {
436
        vorbis_floor *floor_setup=&vc->floors[i];
437
438
        floor_setup->floor_type=get_bits(gb, 16);
439
440
        AV_DEBUG(" %d. floor type %d \n", i, floor_setup->floor_type);
441
442
        if (floor_setup->floor_type==1) {
443
            uint_fast8_t maximum_class=0;
444
            uint_fast8_t rangebits;
445
            uint_fast16_t floor1_values=2;
446
447 43eb5908 Alexander Strasser
            floor_setup->decode=vorbis_floor1_decode;
448
449
            floor_setup->data.t1.partitions=get_bits(gb, 5);
450 0bde73d9 Michael Niedermayer
451 43eb5908 Alexander Strasser
            AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->data.t1.partitions);
452 0bde73d9 Michael Niedermayer
453 43eb5908 Alexander Strasser
            for(j=0;j<floor_setup->data.t1.partitions;++j) {
454
                floor_setup->data.t1.partition_class[j]=get_bits(gb, 4);
455
                if (floor_setup->data.t1.partition_class[j]>maximum_class) maximum_class=floor_setup->data.t1.partition_class[j];
456 0bde73d9 Michael Niedermayer
457 43eb5908 Alexander Strasser
                AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->data.t1.partition_class[j]);
458 0bde73d9 Michael Niedermayer
459
            }
460
461
            AV_DEBUG(" maximum class %d \n", maximum_class);
462
463 43eb5908 Alexander Strasser
            floor_setup->data.t1.maximum_class=maximum_class;
464 0bde73d9 Michael Niedermayer
465
            for(j=0;j<=maximum_class;++j) {
466 43eb5908 Alexander Strasser
                floor_setup->data.t1.class_dimensions[j]=get_bits(gb, 3)+1;
467
                floor_setup->data.t1.class_subclasses[j]=get_bits(gb, 2);
468 0bde73d9 Michael Niedermayer
469 43eb5908 Alexander Strasser
                AV_DEBUG(" %d floor %d class dim: %d subclasses %d \n", i, j, floor_setup->data.t1.class_dimensions[j], floor_setup->data.t1.class_subclasses[j]);
470 0bde73d9 Michael Niedermayer
471 43eb5908 Alexander Strasser
                if (floor_setup->data.t1.class_subclasses[j]) {
472
                    floor_setup->data.t1.class_masterbook[j]=get_bits(gb, 8);
473 0bde73d9 Michael Niedermayer
474 43eb5908 Alexander Strasser
                    AV_DEBUG("   masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
475 0bde73d9 Michael Niedermayer
                }
476
477 43eb5908 Alexander Strasser
                for(k=0;k<(1<<floor_setup->data.t1.class_subclasses[j]);++k) {
478 24efb5e5 Loren Merritt
                    floor_setup->data.t1.subclass_books[j][k]=(int16_t)get_bits(gb, 8)-1;
479 0bde73d9 Michael Niedermayer
480 43eb5908 Alexander Strasser
                    AV_DEBUG("    book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
481 0bde73d9 Michael Niedermayer
                }
482
            }
483
484 43eb5908 Alexander Strasser
            floor_setup->data.t1.multiplier=get_bits(gb, 2)+1;
485
            floor_setup->data.t1.x_list_dim=2;
486 0bde73d9 Michael Niedermayer
487 43eb5908 Alexander Strasser
            for(j=0;j<floor_setup->data.t1.partitions;++j) {
488
                floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
489 0bde73d9 Michael Niedermayer
            }
490
491 43eb5908 Alexander Strasser
            floor_setup->data.t1.x_list=(uint_fast16_t *)av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(uint_fast16_t));
492
            floor_setup->data.t1.x_list_order=(uint_fast16_t *)av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(uint_fast16_t));
493
            floor_setup->data.t1.low_neighbour=(uint_fast16_t *)av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(uint_fast16_t));
494
            floor_setup->data.t1.high_neighbour=(uint_fast16_t *)av_mallocz(floor_setup->data.t1.x_list_dim * sizeof(uint_fast16_t));
495 0bde73d9 Michael Niedermayer
496
497
            rangebits=get_bits(gb, 4);
498 43eb5908 Alexander Strasser
            floor_setup->data.t1.x_list[0] = 0;
499
            floor_setup->data.t1.x_list[1] = (1<<rangebits);
500 0bde73d9 Michael Niedermayer
501 43eb5908 Alexander Strasser
            for(j=0;j<floor_setup->data.t1.partitions;++j) {
502
                for(k=0;k<floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];++k,++floor1_values) {
503
                    floor_setup->data.t1.x_list[floor1_values]=get_bits(gb, rangebits);
504 0bde73d9 Michael Niedermayer
505 43eb5908 Alexander Strasser
                    AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values, floor_setup->data.t1.x_list[floor1_values]);
506 0bde73d9 Michael Niedermayer
                }
507
            }
508
509
// Precalculate order of x coordinates - needed for decode
510
511 43eb5908 Alexander Strasser
            for(k=0;k<floor_setup->data.t1.x_list_dim;++k) {
512
                floor_setup->data.t1.x_list_order[k]=k;
513 0bde73d9 Michael Niedermayer
            }
514
515 43eb5908 Alexander Strasser
            for(k=0;k<floor_setup->data.t1.x_list_dim-1;++k) {   // FIXME optimize sorting ?
516
                for(j=k+1;j<floor_setup->data.t1.x_list_dim;++j) {
517
                    if(floor_setup->data.t1.x_list[floor_setup->data.t1.x_list_order[k]]>floor_setup->data.t1.x_list[floor_setup->data.t1.x_list_order[j]]) {
518
                        uint_fast16_t tmp=floor_setup->data.t1.x_list_order[k];
519
                        floor_setup->data.t1.x_list_order[k]=floor_setup->data.t1.x_list_order[j];
520
                        floor_setup->data.t1.x_list_order[j]=tmp;
521 0bde73d9 Michael Niedermayer
                    }
522
                }
523
            }
524
525
// Precalculate low and high neighbours
526
527 43eb5908 Alexander Strasser
            for(k=2;k<floor_setup->data.t1.x_list_dim;++k) {
528
                floor_setup->data.t1.low_neighbour[k]=0;
529
                floor_setup->data.t1.high_neighbour[k]=1;  // correct according to SPEC requirements
530 0bde73d9 Michael Niedermayer
531
                for (j=0;j<k;++j) {
532 43eb5908 Alexander Strasser
                    if ((floor_setup->data.t1.x_list[j]<floor_setup->data.t1.x_list[k]) &&
533
                      (floor_setup->data.t1.x_list[j]>floor_setup->data.t1.x_list[floor_setup->data.t1.low_neighbour[k]])) {
534
                        floor_setup->data.t1.low_neighbour[k]=j;
535 0bde73d9 Michael Niedermayer
                    }
536 43eb5908 Alexander Strasser
                    if ((floor_setup->data.t1.x_list[j]>floor_setup->data.t1.x_list[k]) &&
537
                      (floor_setup->data.t1.x_list[j]<floor_setup->data.t1.x_list[floor_setup->data.t1.high_neighbour[k]])) {
538
                        floor_setup->data.t1.high_neighbour[k]=j;
539 0bde73d9 Michael Niedermayer
                    }
540
                }
541
            }
542
        }
543 43eb5908 Alexander Strasser
        else if(floor_setup->floor_type==0) {
544
            uint_fast8_t max_codebook_dim=0;
545
546
            floor_setup->decode=vorbis_floor0_decode;
547
548
            floor_setup->data.t0.order=get_bits(gb, 8);
549
            floor_setup->data.t0.rate=get_bits(gb, 16);
550
            floor_setup->data.t0.bark_map_size=get_bits(gb, 16);
551
            floor_setup->data.t0.amplitude_bits=get_bits(gb, 6);
552 536b48b2 Alexander Strasser
            /* zero would result in a div by zero later *
553
             * 2^0 - 1 == 0                             */
554
            if (floor_setup->data.t0.amplitude_bits == 0) {
555
              av_log(vc->avccontext, AV_LOG_ERROR,
556
                     "Floor 0 amplitude bits is 0.\n");
557
              return 1;
558
            }
559 43eb5908 Alexander Strasser
            floor_setup->data.t0.amplitude_offset=get_bits(gb, 8);
560
            floor_setup->data.t0.num_books=get_bits(gb, 4)+1;
561
562
            /* allocate mem for booklist */
563
            floor_setup->data.t0.book_list=
564
                av_malloc(floor_setup->data.t0.num_books);
565
            if(!floor_setup->data.t0.book_list) { return 1; }
566
            /* read book indexes */
567
            {
568
                int idx;
569
                uint_fast8_t book_idx;
570
                for (idx=0;idx<floor_setup->data.t0.num_books;++idx) {
571
                    book_idx=get_bits(gb, 8);
572
                    floor_setup->data.t0.book_list[idx]=book_idx;
573
                    if (vc->codebooks[book_idx].dimensions > max_codebook_dim)
574
                        max_codebook_dim=vc->codebooks[book_idx].dimensions;
575
576
                    if (floor_setup->data.t0.book_list[idx]>vc->codebook_count)
577
                        return 1;
578
                }
579
            }
580
581 04c669ba Alexander Strasser
            create_map( vc, i );
582
583 43eb5908 Alexander Strasser
            /* allocate mem for lsp coefficients */
584
            {
585
                /* codebook dim is for padding if codebook dim doesn't *
586
                 * divide order+1 then we need to read more data       */
587
                floor_setup->data.t0.lsp=
588
                    av_malloc((floor_setup->data.t0.order+1 + max_codebook_dim)
589
                              * sizeof(float));
590 536b48b2 Alexander Strasser
                if(!floor_setup->data.t0.lsp) { return 1; }
591 43eb5908 Alexander Strasser
            }
592
593
#ifdef V_DEBUG /* debug output parsed headers */
594
            AV_DEBUG("floor0 order: %u\n", floor_setup->data.t0.order);
595
            AV_DEBUG("floor0 rate: %u\n", floor_setup->data.t0.rate);
596
            AV_DEBUG("floor0 bark map size: %u\n",
597
              floor_setup->data.t0.bark_map_size);
598
            AV_DEBUG("floor0 amplitude bits: %u\n",
599
              floor_setup->data.t0.amplitude_bits);
600
            AV_DEBUG("floor0 amplitude offset: %u\n",
601
              floor_setup->data.t0.amplitude_offset);
602
            AV_DEBUG("floor0 number of books: %u\n",
603
              floor_setup->data.t0.num_books);
604
            AV_DEBUG("floor0 book list pointer: %p\n",
605
              floor_setup->data.t0.book_list);
606
            {
607
              int idx;
608
              for (idx=0;idx<floor_setup->data.t0.num_books;++idx) {
609
                AV_DEBUG( "  Book %d: %u\n",
610
                  idx+1,
611
                  floor_setup->data.t0.book_list[idx] );
612
              }
613
            }
614
#endif
615
        }
616 0bde73d9 Michael Niedermayer
        else {
617 43eb5908 Alexander Strasser
            av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n");
618 0bde73d9 Michael Niedermayer
            return 1;
619
        }
620
    }
621
    return 0;
622
}
623
624
// Process residues part
625
626
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc){
627
    GetBitContext *gb=&vc->gb;
628
    uint_fast8_t i, j, k;
629
630
    vc->residue_count=get_bits(gb, 6)+1;
631
    vc->residues=(vorbis_residue *)av_mallocz(vc->residue_count * sizeof(vorbis_residue));
632
633
    AV_DEBUG(" There are %d residues. \n", vc->residue_count);
634
635
    for(i=0;i<vc->residue_count;++i) {
636
        vorbis_residue *res_setup=&vc->residues[i];
637
        uint_fast8_t cascade[64];
638
        uint_fast8_t high_bits;
639
        uint_fast8_t low_bits;
640
641
        res_setup->type=get_bits(gb, 16);
642
643
        AV_DEBUG(" %d. residue type %d \n", i, res_setup->type);
644
645
        res_setup->begin=get_bits(gb, 24);
646
        res_setup->end=get_bits(gb, 24);
647
        res_setup->partition_size=get_bits(gb, 24)+1;
648
        res_setup->classifications=get_bits(gb, 6)+1;
649
        res_setup->classbook=get_bits(gb, 8);
650
651
        AV_DEBUG("    begin %d end %d part.size %d classif.s %d classbook %d \n", res_setup->begin, res_setup->end, res_setup->partition_size,
652
          res_setup->classifications, res_setup->classbook);
653
654
        for(j=0;j<res_setup->classifications;++j) {
655
            high_bits=0;
656
            low_bits=get_bits(gb, 3);
657
            if (get_bits1(gb)) {
658
                high_bits=get_bits(gb, 5);
659
            }
660
            cascade[j]=(high_bits<<3)+low_bits;
661
662
            AV_DEBUG("     %d class casscade depth: %d \n", j, ilog(cascade[j]));
663
        }
664
665
        res_setup->maxpass=0;
666
        for(j=0;j<res_setup->classifications;++j) {
667
            for(k=0;k<8;++k) {
668
                if (cascade[j]&(1<<k)) {
669
                        res_setup->books[j][k]=get_bits(gb, 8);
670
671
                    AV_DEBUG("     %d class casscade depth %d book: %d \n", j, k, res_setup->books[j][k]);
672
673
                    if (k>res_setup->maxpass) {
674
                        res_setup->maxpass=k;
675
                    }
676
                } else {
677
                    res_setup->books[j][k]=-1;
678
                }
679
            }
680
        }
681
    }
682
    return 0;
683
}
684
685
// Process mappings part
686
687
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc) {
688
    GetBitContext *gb=&vc->gb;
689
    uint_fast8_t i, j;
690
691
    vc->mapping_count=get_bits(gb, 6)+1;
692
    vc->mappings=(vorbis_mapping *)av_mallocz(vc->mapping_count * sizeof(vorbis_mapping));
693
694
    AV_DEBUG(" There are %d mappings. \n", vc->mapping_count);
695
696
    for(i=0;i<vc->mapping_count;++i) {
697
        vorbis_mapping *mapping_setup=&vc->mappings[i];
698
699
        if (get_bits(gb, 16)) {
700
            av_log(vc->avccontext, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
701
            return 1;
702
        }
703
        if (get_bits1(gb)) {
704
            mapping_setup->submaps=get_bits(gb, 4)+1;
705
        } else {
706
            mapping_setup->submaps=1;
707
        }
708
709
        if (get_bits1(gb)) {
710
            mapping_setup->coupling_steps=get_bits(gb, 8)+1;
711
            mapping_setup->magnitude=(uint_fast8_t *)av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
712
            mapping_setup->angle=(uint_fast8_t *)av_mallocz(mapping_setup->coupling_steps * sizeof(uint_fast8_t));
713
            for(j=0;j<mapping_setup->coupling_steps;++j) {
714
                mapping_setup->magnitude[j]=get_bits(gb, ilog(vc->audio_channels-1));
715
                mapping_setup->angle[j]=get_bits(gb, ilog(vc->audio_channels-1));
716
                // FIXME: sanity checks
717
            }
718
        } else {
719
            mapping_setup->coupling_steps=0;
720
        }
721
722
        AV_DEBUG("   %d mapping coupling steps: %d \n", i, mapping_setup->coupling_steps);
723
724
        if(get_bits(gb, 2)) {
725
            av_log(vc->avccontext, AV_LOG_ERROR, "%d. mapping setup data invalid. \n", i);
726
            return 1; // following spec.
727
        }
728
729
        if (mapping_setup->submaps>1) {
730
            mapping_setup->mux=(uint_fast8_t *)av_mallocz(vc->audio_channels * sizeof(uint_fast8_t));
731
            for(j=0;j<vc->audio_channels;++j) {
732
                mapping_setup->mux[j]=get_bits(gb, 4);
733
            }
734
        }
735
736
        for(j=0;j<mapping_setup->submaps;++j) {
737
            get_bits(gb, 8); // FIXME check?
738
            mapping_setup->submap_floor[j]=get_bits(gb, 8);
739
            mapping_setup->submap_residue[j]=get_bits(gb, 8);
740
741
            AV_DEBUG("   %d mapping %d submap : floor %d, residue %d \n", i, j, mapping_setup->submap_floor[j], mapping_setup->submap_residue[j]);
742
        }
743
    }
744
    return 0;
745
}
746
747
// Process modes part
748
749 04c669ba Alexander Strasser
static void create_map( vorbis_context * vc, uint_fast8_t floor_number )
750 43eb5908 Alexander Strasser
{
751
    vorbis_floor * floors=vc->floors;
752
    vorbis_floor0 * vf;
753
    int idx;
754 04c669ba Alexander Strasser
    int_fast8_t blockflag;
755 43eb5908 Alexander Strasser
    int_fast32_t * map;
756
    int_fast32_t n; //TODO: could theoretically be smaller?
757
758 04c669ba Alexander Strasser
    for (blockflag=0;blockflag<2;++blockflag)
759
    {
760
    n=(blockflag ? vc->blocksize_1 : vc->blocksize_0) / 2;
761
    floors[floor_number].data.t0.map[blockflag]=
762 43eb5908 Alexander Strasser
        av_malloc((n+1) * sizeof(int_fast32_t)); // n+sentinel
763
764 04c669ba Alexander Strasser
    map=floors[floor_number].data.t0.map[blockflag];
765
    vf=&floors[floor_number].data.t0;
766 43eb5908 Alexander Strasser
767
    for (idx=0; idx<n;++idx) {
768
        map[idx]=floor( BARK((vf->rate*idx)/(2.0f*n)) *
769
                              ((vf->bark_map_size)/
770
                               BARK(vf->rate/2.0f )) );
771
        if (vf->bark_map_size-1 < map[idx]) {
772
            map[idx]=vf->bark_map_size-1;
773
        }
774
    }
775
    map[n]=-1;
776 04c669ba Alexander Strasser
    vf->map_size[blockflag]=n;
777
    }
778 43eb5908 Alexander Strasser
779
#   ifdef V_DEBUG
780
    for(idx=0;idx<=n;++idx) {
781
        AV_DEBUG("floor0 map: map at pos %d is %d\n",
782
                 idx, map[idx]);
783
    }
784
#   endif
785
}
786
787 0bde73d9 Michael Niedermayer
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc) {
788
    GetBitContext *gb=&vc->gb;
789
    uint_fast8_t i;
790
791
    vc->mode_count=get_bits(gb, 6)+1;
792
    vc->modes=(vorbis_mode *)av_mallocz(vc->mode_count * sizeof(vorbis_mode));
793
794
    AV_DEBUG(" There are %d modes.\n", vc->mode_count);
795
796
    for(i=0;i<vc->mode_count;++i) {
797
        vorbis_mode *mode_setup=&vc->modes[i];
798
799
        mode_setup->blockflag=get_bits(gb, 1);
800
        mode_setup->windowtype=get_bits(gb, 16); //FIXME check
801
        mode_setup->transformtype=get_bits(gb, 16); //FIXME check
802
        mode_setup->mapping=get_bits(gb, 8); //FIXME check
803
804
        AV_DEBUG(" %d mode: blockflag %d, windowtype %d, transformtype %d, mapping %d \n", i, mode_setup->blockflag, mode_setup->windowtype, mode_setup->transformtype, mode_setup->mapping);
805
    }
806
    return 0;
807
}
808
809
// Process the whole setup header using the functions above
810
811
static int vorbis_parse_setup_hdr(vorbis_context *vc) {
812
    GetBitContext *gb=&vc->gb;
813
814
    if ((get_bits(gb, 8)!='v') || (get_bits(gb, 8)!='o') ||
815
    (get_bits(gb, 8)!='r') || (get_bits(gb, 8)!='b') ||
816
    (get_bits(gb, 8)!='i') || (get_bits(gb, 8)!='s')) {
817
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
818
        return 1;
819
    }
820
821
    if (vorbis_parse_setup_hdr_codebooks(vc)) {
822
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
823
        return 2;
824
    }
825
    if (vorbis_parse_setup_hdr_tdtransforms(vc)) {
826
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
827
        return 3;
828
    }
829
    if (vorbis_parse_setup_hdr_floors(vc)) {
830
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
831
        return 4;
832
    }
833
    if (vorbis_parse_setup_hdr_residues(vc)) {
834
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
835
        return 5;
836
    }
837
    if (vorbis_parse_setup_hdr_mappings(vc)) {
838
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
839
        return 6;
840
    }
841
    if (vorbis_parse_setup_hdr_modes(vc)) {
842
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
843
        return 7;
844
    }
845
    if (!get_bits1(gb)) {
846
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
847
        return 8; // framing flag bit unset error
848
    }
849
850
    return 0;
851
}
852
853
// Process the identification header
854
855
static int vorbis_parse_id_hdr(vorbis_context *vc){
856
    GetBitContext *gb=&vc->gb;
857
    uint_fast8_t bl0, bl1;
858
    const float *vwin[8]={ vwin64, vwin128, vwin256, vwin512, vwin1024, vwin2048, vwin4096, vwin8192 };
859
860
    if ((get_bits(gb, 8)!='v') || (get_bits(gb, 8)!='o') ||
861
    (get_bits(gb, 8)!='r') || (get_bits(gb, 8)!='b') ||
862
    (get_bits(gb, 8)!='i') || (get_bits(gb, 8)!='s')) {
863
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
864
        return 1;
865
    }
866
867
    vc->version=get_bits_long_le(gb, 32);    //FIXME check 0
868
    vc->audio_channels=get_bits(gb, 8);   //FIXME check >0
869
    vc->audio_samplerate=get_bits_long_le(gb, 32);   //FIXME check >0
870
    vc->bitrate_maximum=get_bits_long_le(gb, 32);
871
    vc->bitrate_nominal=get_bits_long_le(gb, 32);
872
    vc->bitrate_minimum=get_bits_long_le(gb, 32);
873
    bl0=get_bits(gb, 4);
874
    bl1=get_bits(gb, 4);
875
    vc->blocksize_0=(1<<bl0);
876
    vc->blocksize_1=(1<<bl1);
877 f267587e Uoti Urpala
    if (bl0>13 || bl0<6 || bl1>13 || bl1<6 || bl1<bl0) {
878 0bde73d9 Michael Niedermayer
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
879
        return 3;
880
    }
881 f267587e Uoti Urpala
    // output format int16
882
    if (vc->blocksize_1/2 * vc->audio_channels * 2 >
883
                                             AVCODEC_MAX_AUDIO_FRAME_SIZE) {
884
        av_log(vc->avccontext, AV_LOG_ERROR, "Vorbis channel count makes "
885
               "output packets too large.\n");
886
        return 4;
887
    }
888 0bde73d9 Michael Niedermayer
    vc->swin=vwin[bl0-6];
889
    vc->lwin=vwin[bl1-6];
890
891
    if ((get_bits1(gb)) == 0) {
892
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
893
        return 2;
894
    }
895
896
    vc->channel_residues=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float));
897
    vc->channel_floors=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float));
898
    vc->saved=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float));
899
    vc->ret=(float *)av_malloc((vc->blocksize_1/2)*vc->audio_channels * sizeof(float));
900 13c2469d Michael Niedermayer
    vc->buf=(float *)av_malloc(vc->blocksize_1 * sizeof(float));
901
    vc->buf_tmp=(float *)av_malloc(vc->blocksize_1 * sizeof(float));
902 0bde73d9 Michael Niedermayer
    vc->saved_start=0;
903
904
    ff_mdct_init(&vc->mdct0, bl0, 1);
905
    ff_mdct_init(&vc->mdct1, bl1, 1);
906
907
    AV_DEBUG(" vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
908
            vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize_0, vc->blocksize_1);
909
910
/*
911
    BLK=vc->blocksize_0;
912
    for(i=0;i<BLK/2;++i) {
913
        vc->swin[i]=sin(0.5*3.14159265358*(sin(((float)i+0.5)/(float)BLK*3.14159265358))*(sin(((float)i+0.5)/(float)BLK*3.14159265358)));
914
    }
915
*/
916
917
    return 0;
918
}
919
920
// Process the extradata using the functions above (identification header, setup header)
921
922
static int vorbis_decode_init(AVCodecContext *avccontext) {
923
    vorbis_context *vc = avccontext->priv_data ;
924
    uint8_t *headers = avccontext->extradata;
925
    int headers_len=avccontext->extradata_size;
926 2c578058 Måns Rullgård
    uint8_t *header_start[3];
927 0bde73d9 Michael Niedermayer
    int header_len[3];
928
    GetBitContext *gb = &(vc->gb);
929
    int i, j, hdr_type;
930
931
    vc->avccontext = avccontext;
932
933 2c578058 Måns Rullgård
    if (!headers_len) {
934 0bde73d9 Michael Niedermayer
        av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
935
        return -1;
936
    }
937
938 2c578058 Måns Rullgård
    if(headers[0] == 0 && headers[1] == 30) {
939
        for(i = 0; i < 3; i++){
940
            header_len[i] = *headers++ << 8;
941
            header_len[i] += *headers++;
942
            header_start[i] = headers;
943
            headers += header_len[i];
944 0bde73d9 Michael Niedermayer
        }
945 2c578058 Måns Rullgård
    } else if(headers[0] == 2) {
946
        for(j=1,i=0;i<2;++i, ++j) {
947
            header_len[i]=0;
948
            while(j<headers_len && headers[j]==0xff) {
949
                header_len[i]+=0xff;
950
                ++j;
951
            }
952
            if (j>=headers_len) {
953
                av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
954
                return -1;
955
            }
956
            header_len[i]+=headers[j];
957 0bde73d9 Michael Niedermayer
        }
958 2c578058 Måns Rullgård
        header_len[2]=headers_len-header_len[0]-header_len[1]-j;
959
        headers+=j;
960
        header_start[0] = headers;
961
        header_start[1] = header_start[0] + header_len[0];
962
        header_start[2] = header_start[1] + header_len[1];
963
    } else {
964
        av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
965
        return -1;
966 0bde73d9 Michael Niedermayer
    }
967
968 2c578058 Måns Rullgård
    init_get_bits(gb, header_start[0], header_len[0]*8);
969 0bde73d9 Michael Niedermayer
    hdr_type=get_bits(gb, 8);
970
    if (hdr_type!=1) {
971
        av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n");
972
        return -1;
973
    }
974
    if (vorbis_parse_id_hdr(vc)) {
975
        av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n");
976
        vorbis_free(vc);
977
        return -1;
978
    }
979
980 2c578058 Måns Rullgård
    init_get_bits(gb, header_start[2], header_len[2]*8);
981 0bde73d9 Michael Niedermayer
    hdr_type=get_bits(gb, 8);
982
    if (hdr_type!=5) {
983
        av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n");
984
        return -1;
985
    }
986
    if (vorbis_parse_setup_hdr(vc)) {
987
        av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n");
988
        vorbis_free(vc);
989
        return -1;
990
    }
991
992
    avccontext->channels = vc->audio_channels;
993
    avccontext->sample_rate = vc->audio_samplerate;
994
995
    return 0 ;
996
}
997
998
// Decode audiopackets -------------------------------------------------
999
1000 43eb5908 Alexander Strasser
// Read and decode floor
1001
1002
static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
1003
                                         vorbis_floor_data *vfu, float *vec) {
1004
    vorbis_floor0 * vf=&vfu->t0;
1005
    float * lsp=vf->lsp;
1006
    uint_fast32_t amplitude;
1007
    uint_fast32_t book_idx;
1008 04c669ba Alexander Strasser
    uint_fast8_t blockflag=vc->modes[vc->mode_number].blockflag;
1009 43eb5908 Alexander Strasser
1010
    amplitude=get_bits(&vc->gb, vf->amplitude_bits);
1011
    if (amplitude>0) {
1012
        float last = 0;
1013
        uint_fast16_t lsp_len = 0;
1014
        uint_fast16_t idx;
1015
        vorbis_codebook codebook;
1016
1017
        book_idx=get_bits(&vc->gb, ilog(vf->num_books));
1018
        if ( book_idx >= vf->num_books ) {
1019
            av_log( vc->avccontext, AV_LOG_ERROR,
1020
                    "floor0 dec: booknumber too high!\n" );
1021
            //FIXME: look above
1022
        }
1023
        AV_DEBUG( "floor0 dec: booknumber: %u\n", book_idx );
1024
        codebook=vc->codebooks[vf->book_list[book_idx]];
1025
1026
        while (lsp_len<vf->order) {
1027
            int vec_off;
1028
1029
            AV_DEBUG( "floor0 dec: book dimension: %d\n", codebook.dimensions );
1030
            AV_DEBUG( "floor0 dec: maximum depth: %d\n", codebook.maxdepth );
1031
            /* read temp vector */
1032
            vec_off=get_vlc2(&vc->gb,
1033
                             codebook.vlc.table,
1034
                             codebook.nb_bits,
1035
                             codebook.maxdepth ) *
1036
                             codebook.dimensions;
1037
            AV_DEBUG( "floor0 dec: vector offset: %d\n", vec_off );
1038
            /* copy each vector component and add last to it */
1039
            for (idx=0; idx<codebook.dimensions; ++idx) {
1040
                lsp[lsp_len+idx]=codebook.codevectors[vec_off+idx]+last;
1041
            }
1042
            last=lsp[lsp_len+idx-1]; /* set last to last vector component */
1043
1044
            lsp_len += codebook.dimensions;
1045
        }
1046
#ifdef V_DEBUG
1047
        /* DEBUG: output lsp coeffs */
1048
        {
1049
            int idx;
1050
            for ( idx = 0; idx < lsp_len; ++idx )
1051
                AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx, lsp[idx] );
1052
        }
1053
#endif
1054
1055
        /* synthesize floor output vector */
1056
        {
1057
            int i;
1058
            int order=vf->order;
1059
            float wstep=M_PI/vf->bark_map_size;
1060
1061
            for(i=0;i<order;i++) { lsp[i]=2.0f*cos(lsp[i]); }
1062
1063
            AV_DEBUG("floor0 synth: map_size=%d; m=%d; wstep=%f\n",
1064
                     vf->map_size, order, wstep);
1065
1066
            i=0;
1067 04c669ba Alexander Strasser
            while(i<vf->map_size[blockflag]) {
1068
                int j, iter_cond=vf->map[blockflag][i];
1069 43eb5908 Alexander Strasser
                float p=0.5f;
1070
                float q=0.5f;
1071
                float two_cos_w=2.0f*cos(wstep*iter_cond); // needed all times
1072
1073
                /* similar part for the q and p products */
1074
                for(j=0;j<order;j+=2) {
1075
                    q *= lsp[j]  -two_cos_w;
1076
                    p *= lsp[j+1]-two_cos_w;
1077
                }
1078
                if(j==order) { // even order
1079
                    p *= p*(2.0f-two_cos_w);
1080
                    q *= q*(2.0f+two_cos_w);
1081
                }
1082
                else { // odd order
1083
                    q *= two_cos_w-lsp[j]; // one more time for q
1084
1085
                    /* final step and square */
1086
                    p *= p*(4.f-two_cos_w*two_cos_w);
1087
                    q *= q;
1088
                }
1089
1090
                /* calculate linear floor value */
1091
                {
1092
                    q=exp( (
1093
                             ( (amplitude*vf->amplitude_offset)/
1094 536b48b2 Alexander Strasser
                               (((1<<vf->amplitude_bits)-1) * sqrt(p+q)) )
1095 43eb5908 Alexander Strasser
                             - vf->amplitude_offset ) * .11512925f
1096
                         );
1097
                }
1098
1099
                /* fill vector */
1100 04c669ba Alexander Strasser
                do { vec[i]=q; ++i; }while(vf->map[blockflag][i]==iter_cond);
1101 43eb5908 Alexander Strasser
            }
1102
        }
1103
    }
1104
    else {
1105
        /* this channel is unused */
1106
        return 1;
1107
    }
1108
1109
    AV_DEBUG(" Floor0 decoded\n");
1110 0bde73d9 Michael Niedermayer
1111 43eb5908 Alexander Strasser
    return 0;
1112
}
1113
static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec) {
1114
    vorbis_floor1 * vf=&vfu->t1;
1115 0bde73d9 Michael Niedermayer
    GetBitContext *gb=&vc->gb;
1116
    uint_fast16_t range_v[4]={ 256, 128, 86, 64 };
1117
    uint_fast16_t range=range_v[vf->multiplier-1];
1118
    uint_fast16_t floor1_Y[vf->x_list_dim];
1119
    uint_fast16_t floor1_Y_final[vf->x_list_dim];
1120
    uint_fast8_t floor1_flag[vf->x_list_dim];
1121
    uint_fast8_t class_;
1122
    uint_fast8_t cdim;
1123
    uint_fast8_t cbits;
1124
    uint_fast8_t csub;
1125
    uint_fast8_t cval;
1126
    int_fast16_t book;
1127
    uint_fast16_t offset;
1128
    uint_fast16_t i,j;
1129
    uint_fast16_t *floor_x_sort=vf->x_list_order;
1130
    /*u*/int_fast16_t adx, ady, off, predicted; // WTF ? dy/adx= (unsigned)dy/adx ?
1131
    int_fast16_t dy, err;
1132
    uint_fast16_t lx,hx, ly, hy=0;
1133
1134
1135
    if (!get_bits1(gb)) return 1; // silence
1136
1137
// Read values (or differences) for the floor's points
1138
1139
    floor1_Y[0]=get_bits(gb, ilog(range-1));
1140
    floor1_Y[1]=get_bits(gb, ilog(range-1));
1141
1142
    AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1143
1144
    offset=2;
1145
    for(i=0;i<vf->partitions;++i) {
1146
        class_=vf->partition_class[i];
1147
        cdim=vf->class_dimensions[class_];
1148
        cbits=vf->class_subclasses[class_];
1149
        csub=(1<<cbits)-1;
1150
        cval=0;
1151
1152
        AV_DEBUG("Cbits %d \n", cbits);
1153
1154
        if (cbits) { // this reads all subclasses for this partition's class
1155
            cval=get_vlc2(gb, vc->codebooks[vf->class_masterbook[class_]].vlc.table,
1156 5a408f91 Michael Niedermayer
            vc->codebooks[vf->class_masterbook[class_]].nb_bits, 3);
1157 0bde73d9 Michael Niedermayer
        }
1158
1159
        for(j=0;j<cdim;++j) {
1160
            book=vf->subclass_books[class_][cval & csub];
1161
1162
            AV_DEBUG("book %d Cbits %d cval %d  bits:%d \n", book, cbits, cval, get_bits_count(gb));
1163
1164
            cval=cval>>cbits;
1165
            if (book>0) {
1166
                floor1_Y[offset+j]=get_vlc2(gb, vc->codebooks[book].vlc.table,
1167 5a408f91 Michael Niedermayer
                vc->codebooks[book].nb_bits, 3);
1168 0bde73d9 Michael Niedermayer
            } else {
1169
                floor1_Y[offset+j]=0;
1170
            }
1171
1172
            AV_DEBUG(" floor(%d) = %d \n", vf->x_list[offset+j], floor1_Y[offset+j]);
1173
        }
1174
        offset+=cdim;
1175
    }
1176
1177
// Amplitude calculation from the differences
1178
1179
    floor1_flag[0]=1;
1180
    floor1_flag[1]=1;
1181
    floor1_Y_final[0]=floor1_Y[0];
1182
    floor1_Y_final[1]=floor1_Y[1];
1183
1184
    for(i=2;i<vf->x_list_dim;++i) {
1185
        uint_fast16_t val, highroom, lowroom, room;
1186
        uint_fast16_t high_neigh_offs;
1187
        uint_fast16_t low_neigh_offs;
1188
1189
        low_neigh_offs=vf->low_neighbour[i];
1190
        high_neigh_offs=vf->high_neighbour[i];
1191
        dy=floor1_Y_final[high_neigh_offs]-floor1_Y_final[low_neigh_offs];  // render_point begin
1192
        adx=vf->x_list[high_neigh_offs]-vf->x_list[low_neigh_offs];
1193
        ady= ABS(dy);
1194
        err=ady*(vf->x_list[i]-vf->x_list[low_neigh_offs]);
1195
        off=err/adx;
1196
        if (dy<0) {
1197
            predicted=floor1_Y_final[low_neigh_offs]-off;
1198
        } else {
1199
            predicted=floor1_Y_final[low_neigh_offs]+off;
1200
        } // render_point end
1201
1202
        val=floor1_Y[i];
1203
        highroom=range-predicted;
1204
        lowroom=predicted;
1205
        if (highroom < lowroom) {
1206
            room=highroom*2;
1207
        } else {
1208
            room=lowroom*2;   // SPEC mispelling
1209
        }
1210
        if (val) {
1211
            floor1_flag[low_neigh_offs]=1;
1212
            floor1_flag[high_neigh_offs]=1;
1213
            floor1_flag[i]=1;
1214
            if (val>=room) {
1215
                if (highroom > lowroom) {
1216
                    floor1_Y_final[i]=val-lowroom+predicted;
1217
                } else {
1218
                    floor1_Y_final[i]=predicted-val+highroom-1;
1219
                }
1220
            } else {
1221
                if (val & 1) {
1222
                    floor1_Y_final[i]=predicted-(val+1)/2;
1223
                } else {
1224
                    floor1_Y_final[i]=predicted+val/2;
1225
                }
1226
            }
1227
        } else {
1228
            floor1_flag[i]=0;
1229
            floor1_Y_final[i]=predicted;
1230
        }
1231
1232
        AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf->x_list[i], floor1_Y_final[i], val);
1233
    }
1234
1235
// Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1236
1237
    hx=0;
1238
    lx=0;
1239
    ly=floor1_Y_final[0]*vf->multiplier;  // conforms to SPEC
1240
1241
    vec[0]=floor1_inverse_db_table[ly];
1242
1243
    for(i=1;i<vf->x_list_dim;++i) {
1244
        AV_DEBUG(" Looking at post %d \n", i);
1245
1246
        if (floor1_flag[floor_x_sort[i]]) {   // SPEC mispelled
1247
            int_fast16_t x, y, dy, base, sy; // if uncommented: dy = -32 adx = 2  base = 2blablabla ?????
1248
1249
            hy=floor1_Y_final[floor_x_sort[i]]*vf->multiplier;
1250
            hx=vf->x_list[floor_x_sort[i]];
1251
1252
            dy=hy-ly;
1253
            adx=hx-lx;
1254
            ady= (dy<0) ? -dy:dy;//ABS(dy);
1255
            base=dy/adx;
1256
1257
            AV_DEBUG(" dy %d  adx %d base %d = %d \n", dy, adx, base, dy/adx);
1258
1259
            x=lx;
1260
            y=ly;
1261
            err=0;
1262
            if (dy<0) {
1263
                sy=base-1;
1264
            } else {
1265
                sy=base+1;
1266
            }
1267
            ady=ady-(base<0 ? -base : base)*adx;
1268
            vec[x]=floor1_inverse_db_table[y];
1269
1270
            AV_DEBUG(" vec[ %d ] = %d \n", x, y);
1271
1272
            for(x=lx+1;(x<hx) && (x<vf->x_list[1]);++x) {
1273
                err+=ady;
1274
                if (err>=adx) {
1275
                    err-=adx;
1276
                    y+=sy;
1277
                } else {
1278
                    y+=base;
1279
                }
1280
                vec[x]=floor1_inverse_db_table[y];
1281
1282
                AV_DEBUG(" vec[ %d ] = %d \n", x, y);
1283
            }
1284
1285
/*            for(j=1;j<hx-lx+1;++j) {  // iterating render_point
1286
                dy=hy-ly;
1287
                adx=hx-lx;
1288
                ady= dy<0 ? -dy : dy;
1289
                err=ady*j;
1290
                off=err/adx;
1291
                if (dy<0) {
1292
                    predicted=ly-off;
1293
                } else {
1294
                    predicted=ly+off;
1295
                }
1296
                if (lx+j < vf->x_list[1]) {
1297
                    vec[lx+j]=floor1_inverse_db_table[predicted];
1298
                }
1299
            }*/
1300
1301
            lx=hx;
1302
            ly=hy;
1303
        }
1304
    }
1305
1306
    if (hx<vf->x_list[1]) {
1307
        for(i=hx;i<vf->x_list[1];++i) {
1308
            vec[i]=floor1_inverse_db_table[hy];
1309
        }
1310
    }
1311
1312
    AV_DEBUG(" Floor decoded\n");
1313
1314
    return 0;
1315
}
1316
1317
// Read and decode residue
1318
1319
static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, uint_fast8_t ch, uint_fast8_t *do_not_decode, float *vec, uint_fast16_t vlen) {
1320
    GetBitContext *gb=&vc->gb;
1321
    uint_fast8_t c_p_c=vc->codebooks[vr->classbook].dimensions;
1322
    uint_fast16_t n_to_read=vr->end-vr->begin;
1323
    uint_fast16_t ptns_to_read=n_to_read/vr->partition_size;
1324 d381c505 Måns Rullgård
    uint_fast8_t classifs[ptns_to_read*vc->audio_channels];
1325 0bde73d9 Michael Niedermayer
    uint_fast8_t pass;
1326
    uint_fast8_t ch_used;
1327
    uint_fast8_t i,j,l;
1328
    uint_fast16_t k;
1329
1330
    if (vr->type==2) {
1331
        for(j=1;j<ch;++j) {
1332
                do_not_decode[0]&=do_not_decode[j];  // FIXME - clobbering input
1333
        }
1334
        if (do_not_decode[0]) return 0;
1335
        ch_used=1;
1336
    } else {
1337
        ch_used=ch;
1338
    }
1339
1340
    AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
1341
1342
    for(pass=0;pass<=vr->maxpass;++pass) { // FIXME OPTIMIZE?
1343
        uint_fast16_t voffset;
1344
        uint_fast16_t partition_count;
1345
        uint_fast16_t j_times_ptns_to_read;
1346
1347
        voffset=vr->begin;
1348
        for(partition_count=0;partition_count<ptns_to_read;) {  // SPEC        error
1349
            if (!pass) {
1350
                for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) {
1351
                    if (!do_not_decode[j]) {
1352
                        uint_fast32_t temp=get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table,
1353 5a408f91 Michael Niedermayer
                        vc->codebooks[vr->classbook].nb_bits, 3);
1354 0bde73d9 Michael Niedermayer
1355
                        AV_DEBUG("Classword: %d \n", temp);
1356
1357 1bd86246 Måns Rullgård
                        assert(vr->classifications > 1 && temp<=65536); //needed for inverse[]
1358 0bde73d9 Michael Niedermayer
                        for(i=0;i<c_p_c;++i) {
1359
                            uint_fast32_t temp2;
1360
1361 f4e61cd1 Michael Niedermayer
                            temp2=(((uint_fast64_t)temp) * inverse[vr->classifications])>>32;
1362 8d39d67a Denes Balatoni
                            if (partition_count+c_p_c-1-i < ptns_to_read) {
1363
                                classifs[j_times_ptns_to_read+partition_count+c_p_c-1-i]=temp-temp2*vr->classifications;
1364
                            }
1365 0bde73d9 Michael Niedermayer
                            temp=temp2;
1366
                        }
1367
                    }
1368
                    j_times_ptns_to_read+=ptns_to_read;
1369
                }
1370
            }
1371
            for(i=0;(i<c_p_c) && (partition_count<ptns_to_read);++i) {
1372
                for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) {
1373
                    uint_fast16_t voffs;
1374
1375
                    if (!do_not_decode[j]) {
1376
                        uint_fast8_t vqclass=classifs[j_times_ptns_to_read+partition_count];
1377
                        int_fast16_t vqbook=vr->books[vqclass][pass];
1378
1379
                        if (vqbook>=0) {
1380
                            uint_fast16_t coffs;
1381 f4e61cd1 Michael Niedermayer
                            uint_fast16_t step=vr->partition_size/vc->codebooks[vqbook].dimensions;
1382
                            vorbis_codebook codebook= vc->codebooks[vqbook];
1383 0bde73d9 Michael Niedermayer
1384
                            if (vr->type==0) {
1385
1386
                                voffs=voffset+j*vlen;
1387
                                for(k=0;k<step;++k) {
1388 5a408f91 Michael Niedermayer
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1389 f4e61cd1 Michael Niedermayer
                                    for(l=0;l<codebook.dimensions;++l) {
1390
                                        vec[voffs+k+l*step]+=codebook.codevectors[coffs+l];  // FPMATH
1391 0bde73d9 Michael Niedermayer
                                    }
1392
                                }
1393
                            }
1394
                            else if (vr->type==1) {
1395
                                voffs=voffset+j*vlen;
1396 f4e61cd1 Michael Niedermayer
                                for(k=0;k<step;++k) {
1397 5a408f91 Michael Niedermayer
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1398 f4e61cd1 Michael Niedermayer
                                    for(l=0;l<codebook.dimensions;++l, ++voffs) {
1399
                                        vec[voffs]+=codebook.codevectors[coffs+l];  // FPMATH
1400 0bde73d9 Michael Niedermayer
1401 f4e61cd1 Michael Niedermayer
                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d  \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1402 0bde73d9 Michael Niedermayer
                                    }
1403
                                }
1404
                            }
1405 f4e61cd1 Michael Niedermayer
                            else if (vr->type==2 && ch==2 && (voffset&1)==0 && (codebook.dimensions&1)==0) { // most frequent case optimized
1406
                                voffs=voffset>>1;
1407 0bde73d9 Michael Niedermayer
1408 f4e61cd1 Michael Niedermayer
                                for(k=0;k<step;++k) {
1409 5a408f91 Michael Niedermayer
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1410 f4e61cd1 Michael Niedermayer
                                    for(l=0;l<codebook.dimensions;l+=2, voffs++) {
1411
                                        vec[voffs     ]+=codebook.codevectors[coffs+l  ];  // FPMATH
1412
                                        vec[voffs+vlen]+=codebook.codevectors[coffs+l+1];  // FPMATH
1413 0bde73d9 Michael Niedermayer
1414 f4e61cd1 Michael Niedermayer
                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n", pass, voffset/ch+(voffs%ch)*vlen, vec[voffset/ch+(voffs%ch)*vlen], codebook.codevectors[coffs+l], coffs, l);
1415 0bde73d9 Michael Niedermayer
                                    }
1416
                                }
1417
1418
                            }
1419
                            else if (vr->type==2) {
1420
                                voffs=voffset;
1421
1422 f4e61cd1 Michael Niedermayer
                                for(k=0;k<step;++k) {
1423 5a408f91 Michael Niedermayer
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1424 f4e61cd1 Michael Niedermayer
                                    for(l=0;l<codebook.dimensions;++l, ++voffs) {
1425
                                        vec[voffs/ch+(voffs%ch)*vlen]+=codebook.codevectors[coffs+l];  // FPMATH FIXME use if and counter instead of / and %
1426 0bde73d9 Michael Niedermayer
1427 f4e61cd1 Michael Niedermayer
                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n", pass, voffset/ch+(voffs%ch)*vlen, vec[voffset/ch+(voffs%ch)*vlen], codebook.codevectors[coffs+l], coffs, l);
1428 0bde73d9 Michael Niedermayer
                                    }
1429
                                }
1430
                            } else {
1431
                                av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1432
                                return 1;
1433
                            }
1434
                        }
1435
                    }
1436 d381c505 Måns Rullgård
                    j_times_ptns_to_read+=ptns_to_read;
1437 0bde73d9 Michael Niedermayer
                }
1438
                ++partition_count;
1439
                voffset+=vr->partition_size;
1440
            }
1441
        }
1442
    }
1443
    return 0;
1444
}
1445
1446
// Decode the audio packet using the functions above
1447 de312e51 Michael Niedermayer
#define BIAS 385
1448 0bde73d9 Michael Niedermayer
1449
static int vorbis_parse_audio_packet(vorbis_context *vc) {
1450
    GetBitContext *gb=&vc->gb;
1451
1452
    uint_fast8_t previous_window=0,next_window=0;
1453
    uint_fast8_t mode_number;
1454
    uint_fast16_t blocksize;
1455
    int_fast32_t i,j;
1456
    uint_fast8_t no_residue[vc->audio_channels];
1457
    uint_fast8_t do_not_decode[vc->audio_channels];
1458
    vorbis_mapping *mapping;
1459
    float *ch_res_ptr=vc->channel_residues;
1460
    float *ch_floor_ptr=vc->channel_floors;
1461
    uint_fast8_t res_chan[vc->audio_channels];
1462
    uint_fast8_t res_num=0;
1463
    int_fast16_t retlen=0;
1464
    uint_fast16_t saved_start=0;
1465
1466
    if (get_bits1(gb)) {
1467
        av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1468
        return -1; // packet type not audio
1469
    }
1470
1471 84a96d6a Denes Balatoni
    if (vc->mode_count==1) {
1472
        mode_number=0;
1473
    } else {
1474
        mode_number=get_bits(gb, ilog(vc->mode_count-1));
1475
    }
1476 04c669ba Alexander Strasser
    vc->mode_number=mode_number;
1477 0bde73d9 Michael Niedermayer
    mapping=&vc->mappings[vc->modes[mode_number].mapping];
1478
1479
    AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number, vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1480
1481
    if (vc->modes[mode_number].blockflag) {
1482
        previous_window=get_bits1(gb);
1483
        next_window=get_bits1(gb);
1484
    }
1485
1486
    blocksize=vc->modes[mode_number].blockflag ? vc->blocksize_1 : vc->blocksize_0;
1487
    memset(ch_res_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ?
1488
    memset(ch_floor_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ?
1489
1490 43eb5908 Alexander Strasser
// Decode floor
1491 0bde73d9 Michael Niedermayer
1492
    for(i=0;i<vc->audio_channels;++i) {
1493
        vorbis_floor *floor;
1494
        if (mapping->submaps>1) {
1495
            floor=&vc->floors[mapping->submap_floor[mapping->mux[i]]];
1496
        } else {
1497
            floor=&vc->floors[mapping->submap_floor[0]];
1498
        }
1499
1500 43eb5908 Alexander Strasser
        no_residue[i]=floor->decode(vc, &floor->data, ch_floor_ptr);
1501 0bde73d9 Michael Niedermayer
        ch_floor_ptr+=blocksize/2;
1502
    }
1503
1504
// Nonzero vector propagate
1505
1506
    for(i=mapping->coupling_steps-1;i>=0;--i) {
1507
        if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1508
            no_residue[mapping->magnitude[i]]=0;
1509
            no_residue[mapping->angle[i]]=0;
1510
        }
1511
    }
1512
1513
// Decode residue
1514
1515
    for(i=0;i<mapping->submaps;++i) {
1516
        vorbis_residue *residue;
1517
        uint_fast8_t ch=0;
1518
1519
        for(j=0;j<vc->audio_channels;++j) {
1520
            if ((mapping->submaps==1) || (i=mapping->mux[j])) {
1521
                res_chan[j]=res_num;
1522
                if (no_residue[j]) {
1523
                    do_not_decode[ch]=1;
1524
                } else {
1525
                    do_not_decode[ch]=0;
1526
                }
1527
                ++ch;
1528
                ++res_num;
1529
            }
1530
        }
1531
        residue=&vc->residues[mapping->submap_residue[i]];
1532
        vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, blocksize/2);
1533
1534
        ch_res_ptr+=ch*blocksize/2;
1535
    }
1536
1537
// Inverse coupling
1538
1539
    for(i=mapping->coupling_steps-1;i>=0;--i) { //warning: i has to be signed
1540
        float *mag, *ang;
1541
1542
        mag=vc->channel_residues+res_chan[mapping->magnitude[i]]*blocksize/2;
1543
        ang=vc->channel_residues+res_chan[mapping->angle[i]]*blocksize/2;
1544
        for(j=0;j<blocksize/2;++j) {
1545
            float temp;
1546
            if (mag[j]>0.0) {
1547
                if (ang[j]>0.0) {
1548
                    ang[j]=mag[j]-ang[j];
1549
                } else {
1550
                    temp=ang[j];
1551
                    ang[j]=mag[j];
1552
                    mag[j]+=temp;
1553
                }
1554
            } else {
1555
                if (ang[j]>0.0) {
1556
                    ang[j]+=mag[j];
1557
                } else {
1558
                    temp=ang[j];
1559
                    ang[j]=mag[j];
1560
                    mag[j]-=temp;
1561
                }
1562
            }
1563
        }
1564
    }
1565
1566
// Dotproduct
1567
1568
    for(j=0, ch_floor_ptr=vc->channel_floors;j<vc->audio_channels;++j,ch_floor_ptr+=blocksize/2) {
1569
        ch_res_ptr=vc->channel_residues+res_chan[j]*blocksize/2;
1570
1571
        for(i=0;i<blocksize/2;++i) {
1572
            ch_floor_ptr[i]*=ch_res_ptr[i]; //FPMATH
1573
        }
1574
    }
1575
1576
// MDCT, overlap/add, save data for next overlapping  FPMATH
1577
1578
    for(j=0;j<vc->audio_channels;++j) {
1579
        uint_fast8_t step=vc->audio_channels;
1580
        uint_fast16_t k;
1581
        float *saved=vc->saved+j*vc->blocksize_1/2;
1582
        float *ret=vc->ret;
1583
        const float *lwin=vc->lwin;
1584
        const float *swin=vc->swin;
1585 13c2469d Michael Niedermayer
        float *buf=vc->buf;
1586
        float *buf_tmp=vc->buf_tmp;
1587 0bde73d9 Michael Niedermayer
1588
        ch_floor_ptr=vc->channel_floors+j*blocksize/2;
1589
1590
        saved_start=vc->saved_start;
1591
1592
        ff_imdct_calc(vc->modes[mode_number].blockflag ? &vc->mdct1 : &vc->mdct0, buf, ch_floor_ptr, buf_tmp);
1593
1594
        if (vc->modes[mode_number].blockflag) {
1595
            // -- overlap/add
1596
            if (previous_window) {
1597
                for(k=j, i=0;i<vc->blocksize_1/2;++i, k+=step) {
1598 f56f96d8 Michael Niedermayer
                    ret[k]=saved[i]+buf[i]*lwin[i]+BIAS;
1599 0bde73d9 Michael Niedermayer
                }
1600
                retlen=vc->blocksize_1/2;
1601
            } else {
1602 de312e51 Michael Niedermayer
                buf += (vc->blocksize_1-vc->blocksize_0)/4;
1603 0bde73d9 Michael Niedermayer
                for(k=j, i=0;i<vc->blocksize_0/2;++i, k+=step) {
1604 de312e51 Michael Niedermayer
                    ret[k]=saved[i]+buf[i]*swin[i]+BIAS;
1605 0bde73d9 Michael Niedermayer
                }
1606 de312e51 Michael Niedermayer
                buf += vc->blocksize_0/2;
1607 0bde73d9 Michael Niedermayer
                for(i=0;i<(vc->blocksize_1-vc->blocksize_0)/4;++i, k+=step) {
1608 de312e51 Michael Niedermayer
                    ret[k]=buf[i]+BIAS;
1609 0bde73d9 Michael Niedermayer
                }
1610 de312e51 Michael Niedermayer
                buf=vc->buf;
1611 0bde73d9 Michael Niedermayer
                retlen=vc->blocksize_0/2+(vc->blocksize_1-vc->blocksize_0)/4;
1612
            }
1613
            // -- save
1614
            if (next_window) {
1615 de312e51 Michael Niedermayer
                buf += vc->blocksize_1/2;
1616
                lwin += vc->blocksize_1/2-1;
1617 0bde73d9 Michael Niedermayer
                for(i=0;i<vc->blocksize_1/2;++i) {
1618 de312e51 Michael Niedermayer
                    saved[i]=buf[i]*lwin[-i];
1619 0bde73d9 Michael Niedermayer
                }
1620
                saved_start=0;
1621
            } else {
1622
                saved_start=(vc->blocksize_1-vc->blocksize_0)/4;
1623 de312e51 Michael Niedermayer
                buf += vc->blocksize_1/2;
1624 0bde73d9 Michael Niedermayer
                for(i=0;i<saved_start;++i) {
1625 de312e51 Michael Niedermayer
                    saved[i]=buf[i];
1626 0bde73d9 Michael Niedermayer
                }
1627 de312e51 Michael Niedermayer
                swin += vc->blocksize_0/2-1;
1628 0bde73d9 Michael Niedermayer
                for(i=0;i<vc->blocksize_0/2;++i) {
1629 de312e51 Michael Niedermayer
                    saved[saved_start+i]=buf[saved_start+i]*swin[-i];
1630 0bde73d9 Michael Niedermayer
                }
1631
            }
1632
        } else {
1633
            // --overlap/add
1634
            for(k=j, i=0;i<saved_start;++i, k+=step) {
1635 f56f96d8 Michael Niedermayer
                ret[k]=saved[i]+BIAS;
1636 0bde73d9 Michael Niedermayer
            }
1637
            for(i=0;i<vc->blocksize_0/2;++i, k+=step) {
1638 f56f96d8 Michael Niedermayer
                ret[k]=saved[saved_start+i]+buf[i]*swin[i]+BIAS;
1639 0bde73d9 Michael Niedermayer
            }
1640
            retlen=saved_start+vc->blocksize_0/2;
1641
            // -- save
1642 de312e51 Michael Niedermayer
            buf += vc->blocksize_0/2;
1643
            swin += vc->blocksize_0/2-1;
1644 0bde73d9 Michael Niedermayer
            for(i=0;i<vc->blocksize_0/2;++i) {
1645 de312e51 Michael Niedermayer
                saved[i]=buf[i]*swin[-i];
1646 0bde73d9 Michael Niedermayer
            }
1647
            saved_start=0;
1648
        }
1649
    }
1650
    vc->saved_start=saved_start;
1651
1652
    return retlen*vc->audio_channels;
1653
}
1654
1655
// Return the decoded audio packet through the standard api
1656
1657
static int vorbis_decode_frame(AVCodecContext *avccontext,
1658
                        void *data, int *data_size,
1659
                        uint8_t *buf, int buf_size)
1660
{
1661
    vorbis_context *vc = avccontext->priv_data ;
1662
    GetBitContext *gb = &(vc->gb);
1663
1664
    int_fast16_t i, len;
1665
1666
    if(!buf_size){
1667
        return 0;
1668
    }
1669
1670
    AV_DEBUG("packet length %d \n", buf_size);
1671
1672
    init_get_bits(gb, buf, buf_size*8);
1673
1674
    len=vorbis_parse_audio_packet(vc);
1675
1676
    if (len<=0) {
1677
        *data_size=0;
1678
        return buf_size;
1679
    }
1680
1681
    if (!vc->first_frame) {
1682
        vc->first_frame=1;
1683
        *data_size=0;
1684
        return buf_size ;
1685
    }
1686
1687
    AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len);
1688
1689
    for(i=0;i<len;++i) {
1690 f56f96d8 Michael Niedermayer
        int_fast32_t tmp= ((int32_t*)vc->ret)[i];
1691 de312e51 Michael Niedermayer
        if(tmp & 0xf0000){
1692
//            tmp= (0x43c0ffff - tmp)>>31; //ask gcc devs why this is slower
1693
            if(tmp > 0x43c0ffff) tmp= 0xFFFF;
1694
            else                 tmp= 0;
1695
        }
1696
        ((int16_t*)data)[i]=tmp - 0x8000;
1697 0bde73d9 Michael Niedermayer
    }
1698 f56f96d8 Michael Niedermayer
1699 0bde73d9 Michael Niedermayer
    *data_size=len*2;
1700
1701
    return buf_size ;
1702
}
1703
1704
// Close decoder
1705
1706
static int vorbis_decode_close(AVCodecContext *avccontext) {
1707
    vorbis_context *vc = avccontext->priv_data;
1708
1709
    vorbis_free(vc);
1710
1711
    return 0 ;
1712
}
1713
1714
AVCodec vorbis_decoder = {
1715
    "vorbis",
1716
    CODEC_TYPE_AUDIO,
1717
    CODEC_ID_VORBIS,
1718
    sizeof(vorbis_context),
1719
    vorbis_decode_init,
1720
    NULL,
1721
    vorbis_decode_close,
1722
    vorbis_decode_frame,
1723
};