Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vorbis.c @ bcfa3e58

History | View | Annotate | Download (60.3 KB)

1
/**
2
 * @file vorbis.c
3
 * Vorbis I decoder
4
 * @author Denes Balatoni  ( dbalatoni programozo hu )
5

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
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 *
20
 */
21

    
22
#undef V_DEBUG
23
//#define V_DEBUG
24
//#define AV_DEBUG(...) av_log(NULL, AV_LOG_INFO, __VA_ARGS__)
25

    
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
#define V_NB_BITS 8
36
#define V_NB_BITS2 11
37
#define V_MAX_VLCS (1<<16)
38

    
39
#ifndef V_DEBUG
40
#define AV_DEBUG(...)
41
#endif
42

    
43
#undef NDEBUG
44
#include <assert.h>
45

    
46
/* Helper functions */
47

    
48
/**
49
 *  reads 0-32 bits when using the ALT_BITSTREAM_READER_LE bitstream reader
50
 */
51
static unsigned int get_bits_long_le(GetBitContext *s, int n){
52
    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
#define ilog(i) av_log2(2*(i))
60

    
61
#define BARK(x) \
62
    (13.1f*atan(0.00074f*(x))+2.24f*atan(1.85e-8f*(x)*(x))+1e-4f*(x))
63

    
64
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
    av_freep(&vc->buf);
159
    av_freep(&vc->buf_tmp);
160

    
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
        if(vc->floors[i].floor_type==0) {
175
            av_free(vc->floors[i].data.t0.map[0]);
176
            av_free(vc->floors[i].data.t0.map[1]);
177
            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
    }
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
    uint_fast8_t *tmp_vlc_bits;
204
    uint_fast32_t *tmp_vlc_codes;
205
    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
    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

    
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
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook setup data corrupt. \n", cb);
225
            goto error;
226
        }
227

    
228
        codebook_setup->dimensions=get_bits(gb, 16);
229
        if (codebook_setup->dimensions>16) {
230
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook's dimension is too large (%d). \n", cb, codebook_setup->dimensions);
231
            goto error;
232
        }
233
        entries=get_bits(gb, 24);
234
        if (entries>V_MAX_VLCS) {
235
            av_log(vc->avccontext, AV_LOG_ERROR, " %"PRIdFAST16". Codebook has too many entries (%"PRIdFAST32"). \n", cb, entries);
236
            goto error;
237
        }
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
                goto error;
295
            }
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
                goto error;
361
            }
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
            goto error;
367
        }
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
            goto error;
373
        }
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
        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

    
381
        codebook_setup->maxdepth=(codebook_setup->maxdepth+codebook_setup->nb_bits-1)/codebook_setup->nb_bits;
382

    
383
        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
            av_log(vc->avccontext, AV_LOG_ERROR, " Error generating vlc tables. \n");
385
            goto error;
386
        }
387
    }
388

    
389
    av_free(tmp_vlc_bits);
390
    av_free(tmp_vlc_codes);
391
    return 0;
392

    
393
// Error:
394
error:
395
    av_free(tmp_vlc_bits);
396
    av_free(tmp_vlc_codes);
397
    return 1;
398
}
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
// Process floors part
421

    
422
static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
423
                                         vorbis_floor_data *vfu, float *vec);
424
static void create_map( vorbis_context * vc, uint_fast8_t floor_number );
425
static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc,
426
                                         vorbis_floor_data *vfu, float *vec);
427
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
            floor_setup->decode=vorbis_floor1_decode;
448

    
449
            floor_setup->data.t1.partitions=get_bits(gb, 5);
450

    
451
            AV_DEBUG(" %d.floor: %d partitions \n", i, floor_setup->data.t1.partitions);
452

    
453
            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

    
457
                AV_DEBUG(" %d. floor %d partition class %d \n", i, j, floor_setup->data.t1.partition_class[j]);
458

    
459
            }
460

    
461
            AV_DEBUG(" maximum class %d \n", maximum_class);
462

    
463
            floor_setup->data.t1.maximum_class=maximum_class;
464

    
465
            for(j=0;j<=maximum_class;++j) {
466
                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

    
469
                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

    
471
                if (floor_setup->data.t1.class_subclasses[j]) {
472
                    floor_setup->data.t1.class_masterbook[j]=get_bits(gb, 8);
473

    
474
                    AV_DEBUG("   masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
475
                }
476

    
477
                for(k=0;k<(1<<floor_setup->data.t1.class_subclasses[j]);++k) {
478
                    floor_setup->data.t1.subclass_books[j][k]=(int16_t)get_bits(gb, 8)-1;
479

    
480
                    AV_DEBUG("    book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
481
                }
482
            }
483

    
484
            floor_setup->data.t1.multiplier=get_bits(gb, 2)+1;
485
            floor_setup->data.t1.x_list_dim=2;
486

    
487
            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
            }
490

    
491
            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

    
496

    
497
            rangebits=get_bits(gb, 4);
498
            floor_setup->data.t1.x_list[0] = 0;
499
            floor_setup->data.t1.x_list[1] = (1<<rangebits);
500

    
501
            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

    
505
                    AV_DEBUG(" %d. floor1 Y coord. %d \n", floor1_values, floor_setup->data.t1.x_list[floor1_values]);
506
                }
507
            }
508

    
509
// Precalculate order of x coordinates - needed for decode
510

    
511
            for(k=0;k<floor_setup->data.t1.x_list_dim;++k) {
512
                floor_setup->data.t1.x_list_order[k]=k;
513
            }
514

    
515
            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
                    }
522
                }
523
            }
524

    
525
// Precalculate low and high neighbours
526

    
527
            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

    
531
                for (j=0;j<k;++j) {
532
                    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
                    }
536
                    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
                    }
540
                }
541
            }
542
        }
543
        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
            /* 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
            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
            create_map( vc, i );
582

    
583
            /* 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
                if(!floor_setup->data.t0.lsp) { return 1; }
591
            }
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
        else {
617
            av_log(vc->avccontext, AV_LOG_ERROR, "Invalid floor type!\n");
618
            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
static void create_map( vorbis_context * vc, uint_fast8_t floor_number )
750
{
751
    vorbis_floor * floors=vc->floors;
752
    vorbis_floor0 * vf;
753
    int idx;
754
    int_fast8_t blockflag;
755
    int_fast32_t * map;
756
    int_fast32_t n; //TODO: could theoretically be smaller?
757

    
758
    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
        av_malloc((n+1) * sizeof(int_fast32_t)); // n+sentinel
763

    
764
    map=floors[floor_number].data.t0.map[blockflag];
765
    vf=&floors[floor_number].data.t0;
766

    
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
    vf->map_size[blockflag]=n;
777
    }
778

    
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
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
    if (bl0>13 || bl0<6 || bl1>13 || bl1<6 || bl1<bl0) {
878
        av_log(vc->avccontext, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
879
        return 3;
880
    }
881
    // 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
    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
    vc->buf=(float *)av_malloc(vc->blocksize_1 * sizeof(float));
901
    vc->buf_tmp=(float *)av_malloc(vc->blocksize_1 * sizeof(float));
902
    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
    uint8_t *header_start[3];
927
    int header_len[3];
928
    GetBitContext *gb = &(vc->gb);
929
    int i, j, hdr_type;
930

    
931
    vc->avccontext = avccontext;
932
    dsputil_init(&vc->dsp, avccontext);
933

    
934
    if (!headers_len) {
935
        av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
936
        return -1;
937
    }
938

    
939
    if(headers[0] == 0 && headers[1] == 30) {
940
        for(i = 0; i < 3; i++){
941
            header_len[i] = *headers++ << 8;
942
            header_len[i] += *headers++;
943
            header_start[i] = headers;
944
            headers += header_len[i];
945
        }
946
    } else if(headers[0] == 2) {
947
        for(j=1,i=0;i<2;++i, ++j) {
948
            header_len[i]=0;
949
            while(j<headers_len && headers[j]==0xff) {
950
                header_len[i]+=0xff;
951
                ++j;
952
            }
953
            if (j>=headers_len) {
954
                av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
955
                return -1;
956
            }
957
            header_len[i]+=headers[j];
958
        }
959
        header_len[2]=headers_len-header_len[0]-header_len[1]-j;
960
        headers+=j;
961
        header_start[0] = headers;
962
        header_start[1] = header_start[0] + header_len[0];
963
        header_start[2] = header_start[1] + header_len[1];
964
    } else {
965
        av_log(avccontext, AV_LOG_ERROR, "Extradata corrupt.\n");
966
        return -1;
967
    }
968

    
969
    init_get_bits(gb, header_start[0], header_len[0]*8);
970
    hdr_type=get_bits(gb, 8);
971
    if (hdr_type!=1) {
972
        av_log(avccontext, AV_LOG_ERROR, "First header is not the id header.\n");
973
        return -1;
974
    }
975
    if (vorbis_parse_id_hdr(vc)) {
976
        av_log(avccontext, AV_LOG_ERROR, "Id header corrupt.\n");
977
        vorbis_free(vc);
978
        return -1;
979
    }
980

    
981
    init_get_bits(gb, header_start[2], header_len[2]*8);
982
    hdr_type=get_bits(gb, 8);
983
    if (hdr_type!=5) {
984
        av_log(avccontext, AV_LOG_ERROR, "Third header is not the setup header.\n");
985
        return -1;
986
    }
987
    if (vorbis_parse_setup_hdr(vc)) {
988
        av_log(avccontext, AV_LOG_ERROR, "Setup header corrupt.\n");
989
        vorbis_free(vc);
990
        return -1;
991
    }
992

    
993
    avccontext->channels = vc->audio_channels;
994
    avccontext->sample_rate = vc->audio_samplerate;
995

    
996
    return 0 ;
997
}
998

    
999
// Decode audiopackets -------------------------------------------------
1000

    
1001
// Read and decode floor
1002

    
1003
static uint_fast8_t vorbis_floor0_decode(vorbis_context *vc,
1004
                                         vorbis_floor_data *vfu, float *vec) {
1005
    vorbis_floor0 * vf=&vfu->t0;
1006
    float * lsp=vf->lsp;
1007
    uint_fast32_t amplitude;
1008
    uint_fast32_t book_idx;
1009
    uint_fast8_t blockflag=vc->modes[vc->mode_number].blockflag;
1010

    
1011
    amplitude=get_bits(&vc->gb, vf->amplitude_bits);
1012
    if (amplitude>0) {
1013
        float last = 0;
1014
        uint_fast16_t lsp_len = 0;
1015
        uint_fast16_t idx;
1016
        vorbis_codebook codebook;
1017

    
1018
        book_idx=get_bits(&vc->gb, ilog(vf->num_books));
1019
        if ( book_idx >= vf->num_books ) {
1020
            av_log( vc->avccontext, AV_LOG_ERROR,
1021
                    "floor0 dec: booknumber too high!\n" );
1022
            //FIXME: look above
1023
        }
1024
        AV_DEBUG( "floor0 dec: booknumber: %u\n", book_idx );
1025
        codebook=vc->codebooks[vf->book_list[book_idx]];
1026

    
1027
        while (lsp_len<vf->order) {
1028
            int vec_off;
1029

    
1030
            AV_DEBUG( "floor0 dec: book dimension: %d\n", codebook.dimensions );
1031
            AV_DEBUG( "floor0 dec: maximum depth: %d\n", codebook.maxdepth );
1032
            /* read temp vector */
1033
            vec_off=get_vlc2(&vc->gb,
1034
                             codebook.vlc.table,
1035
                             codebook.nb_bits,
1036
                             codebook.maxdepth ) *
1037
                             codebook.dimensions;
1038
            AV_DEBUG( "floor0 dec: vector offset: %d\n", vec_off );
1039
            /* copy each vector component and add last to it */
1040
            for (idx=0; idx<codebook.dimensions; ++idx) {
1041
                lsp[lsp_len+idx]=codebook.codevectors[vec_off+idx]+last;
1042
            }
1043
            last=lsp[lsp_len+idx-1]; /* set last to last vector component */
1044

    
1045
            lsp_len += codebook.dimensions;
1046
        }
1047
#ifdef V_DEBUG
1048
        /* DEBUG: output lsp coeffs */
1049
        {
1050
            int idx;
1051
            for ( idx = 0; idx < lsp_len; ++idx )
1052
                AV_DEBUG("floor0 dec: coeff at %d is %f\n", idx, lsp[idx] );
1053
        }
1054
#endif
1055

    
1056
        /* synthesize floor output vector */
1057
        {
1058
            int i;
1059
            int order=vf->order;
1060
            float wstep=M_PI/vf->bark_map_size;
1061

    
1062
            for(i=0;i<order;i++) { lsp[i]=2.0f*cos(lsp[i]); }
1063

    
1064
            AV_DEBUG("floor0 synth: map_size=%d; m=%d; wstep=%f\n",
1065
                     vf->map_size, order, wstep);
1066

    
1067
            i=0;
1068
            while(i<vf->map_size[blockflag]) {
1069
                int j, iter_cond=vf->map[blockflag][i];
1070
                float p=0.5f;
1071
                float q=0.5f;
1072
                float two_cos_w=2.0f*cos(wstep*iter_cond); // needed all times
1073

    
1074
                /* similar part for the q and p products */
1075
                for(j=0;j<order;j+=2) {
1076
                    q *= lsp[j]  -two_cos_w;
1077
                    p *= lsp[j+1]-two_cos_w;
1078
                }
1079
                if(j==order) { // even order
1080
                    p *= p*(2.0f-two_cos_w);
1081
                    q *= q*(2.0f+two_cos_w);
1082
                }
1083
                else { // odd order
1084
                    q *= two_cos_w-lsp[j]; // one more time for q
1085

    
1086
                    /* final step and square */
1087
                    p *= p*(4.f-two_cos_w*two_cos_w);
1088
                    q *= q;
1089
                }
1090

    
1091
                /* calculate linear floor value */
1092
                {
1093
                    q=exp( (
1094
                             ( (amplitude*vf->amplitude_offset)/
1095
                               (((1<<vf->amplitude_bits)-1) * sqrt(p+q)) )
1096
                             - vf->amplitude_offset ) * .11512925f
1097
                         );
1098
                }
1099

    
1100
                /* fill vector */
1101
                do { vec[i]=q; ++i; }while(vf->map[blockflag][i]==iter_cond);
1102
            }
1103
        }
1104
    }
1105
    else {
1106
        /* this channel is unused */
1107
        return 1;
1108
    }
1109

    
1110
    AV_DEBUG(" Floor0 decoded\n");
1111

    
1112
    return 0;
1113
}
1114
static uint_fast8_t vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec) {
1115
    vorbis_floor1 * vf=&vfu->t1;
1116
    GetBitContext *gb=&vc->gb;
1117
    uint_fast16_t range_v[4]={ 256, 128, 86, 64 };
1118
    uint_fast16_t range=range_v[vf->multiplier-1];
1119
    uint_fast16_t floor1_Y[vf->x_list_dim];
1120
    uint_fast16_t floor1_Y_final[vf->x_list_dim];
1121
    uint_fast8_t floor1_flag[vf->x_list_dim];
1122
    uint_fast8_t class_;
1123
    uint_fast8_t cdim;
1124
    uint_fast8_t cbits;
1125
    uint_fast8_t csub;
1126
    uint_fast8_t cval;
1127
    int_fast16_t book;
1128
    uint_fast16_t offset;
1129
    uint_fast16_t i,j;
1130
    uint_fast16_t *floor_x_sort=vf->x_list_order;
1131
    /*u*/int_fast16_t adx, ady, off, predicted; // WTF ? dy/adx= (unsigned)dy/adx ?
1132
    int_fast16_t dy, err;
1133
    uint_fast16_t lx,hx, ly, hy=0;
1134

    
1135

    
1136
    if (!get_bits1(gb)) return 1; // silence
1137

    
1138
// Read values (or differences) for the floor's points
1139

    
1140
    floor1_Y[0]=get_bits(gb, ilog(range-1));
1141
    floor1_Y[1]=get_bits(gb, ilog(range-1));
1142

    
1143
    AV_DEBUG("floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1144

    
1145
    offset=2;
1146
    for(i=0;i<vf->partitions;++i) {
1147
        class_=vf->partition_class[i];
1148
        cdim=vf->class_dimensions[class_];
1149
        cbits=vf->class_subclasses[class_];
1150
        csub=(1<<cbits)-1;
1151
        cval=0;
1152

    
1153
        AV_DEBUG("Cbits %d \n", cbits);
1154

    
1155
        if (cbits) { // this reads all subclasses for this partition's class
1156
            cval=get_vlc2(gb, vc->codebooks[vf->class_masterbook[class_]].vlc.table,
1157
            vc->codebooks[vf->class_masterbook[class_]].nb_bits, 3);
1158
        }
1159

    
1160
        for(j=0;j<cdim;++j) {
1161
            book=vf->subclass_books[class_][cval & csub];
1162

    
1163
            AV_DEBUG("book %d Cbits %d cval %d  bits:%d \n", book, cbits, cval, get_bits_count(gb));
1164

    
1165
            cval=cval>>cbits;
1166
            if (book>0) {
1167
                floor1_Y[offset+j]=get_vlc2(gb, vc->codebooks[book].vlc.table,
1168
                vc->codebooks[book].nb_bits, 3);
1169
            } else {
1170
                floor1_Y[offset+j]=0;
1171
            }
1172

    
1173
            AV_DEBUG(" floor(%d) = %d \n", vf->x_list[offset+j], floor1_Y[offset+j]);
1174
        }
1175
        offset+=cdim;
1176
    }
1177

    
1178
// Amplitude calculation from the differences
1179

    
1180
    floor1_flag[0]=1;
1181
    floor1_flag[1]=1;
1182
    floor1_Y_final[0]=floor1_Y[0];
1183
    floor1_Y_final[1]=floor1_Y[1];
1184

    
1185
    for(i=2;i<vf->x_list_dim;++i) {
1186
        uint_fast16_t val, highroom, lowroom, room;
1187
        uint_fast16_t high_neigh_offs;
1188
        uint_fast16_t low_neigh_offs;
1189

    
1190
        low_neigh_offs=vf->low_neighbour[i];
1191
        high_neigh_offs=vf->high_neighbour[i];
1192
        dy=floor1_Y_final[high_neigh_offs]-floor1_Y_final[low_neigh_offs];  // render_point begin
1193
        adx=vf->x_list[high_neigh_offs]-vf->x_list[low_neigh_offs];
1194
        ady= ABS(dy);
1195
        err=ady*(vf->x_list[i]-vf->x_list[low_neigh_offs]);
1196
        off=(int16_t)err/(int16_t)adx;
1197
        if (dy<0) {
1198
            predicted=floor1_Y_final[low_neigh_offs]-off;
1199
        } else {
1200
            predicted=floor1_Y_final[low_neigh_offs]+off;
1201
        } // render_point end
1202

    
1203
        val=floor1_Y[i];
1204
        highroom=range-predicted;
1205
        lowroom=predicted;
1206
        if (highroom < lowroom) {
1207
            room=highroom*2;
1208
        } else {
1209
            room=lowroom*2;   // SPEC mispelling
1210
        }
1211
        if (val) {
1212
            floor1_flag[low_neigh_offs]=1;
1213
            floor1_flag[high_neigh_offs]=1;
1214
            floor1_flag[i]=1;
1215
            if (val>=room) {
1216
                if (highroom > lowroom) {
1217
                    floor1_Y_final[i]=val-lowroom+predicted;
1218
                } else {
1219
                    floor1_Y_final[i]=predicted-val+highroom-1;
1220
                }
1221
            } else {
1222
                if (val & 1) {
1223
                    floor1_Y_final[i]=predicted-(val+1)/2;
1224
                } else {
1225
                    floor1_Y_final[i]=predicted+val/2;
1226
                }
1227
            }
1228
        } else {
1229
            floor1_flag[i]=0;
1230
            floor1_Y_final[i]=predicted;
1231
        }
1232

    
1233
        AV_DEBUG(" Decoded floor(%d) = %d / val %d \n", vf->x_list[i], floor1_Y_final[i], val);
1234
    }
1235

    
1236
// Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1237

    
1238
    hx=0;
1239
    lx=0;
1240
    ly=floor1_Y_final[0]*vf->multiplier;  // conforms to SPEC
1241

    
1242
    vec[0]=floor1_inverse_db_table[ly];
1243

    
1244
    for(i=1;i<vf->x_list_dim;++i) {
1245
        AV_DEBUG(" Looking at post %d \n", i);
1246

    
1247
        if (floor1_flag[floor_x_sort[i]]) {   // SPEC mispelled
1248
            int_fast16_t x, y, dy, base, sy; // if uncommented: dy = -32 adx = 2  base = 2blablabla ?????
1249

    
1250
            hy=floor1_Y_final[floor_x_sort[i]]*vf->multiplier;
1251
            hx=vf->x_list[floor_x_sort[i]];
1252

    
1253
            dy=hy-ly;
1254
            adx=hx-lx;
1255
            ady= (dy<0) ? -dy:dy;//ABS(dy);
1256
            base=(int16_t)dy/(int16_t)adx;
1257

    
1258
            AV_DEBUG(" dy %d  adx %d base %d = %d \n", dy, adx, base, dy/adx);
1259

    
1260
            x=lx;
1261
            y=ly;
1262
            err=0;
1263
            if (dy<0) {
1264
                sy=base-1;
1265
            } else {
1266
                sy=base+1;
1267
            }
1268
            ady=ady-(base<0 ? -base : base)*adx;
1269
            vec[x]=floor1_inverse_db_table[y];
1270

    
1271
            AV_DEBUG(" vec[ %d ] = %d \n", x, y);
1272

    
1273
            for(x=lx+1;(x<hx) && (x<vf->x_list[1]);++x) {
1274
                err+=ady;
1275
                if (err>=adx) {
1276
                    err-=adx;
1277
                    y+=sy;
1278
                } else {
1279
                    y+=base;
1280
                }
1281
                vec[x]=floor1_inverse_db_table[y];
1282

    
1283
                AV_DEBUG(" vec[ %d ] = %d \n", x, y);
1284
            }
1285

    
1286
/*            for(j=1;j<hx-lx+1;++j) {  // iterating render_point
1287
                dy=hy-ly;
1288
                adx=hx-lx;
1289
                ady= dy<0 ? -dy : dy;
1290
                err=ady*j;
1291
                off=err/adx;
1292
                if (dy<0) {
1293
                    predicted=ly-off;
1294
                } else {
1295
                    predicted=ly+off;
1296
                }
1297
                if (lx+j < vf->x_list[1]) {
1298
                    vec[lx+j]=floor1_inverse_db_table[predicted];
1299
                }
1300
            }*/
1301

    
1302
            lx=hx;
1303
            ly=hy;
1304
        }
1305
    }
1306

    
1307
    if (hx<vf->x_list[1]) {
1308
        for(i=hx;i<vf->x_list[1];++i) {
1309
            vec[i]=floor1_inverse_db_table[hy];
1310
        }
1311
    }
1312

    
1313
    AV_DEBUG(" Floor decoded\n");
1314

    
1315
    return 0;
1316
}
1317

    
1318
// Read and decode residue
1319

    
1320
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) {
1321
    GetBitContext *gb=&vc->gb;
1322
    uint_fast8_t c_p_c=vc->codebooks[vr->classbook].dimensions;
1323
    uint_fast16_t n_to_read=vr->end-vr->begin;
1324
    uint_fast16_t ptns_to_read=n_to_read/vr->partition_size;
1325
    uint_fast8_t classifs[ptns_to_read*vc->audio_channels];
1326
    uint_fast8_t pass;
1327
    uint_fast8_t ch_used;
1328
    uint_fast8_t i,j,l;
1329
    uint_fast16_t k;
1330

    
1331
    if (vr->type==2) {
1332
        for(j=1;j<ch;++j) {
1333
                do_not_decode[0]&=do_not_decode[j];  // FIXME - clobbering input
1334
        }
1335
        if (do_not_decode[0]) return 0;
1336
        ch_used=1;
1337
    } else {
1338
        ch_used=ch;
1339
    }
1340

    
1341
    AV_DEBUG(" residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
1342

    
1343
    for(pass=0;pass<=vr->maxpass;++pass) { // FIXME OPTIMIZE?
1344
        uint_fast16_t voffset;
1345
        uint_fast16_t partition_count;
1346
        uint_fast16_t j_times_ptns_to_read;
1347

    
1348
        voffset=vr->begin;
1349
        for(partition_count=0;partition_count<ptns_to_read;) {  // SPEC        error
1350
            if (!pass) {
1351
                for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) {
1352
                    if (!do_not_decode[j]) {
1353
                        uint_fast32_t temp=get_vlc2(gb, vc->codebooks[vr->classbook].vlc.table,
1354
                        vc->codebooks[vr->classbook].nb_bits, 3);
1355

    
1356
                        AV_DEBUG("Classword: %d \n", temp);
1357

    
1358
                        assert(vr->classifications > 1 && temp<=65536); //needed for inverse[]
1359
                        for(i=0;i<c_p_c;++i) {
1360
                            uint_fast32_t temp2;
1361

    
1362
                            temp2=(((uint_fast64_t)temp) * inverse[vr->classifications])>>32;
1363
                            if (partition_count+c_p_c-1-i < ptns_to_read) {
1364
                                classifs[j_times_ptns_to_read+partition_count+c_p_c-1-i]=temp-temp2*vr->classifications;
1365
                            }
1366
                            temp=temp2;
1367
                        }
1368
                    }
1369
                    j_times_ptns_to_read+=ptns_to_read;
1370
                }
1371
            }
1372
            for(i=0;(i<c_p_c) && (partition_count<ptns_to_read);++i) {
1373
                for(j_times_ptns_to_read=0, j=0;j<ch_used;++j) {
1374
                    uint_fast16_t voffs;
1375

    
1376
                    if (!do_not_decode[j]) {
1377
                        uint_fast8_t vqclass=classifs[j_times_ptns_to_read+partition_count];
1378
                        int_fast16_t vqbook=vr->books[vqclass][pass];
1379

    
1380
                        if (vqbook>=0) {
1381
                            uint_fast16_t coffs;
1382
                            uint_fast8_t dim= vc->codebooks[vqbook].dimensions;
1383
                            uint_fast16_t step= dim==1 ? vr->partition_size
1384
                                              : FASTDIV(vr->partition_size, dim);
1385
                            vorbis_codebook codebook= vc->codebooks[vqbook];
1386

    
1387
                            if (vr->type==0) {
1388

    
1389
                                voffs=voffset+j*vlen;
1390
                                for(k=0;k<step;++k) {
1391
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1392
                                    for(l=0;l<codebook.dimensions;++l) {
1393
                                        vec[voffs+k+l*step]+=codebook.codevectors[coffs+l];  // FPMATH
1394
                                    }
1395
                                }
1396
                            }
1397
                            else if (vr->type==1) {
1398
                                voffs=voffset+j*vlen;
1399
                                for(k=0;k<step;++k) {
1400
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1401
                                    for(l=0;l<codebook.dimensions;++l, ++voffs) {
1402
                                        vec[voffs]+=codebook.codevectors[coffs+l];  // FPMATH
1403

    
1404
                                        AV_DEBUG(" pass %d offs: %d curr: %f change: %f cv offs.: %d  \n", pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1405
                                    }
1406
                                }
1407
                            }
1408
                            else if (vr->type==2 && ch==2 && (voffset&1)==0 && (codebook.dimensions&1)==0) { // most frequent case optimized
1409
                                voffs=voffset>>1;
1410

    
1411
                                for(k=0;k<step;++k) {
1412
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1413
                                    for(l=0;l<codebook.dimensions;l+=2, voffs++) {
1414
                                        vec[voffs     ]+=codebook.codevectors[coffs+l  ];  // FPMATH
1415
                                        vec[voffs+vlen]+=codebook.codevectors[coffs+l+1];  // FPMATH
1416

    
1417
                                        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);
1418
                                    }
1419
                                }
1420

    
1421
                            }
1422
                            else if (vr->type==2) {
1423
                                voffs=voffset;
1424

    
1425
                                for(k=0;k<step;++k) {
1426
                                    coffs=get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * codebook.dimensions;
1427
                                    for(l=0;l<codebook.dimensions;++l, ++voffs) {
1428
                                        vec[voffs/ch+(voffs%ch)*vlen]+=codebook.codevectors[coffs+l];  // FPMATH FIXME use if and counter instead of / and %
1429

    
1430
                                        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);
1431
                                    }
1432
                                }
1433
                            } else {
1434
                                av_log(vc->avccontext, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1435
                                return 1;
1436
                            }
1437
                        }
1438
                    }
1439
                    j_times_ptns_to_read+=ptns_to_read;
1440
                }
1441
                ++partition_count;
1442
                voffset+=vr->partition_size;
1443
            }
1444
        }
1445
    }
1446
    return 0;
1447
}
1448

    
1449
void vorbis_inverse_coupling(float *mag, float *ang, int blocksize)
1450
{
1451
    int i;
1452
    for(i=0; i<blocksize; i++)
1453
    {
1454
        if (mag[i]>0.0) {
1455
            if (ang[i]>0.0) {
1456
                ang[i]=mag[i]-ang[i];
1457
            } else {
1458
                float temp=ang[i];
1459
                ang[i]=mag[i];
1460
                mag[i]+=temp;
1461
            }
1462
        } else {
1463
            if (ang[i]>0.0) {
1464
                ang[i]+=mag[i];
1465
            } else {
1466
                float temp=ang[i];
1467
                ang[i]=mag[i];
1468
                mag[i]-=temp;
1469
            }
1470
        }
1471
    }
1472
}
1473

    
1474
// Decode the audio packet using the functions above
1475
#define BIAS 385
1476

    
1477
static int vorbis_parse_audio_packet(vorbis_context *vc) {
1478
    GetBitContext *gb=&vc->gb;
1479

    
1480
    uint_fast8_t previous_window=0,next_window=0;
1481
    uint_fast8_t mode_number;
1482
    uint_fast16_t blocksize;
1483
    int_fast32_t i,j;
1484
    uint_fast8_t no_residue[vc->audio_channels];
1485
    uint_fast8_t do_not_decode[vc->audio_channels];
1486
    vorbis_mapping *mapping;
1487
    float *ch_res_ptr=vc->channel_residues;
1488
    float *ch_floor_ptr=vc->channel_floors;
1489
    uint_fast8_t res_chan[vc->audio_channels];
1490
    uint_fast8_t res_num=0;
1491
    int_fast16_t retlen=0;
1492
    uint_fast16_t saved_start=0;
1493

    
1494
    if (get_bits1(gb)) {
1495
        av_log(vc->avccontext, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1496
        return -1; // packet type not audio
1497
    }
1498

    
1499
    if (vc->mode_count==1) {
1500
        mode_number=0;
1501
    } else {
1502
        mode_number=get_bits(gb, ilog(vc->mode_count-1));
1503
    }
1504
    vc->mode_number=mode_number;
1505
    mapping=&vc->mappings[vc->modes[mode_number].mapping];
1506

    
1507
    AV_DEBUG(" Mode number: %d , mapping: %d , blocktype %d \n", mode_number, vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1508

    
1509
    if (vc->modes[mode_number].blockflag) {
1510
        previous_window=get_bits1(gb);
1511
        next_window=get_bits1(gb);
1512
    }
1513

    
1514
    blocksize=vc->modes[mode_number].blockflag ? vc->blocksize_1 : vc->blocksize_0;
1515
    memset(ch_res_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ?
1516
    memset(ch_floor_ptr, 0, sizeof(float)*vc->audio_channels*blocksize/2); //FIXME can this be removed ?
1517

    
1518
// Decode floor
1519

    
1520
    for(i=0;i<vc->audio_channels;++i) {
1521
        vorbis_floor *floor;
1522
        if (mapping->submaps>1) {
1523
            floor=&vc->floors[mapping->submap_floor[mapping->mux[i]]];
1524
        } else {
1525
            floor=&vc->floors[mapping->submap_floor[0]];
1526
        }
1527

    
1528
        no_residue[i]=floor->decode(vc, &floor->data, ch_floor_ptr);
1529
        ch_floor_ptr+=blocksize/2;
1530
    }
1531

    
1532
// Nonzero vector propagate
1533

    
1534
    for(i=mapping->coupling_steps-1;i>=0;--i) {
1535
        if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1536
            no_residue[mapping->magnitude[i]]=0;
1537
            no_residue[mapping->angle[i]]=0;
1538
        }
1539
    }
1540

    
1541
// Decode residue
1542

    
1543
    for(i=0;i<mapping->submaps;++i) {
1544
        vorbis_residue *residue;
1545
        uint_fast8_t ch=0;
1546

    
1547
        for(j=0;j<vc->audio_channels;++j) {
1548
            if ((mapping->submaps==1) || (i=mapping->mux[j])) {
1549
                res_chan[j]=res_num;
1550
                if (no_residue[j]) {
1551
                    do_not_decode[ch]=1;
1552
                } else {
1553
                    do_not_decode[ch]=0;
1554
                }
1555
                ++ch;
1556
                ++res_num;
1557
            }
1558
        }
1559
        residue=&vc->residues[mapping->submap_residue[i]];
1560
        vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, blocksize/2);
1561

    
1562
        ch_res_ptr+=ch*blocksize/2;
1563
    }
1564

    
1565
// Inverse coupling
1566

    
1567
    for(i=mapping->coupling_steps-1;i>=0;--i) { //warning: i has to be signed
1568
        float *mag, *ang;
1569

    
1570
        mag=vc->channel_residues+res_chan[mapping->magnitude[i]]*blocksize/2;
1571
        ang=vc->channel_residues+res_chan[mapping->angle[i]]*blocksize/2;
1572
        vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize/2);
1573
    }
1574

    
1575
// Dotproduct
1576

    
1577
    for(j=0, ch_floor_ptr=vc->channel_floors;j<vc->audio_channels;++j,ch_floor_ptr+=blocksize/2) {
1578
        ch_res_ptr=vc->channel_residues+res_chan[j]*blocksize/2;
1579

    
1580
        for(i=0;i<blocksize/2;++i) {
1581
            ch_floor_ptr[i]*=ch_res_ptr[i]; //FPMATH
1582
        }
1583
    }
1584

    
1585
// MDCT, overlap/add, save data for next overlapping  FPMATH
1586

    
1587
    for(j=0;j<vc->audio_channels;++j) {
1588
        uint_fast8_t step=vc->audio_channels;
1589
        uint_fast16_t k;
1590
        float *saved=vc->saved+j*vc->blocksize_1/2;
1591
        float *ret=vc->ret;
1592
        const float *lwin=vc->lwin;
1593
        const float *swin=vc->swin;
1594
        float *buf=vc->buf;
1595
        float *buf_tmp=vc->buf_tmp;
1596

    
1597
        ch_floor_ptr=vc->channel_floors+j*blocksize/2;
1598

    
1599
        saved_start=vc->saved_start;
1600

    
1601
        vc->mdct0.fft.imdct_calc(vc->modes[mode_number].blockflag ? &vc->mdct1 : &vc->mdct0, buf, ch_floor_ptr, buf_tmp);
1602

    
1603
        if (vc->modes[mode_number].blockflag) {
1604
            // -- overlap/add
1605
            if (previous_window) {
1606
                for(k=j, i=0;i<vc->blocksize_1/2;++i, k+=step) {
1607
                    ret[k]=saved[i]+buf[i]*lwin[i]+BIAS;
1608
                }
1609
                retlen=vc->blocksize_1/2;
1610
            } else {
1611
                buf += (vc->blocksize_1-vc->blocksize_0)/4;
1612
                for(k=j, i=0;i<vc->blocksize_0/2;++i, k+=step) {
1613
                    ret[k]=saved[i]+buf[i]*swin[i]+BIAS;
1614
                }
1615
                buf += vc->blocksize_0/2;
1616
                for(i=0;i<(vc->blocksize_1-vc->blocksize_0)/4;++i, k+=step) {
1617
                    ret[k]=buf[i]+BIAS;
1618
                }
1619
                buf=vc->buf;
1620
                retlen=vc->blocksize_0/2+(vc->blocksize_1-vc->blocksize_0)/4;
1621
            }
1622
            // -- save
1623
            if (next_window) {
1624
                buf += vc->blocksize_1/2;
1625
                lwin += vc->blocksize_1/2-1;
1626
                for(i=0;i<vc->blocksize_1/2;++i) {
1627
                    saved[i]=buf[i]*lwin[-i];
1628
                }
1629
                saved_start=0;
1630
            } else {
1631
                saved_start=(vc->blocksize_1-vc->blocksize_0)/4;
1632
                buf += vc->blocksize_1/2;
1633
                for(i=0;i<saved_start;++i) {
1634
                    saved[i]=buf[i];
1635
                }
1636
                swin += vc->blocksize_0/2-1;
1637
                for(i=0;i<vc->blocksize_0/2;++i) {
1638
                    saved[saved_start+i]=buf[saved_start+i]*swin[-i];
1639
                }
1640
            }
1641
        } else {
1642
            // --overlap/add
1643
            for(k=j, i=0;i<saved_start;++i, k+=step) {
1644
                ret[k]=saved[i]+BIAS;
1645
            }
1646
            for(i=0;i<vc->blocksize_0/2;++i, k+=step) {
1647
                ret[k]=saved[saved_start+i]+buf[i]*swin[i]+BIAS;
1648
            }
1649
            retlen=saved_start+vc->blocksize_0/2;
1650
            // -- save
1651
            buf += vc->blocksize_0/2;
1652
            swin += vc->blocksize_0/2-1;
1653
            for(i=0;i<vc->blocksize_0/2;++i) {
1654
                saved[i]=buf[i]*swin[-i];
1655
            }
1656
            saved_start=0;
1657
        }
1658
    }
1659
    vc->saved_start=saved_start;
1660

    
1661
    return retlen*vc->audio_channels;
1662
}
1663

    
1664
// Return the decoded audio packet through the standard api
1665

    
1666
static int vorbis_decode_frame(AVCodecContext *avccontext,
1667
                        void *data, int *data_size,
1668
                        uint8_t *buf, int buf_size)
1669
{
1670
    vorbis_context *vc = avccontext->priv_data ;
1671
    GetBitContext *gb = &(vc->gb);
1672

    
1673
    int_fast16_t i, len;
1674

    
1675
    if(!buf_size){
1676
        return 0;
1677
    }
1678

    
1679
    AV_DEBUG("packet length %d \n", buf_size);
1680

    
1681
    init_get_bits(gb, buf, buf_size*8);
1682

    
1683
    len=vorbis_parse_audio_packet(vc);
1684

    
1685
    if (len<=0) {
1686
        *data_size=0;
1687
        return buf_size;
1688
    }
1689

    
1690
    if (!vc->first_frame) {
1691
        vc->first_frame=1;
1692
        *data_size=0;
1693
        return buf_size ;
1694
    }
1695

    
1696
    AV_DEBUG("parsed %d bytes %d bits, returned %d samples (*ch*bits) \n", get_bits_count(gb)/8, get_bits_count(gb)%8, len);
1697

    
1698
    for(i=0;i<len;++i) {
1699
        int_fast32_t tmp= ((int32_t*)vc->ret)[i];
1700
        if(tmp & 0xf0000){
1701
//            tmp= (0x43c0ffff - tmp)>>31; //ask gcc devs why this is slower
1702
            if(tmp > 0x43c0ffff) tmp= 0xFFFF;
1703
            else                 tmp= 0;
1704
        }
1705
        ((int16_t*)data)[i]=tmp - 0x8000;
1706
    }
1707

    
1708
    *data_size=len*2;
1709

    
1710
    return buf_size ;
1711
}
1712

    
1713
// Close decoder
1714

    
1715
static int vorbis_decode_close(AVCodecContext *avccontext) {
1716
    vorbis_context *vc = avccontext->priv_data;
1717

    
1718
    vorbis_free(vc);
1719

    
1720
    return 0 ;
1721
}
1722

    
1723
AVCodec vorbis_decoder = {
1724
    "vorbis",
1725
    CODEC_TYPE_AUDIO,
1726
    CODEC_ID_VORBIS,
1727
    sizeof(vorbis_context),
1728
    vorbis_decode_init,
1729
    NULL,
1730
    vorbis_decode_close,
1731
    vorbis_decode_frame,
1732
};
1733