GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vorbisdec.c Lines: 721 913 79.0 %
Date: 2020-08-11 16:46:18 Branches: 405 582 69.6 %

Line Branch Exec Source
1
/**
2
 * @file
3
 * Vorbis I decoder
4
 * @author Denes Balatoni  ( dbalatoni programozo hu )
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * Vorbis I decoder
26
 * @author Denes Balatoni  ( dbalatoni programozo hu )
27
 */
28
29
#include <inttypes.h>
30
#include <math.h>
31
32
#include "libavutil/avassert.h"
33
#include "libavutil/float_dsp.h"
34
35
#define BITSTREAM_READER_LE
36
#include "avcodec.h"
37
#include "fft.h"
38
#include "get_bits.h"
39
#include "internal.h"
40
#include "vorbis.h"
41
#include "vorbisdsp.h"
42
#include "xiph.h"
43
44
#define V_NB_BITS 8
45
#define V_NB_BITS2 11
46
#define V_MAX_VLCS (1 << 16)
47
#define V_MAX_PARTITIONS (1 << 20)
48
49
typedef struct vorbis_codebook {
50
    uint8_t      dimensions;
51
    uint8_t      lookup_type;
52
    uint8_t      maxdepth;
53
    VLC          vlc;
54
    float       *codevectors;
55
    unsigned int nb_bits;
56
} vorbis_codebook;
57
58
typedef union  vorbis_floor_u  vorbis_floor_data;
59
typedef struct vorbis_floor0_s vorbis_floor0;
60
typedef struct vorbis_floor1_s vorbis_floor1;
61
struct vorbis_context_s;
62
typedef
63
int (* vorbis_floor_decode_func)
64
    (struct vorbis_context_s *, vorbis_floor_data *, float *);
65
typedef struct vorbis_floor {
66
    uint8_t floor_type;
67
    vorbis_floor_decode_func decode;
68
    union vorbis_floor_u {
69
        struct vorbis_floor0_s {
70
            uint8_t       order;
71
            uint16_t      rate;
72
            uint16_t      bark_map_size;
73
            int32_t      *map[2];
74
            uint32_t      map_size[2];
75
            uint8_t       amplitude_bits;
76
            uint8_t       amplitude_offset;
77
            uint8_t       num_books;
78
            uint8_t      *book_list;
79
            float        *lsp;
80
        } t0;
81
        struct vorbis_floor1_s {
82
            uint8_t       partitions;
83
            uint8_t       partition_class[32];
84
            uint8_t       class_dimensions[16];
85
            uint8_t       class_subclasses[16];
86
            uint8_t       class_masterbook[16];
87
            int16_t       subclass_books[16][8];
88
            uint8_t       multiplier;
89
            uint16_t      x_list_dim;
90
            vorbis_floor1_entry *list;
91
        } t1;
92
    } data;
93
} vorbis_floor;
94
95
typedef struct vorbis_residue {
96
    uint16_t      type;
97
    uint32_t      begin;
98
    uint32_t      end;
99
    unsigned      partition_size;
100
    uint8_t       classifications;
101
    uint8_t       classbook;
102
    int16_t       books[64][8];
103
    uint8_t       maxpass;
104
    uint16_t      ptns_to_read;
105
    uint8_t      *classifs;
106
} vorbis_residue;
107
108
typedef struct vorbis_mapping {
109
    uint8_t       submaps;
110
    uint16_t      coupling_steps;
111
    uint8_t      *magnitude;
112
    uint8_t      *angle;
113
    uint8_t      *mux;
114
    uint8_t       submap_floor[16];
115
    uint8_t       submap_residue[16];
116
} vorbis_mapping;
117
118
typedef struct vorbis_mode {
119
    uint8_t       blockflag;
120
    uint16_t      windowtype;
121
    uint16_t      transformtype;
122
    uint8_t       mapping;
123
} vorbis_mode;
124
125
typedef struct vorbis_context_s {
126
    AVCodecContext *avctx;
127
    GetBitContext gb;
128
    VorbisDSPContext dsp;
129
    AVFloatDSPContext *fdsp;
130
131
    FFTContext mdct[2];
132
    uint8_t       first_frame;
133
    uint32_t      version;
134
    uint8_t       audio_channels;
135
    uint32_t      audio_samplerate;
136
    uint32_t      bitrate_maximum;
137
    uint32_t      bitrate_nominal;
138
    uint32_t      bitrate_minimum;
139
    uint32_t      blocksize[2];
140
    const float  *win[2];
141
    uint16_t      codebook_count;
142
    vorbis_codebook *codebooks;
143
    uint8_t       floor_count;
144
    vorbis_floor *floors;
145
    uint8_t       residue_count;
146
    vorbis_residue *residues;
147
    uint8_t       mapping_count;
148
    vorbis_mapping *mappings;
149
    uint8_t       mode_count;
150
    vorbis_mode  *modes;
151
    uint8_t       mode_number; // mode number for the current packet
152
    int8_t       previous_window;
153
    float        *channel_residues;
154
    float        *saved;
155
} vorbis_context;
156
157
/* Helper functions */
158
159
#define BARK(x) \
160
    (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))
161
162
static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";
163
#define VALIDATE_INDEX(idx, limit) \
164
    if (idx >= limit) {\
165
        av_log(vc->avctx, AV_LOG_ERROR,\
166
               idx_err_str,\
167
               (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\
168
        return AVERROR_INVALIDDATA;\
169
    }
170
#define GET_VALIDATED_INDEX(idx, bits, limit) \
171
    {\
172
        idx = get_bits(gb, bits);\
173
        VALIDATE_INDEX(idx, limit)\
174
    }
175
176
1720
static float vorbisfloat2float(unsigned val)
177
{
178
1720
    double mant = val & 0x1fffff;
179
1720
    long exp    = (val & 0x7fe00000L) >> 21;
180
1720
    if (val & 0x80000000)
181
792
        mant = -mant;
182
1720
    return ldexp(mant, exp - 20 - 768);
183
}
184
185
186
// Free all allocated memory -----------------------------------------
187
188
62
static void vorbis_free(vorbis_context *vc)
189
{
190
    int i;
191
192
62
    av_freep(&vc->channel_residues);
193
62
    av_freep(&vc->saved);
194
62
    av_freep(&vc->fdsp);
195
196
62
    if (vc->residues)
197
186
        for (i = 0; i < vc->residue_count; i++)
198
124
            av_freep(&vc->residues[i].classifs);
199
62
    av_freep(&vc->residues);
200
62
    av_freep(&vc->modes);
201
202
62
    ff_mdct_end(&vc->mdct[0]);
203
62
    ff_mdct_end(&vc->mdct[1]);
204
205
62
    if (vc->codebooks)
206
1980
        for (i = 0; i < vc->codebook_count; ++i) {
207
1918
            av_freep(&vc->codebooks[i].codevectors);
208
1918
            ff_free_vlc(&vc->codebooks[i].vlc);
209
        }
210
62
    av_freep(&vc->codebooks);
211
212
62
    if (vc->floors)
213
186
        for (i = 0; i < vc->floor_count; ++i) {
214
124
            if (vc->floors[i].floor_type == 0) {
215
44
                av_freep(&vc->floors[i].data.t0.map[0]);
216
44
                av_freep(&vc->floors[i].data.t0.map[1]);
217
44
                av_freep(&vc->floors[i].data.t0.book_list);
218
44
                av_freep(&vc->floors[i].data.t0.lsp);
219
            } else {
220
80
                av_freep(&vc->floors[i].data.t1.list);
221
            }
222
        }
223
62
    av_freep(&vc->floors);
224
225
62
    if (vc->mappings)
226
184
        for (i = 0; i < vc->mapping_count; ++i) {
227
122
            av_freep(&vc->mappings[i].magnitude);
228
122
            av_freep(&vc->mappings[i].angle);
229
122
            av_freep(&vc->mappings[i].mux);
230
        }
231
62
    av_freep(&vc->mappings);
232
62
}
233
234
// Parse setup header -------------------------------------------------
235
236
// Process codebooks part
237
238
62
static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)
239
{
240
    unsigned cb;
241
62
    uint8_t  *tmp_vlc_bits  = NULL;
242
62
    uint32_t *tmp_vlc_codes = NULL;
243
62
    GetBitContext *gb = &vc->gb;
244
62
    uint16_t *codebook_multiplicands = NULL;
245
62
    int ret = 0;
246
247
62
    vc->codebook_count = get_bits(gb, 8) + 1;
248
249
    ff_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);
250
251
62
    vc->codebooks = av_mallocz(vc->codebook_count * sizeof(*vc->codebooks));
252
62
    tmp_vlc_bits  = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_bits));
253
62
    tmp_vlc_codes = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_codes));
254
62
    codebook_multiplicands = av_malloc(V_MAX_VLCS * sizeof(*codebook_multiplicands));
255

62
    if (!vc->codebooks ||
256

62
        !tmp_vlc_bits || !tmp_vlc_codes || !codebook_multiplicands) {
257
        ret = AVERROR(ENOMEM);
258
        goto error;
259
    }
260
261
1980
    for (cb = 0; cb < vc->codebook_count; ++cb) {
262
1918
        vorbis_codebook *codebook_setup = &vc->codebooks[cb];
263
1918
        unsigned ordered, t, entries, used_entries = 0;
264
265
        ff_dlog(NULL, " %u. Codebook\n", cb);
266
267
1918
        if (get_bits(gb, 24) != 0x564342) {
268
            av_log(vc->avctx, AV_LOG_ERROR,
269
                   " %u. Codebook setup data corrupt.\n", cb);
270
            ret = AVERROR_INVALIDDATA;
271
            goto error;
272
        }
273
274
1918
        codebook_setup->dimensions=get_bits(gb, 16);
275

1918
        if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {
276
            av_log(vc->avctx, AV_LOG_ERROR,
277
                   " %u. Codebook's dimension is invalid (%d).\n",
278
                   cb, codebook_setup->dimensions);
279
            ret = AVERROR_INVALIDDATA;
280
            goto error;
281
        }
282
1918
        entries = get_bits(gb, 24);
283
1918
        if (entries > V_MAX_VLCS) {
284
            av_log(vc->avctx, AV_LOG_ERROR,
285
                   " %u. Codebook has too many entries (%u).\n",
286
                   cb, entries);
287
            ret = AVERROR_INVALIDDATA;
288
            goto error;
289
        }
290
291
1918
        ordered = get_bits1(gb);
292
293
        ff_dlog(NULL, " codebook_dimensions %d, codebook_entries %u\n",
294
                codebook_setup->dimensions, entries);
295
296
1918
        if (!ordered) {
297
            unsigned ce, flag;
298
1898
            unsigned sparse = get_bits1(gb);
299
300
            ff_dlog(NULL, " not ordered \n");
301
302
1898
            if (sparse) {
303
                ff_dlog(NULL, " sparse \n");
304
305
770
                used_entries = 0;
306
279642
                for (ce = 0; ce < entries; ++ce) {
307
278872
                    flag = get_bits1(gb);
308
278872
                    if (flag) {
309
94878
                        tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
310
94878
                        ++used_entries;
311
                    } else
312
183994
                        tmp_vlc_bits[ce] = 0;
313
                }
314
            } else {
315
                ff_dlog(NULL, " not sparse \n");
316
317
1128
                used_entries = entries;
318
292038
                for (ce = 0; ce < entries; ++ce)
319
290910
                    tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;
320
            }
321
        } else {
322
20
            unsigned current_entry  = 0;
323
20
            unsigned current_length = get_bits(gb, 5) + 1;
324
325
            ff_dlog(NULL, " ordered, current length: %u\n", current_length);  //FIXME
326
327
20
            used_entries = entries;
328

100
            for (; current_entry < used_entries && current_length <= 32; ++current_length) {
329
                unsigned i, number;
330
331
                ff_dlog(NULL, " number bits: %u ", ilog(entries - current_entry));
332
333
80
                number = get_bits(gb, ilog(entries - current_entry));
334
335
                ff_dlog(NULL, " number: %u\n", number);
336
337
966
                for (i = current_entry; i < number+current_entry; ++i)
338
886
                    if (i < used_entries)
339
886
                        tmp_vlc_bits[i] = current_length;
340
341
80
                current_entry+=number;
342
            }
343
20
            if (current_entry>used_entries) {
344
                av_log(vc->avctx, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");
345
                ret = AVERROR_INVALIDDATA;
346
                goto error;
347
            }
348
        }
349
350
1918
        codebook_setup->lookup_type = get_bits(gb, 4);
351
352
        ff_dlog(NULL, " lookup type: %d : %s \n", codebook_setup->lookup_type,
353
                codebook_setup->lookup_type ? "vq" : "no lookup");
354
355
// If the codebook is used for (inverse) VQ, calculate codevectors.
356
357
1918
        if (codebook_setup->lookup_type == 1) {
358
            unsigned i, j, k;
359
860
            unsigned codebook_lookup_values = ff_vorbis_nth_root(entries, codebook_setup->dimensions);
360
361
860
            float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb, 32));
362
860
            float codebook_delta_value   = vorbisfloat2float(get_bits_long(gb, 32));
363
860
            unsigned codebook_value_bits = get_bits(gb, 4) + 1;
364
860
            unsigned codebook_sequence_p = get_bits1(gb);
365
366
            ff_dlog(NULL, " We expect %d numbers for building the codevectors. \n",
367
                    codebook_lookup_values);
368
            ff_dlog(NULL, "  delta %f minmum %f \n",
369
                    codebook_delta_value, codebook_minimum_value);
370
371
17796
            for (i = 0; i < codebook_lookup_values; ++i) {
372
16936
                codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);
373
374
                ff_dlog(NULL, " multiplicands*delta+minmum : %e \n",
375
                        (float)codebook_multiplicands[i] * codebook_delta_value + codebook_minimum_value);
376
                ff_dlog(NULL, " multiplicand %u\n", codebook_multiplicands[i]);
377
            }
378
379
// Weed out unused vlcs and build codevector vector
380
860
            if (used_entries) {
381
860
                codebook_setup->codevectors =
382
860
                    av_mallocz_array(used_entries, codebook_setup->dimensions *
383
                               sizeof(*codebook_setup->codevectors));
384
860
                if (!codebook_setup->codevectors) {
385
                    ret = AVERROR(ENOMEM);
386
                    goto error;
387
                }
388
            } else
389
                codebook_setup->codevectors = NULL;
390
391
482758
            for (j = 0, i = 0; i < entries; ++i) {
392
481898
                unsigned dim = codebook_setup->dimensions;
393
394
481898
                if (tmp_vlc_bits[i]) {
395
309262
                    float last = 0.0;
396
309262
                    unsigned lookup_offset = i;
397
398
                    ff_dlog(vc->avctx, "Lookup offset %u ,", i);
399
400
1235351
                    for (k = 0; k < dim; ++k) {
401
926089
                        unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;
402
926089
                        codebook_setup->codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last;
403
926089
                        if (codebook_sequence_p)
404
257530
                            last = codebook_setup->codevectors[j * dim + k];
405
926089
                        lookup_offset/=codebook_lookup_values;
406
                    }
407
309262
                    tmp_vlc_bits[j] = tmp_vlc_bits[i];
408
409
                    ff_dlog(vc->avctx, "real lookup offset %u, vector: ", j);
410
1235351
                    for (k = 0; k < dim; ++k)
411
                        ff_dlog(vc->avctx, " %f ",
412
                                codebook_setup->codevectors[j * dim + k]);
413
                    ff_dlog(vc->avctx, "\n");
414
415
309262
                    ++j;
416
                }
417
            }
418
860
            if (j != used_entries) {
419
                av_log(vc->avctx, AV_LOG_ERROR, "Bug in codevector vector building code. \n");
420
                ret = AVERROR_INVALIDDATA;
421
                goto error;
422
            }
423
860
            entries = used_entries;
424
1058
        } else if (codebook_setup->lookup_type >= 2) {
425
            av_log(vc->avctx, AV_LOG_ERROR, "Codebook lookup type not supported. \n");
426
            ret = AVERROR_INVALIDDATA;
427
            goto error;
428
        }
429
430
// Initialize VLC table
431
1918
        if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) {
432
            av_log(vc->avctx, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");
433
            ret = AVERROR_INVALIDDATA;
434
            goto error;
435
        }
436
1918
        codebook_setup->maxdepth = 0;
437
399950
        for (t = 0; t < entries; ++t)
438
398032
            if (tmp_vlc_bits[t] >= codebook_setup->maxdepth)
439
106190
                codebook_setup->maxdepth = tmp_vlc_bits[t];
440
441
1918
        if (codebook_setup->maxdepth > 3 * V_NB_BITS)
442
            codebook_setup->nb_bits = V_NB_BITS2;
443
        else
444
1918
            codebook_setup->nb_bits = V_NB_BITS;
445
446
1918
        codebook_setup->maxdepth = (codebook_setup->maxdepth+codebook_setup->nb_bits - 1) / codebook_setup->nb_bits;
447
448
1918
        if ((ret = init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits,
449
                            entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits),
450
                            sizeof(*tmp_vlc_bits), tmp_vlc_codes,
451
                            sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes),
452
                            INIT_VLC_LE))) {
453
            av_log(vc->avctx, AV_LOG_ERROR, " Error generating vlc tables. \n");
454
            goto error;
455
        }
456
    }
457
458
62
    av_free(tmp_vlc_bits);
459
62
    av_free(tmp_vlc_codes);
460
62
    av_free(codebook_multiplicands);
461
62
    return 0;
462
463
// Error:
464
error:
465
    av_free(tmp_vlc_bits);
466
    av_free(tmp_vlc_codes);
467
    av_free(codebook_multiplicands);
468
    return ret;
469
}
470
471
// Process time domain transforms part (unused in Vorbis I)
472
473
62
static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)
474
{
475
62
    GetBitContext *gb = &vc->gb;
476
62
    unsigned i, vorbis_time_count = get_bits(gb, 6) + 1;
477
478
124
    for (i = 0; i < vorbis_time_count; ++i) {
479
62
        unsigned vorbis_tdtransform = get_bits(gb, 16);
480
481
        ff_dlog(NULL, " Vorbis time domain transform %u: %u\n",
482
                vorbis_time_count, vorbis_tdtransform);
483
484
62
        if (vorbis_tdtransform) {
485
            av_log(vc->avctx, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");
486
            return AVERROR_INVALIDDATA;
487
        }
488
    }
489
62
    return 0;
490
}
491
492
// Process floors part
493
494
static int vorbis_floor0_decode(vorbis_context *vc,
495
                                vorbis_floor_data *vfu, float *vec);
496
static int create_map(vorbis_context *vc, unsigned floor_number);
497
static int vorbis_floor1_decode(vorbis_context *vc,
498
                                vorbis_floor_data *vfu, float *vec);
499
62
static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)
500
{
501
62
    GetBitContext *gb = &vc->gb;
502
    int i, j, k, ret;
503
504
62
    vc->floor_count = get_bits(gb, 6) + 1;
505
506
62
    vc->floors = av_mallocz(vc->floor_count * sizeof(*vc->floors));
507
62
    if (!vc->floors)
508
        return AVERROR(ENOMEM);
509
510
186
    for (i = 0; i < vc->floor_count; ++i) {
511
124
        vorbis_floor *floor_setup = &vc->floors[i];
512
513
124
        floor_setup->floor_type = get_bits(gb, 16);
514
515
        ff_dlog(NULL, " %d. floor type %d \n", i, floor_setup->floor_type);
516
517
124
        if (floor_setup->floor_type == 1) {
518
80
            int maximum_class = -1;
519
80
            unsigned rangebits, rangemax, floor1_values = 2;
520
521
80
            floor_setup->decode = vorbis_floor1_decode;
522
523
80
            floor_setup->data.t1.partitions = get_bits(gb, 5);
524
525
            ff_dlog(NULL, " %d.floor: %d partitions \n",
526
                    i, floor_setup->data.t1.partitions);
527
528
546
            for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
529
466
                floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);
530
466
                if (floor_setup->data.t1.partition_class[j] > maximum_class)
531
294
                    maximum_class = floor_setup->data.t1.partition_class[j];
532
533
                ff_dlog(NULL, " %d. floor %d partition class %d \n",
534
                        i, j, floor_setup->data.t1.partition_class[j]);
535
536
            }
537
538
            ff_dlog(NULL, " maximum class %d \n", maximum_class);
539
540
374
            for (j = 0; j <= maximum_class; ++j) {
541
294
                floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;
542
294
                floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);
543
544
                ff_dlog(NULL, " %d floor %d class dim: %d subclasses %d \n", i, j,
545
                        floor_setup->data.t1.class_dimensions[j],
546
                        floor_setup->data.t1.class_subclasses[j]);
547
548
294
                if (floor_setup->data.t1.class_subclasses[j]) {
549
242
                    GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)
550
551
                    ff_dlog(NULL, "   masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);
552
                }
553
554
1130
                for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) {
555
836
                    int16_t bits = get_bits(gb, 8) - 1;
556
836
                    if (bits != -1)
557
692
                        VALIDATE_INDEX(bits, vc->codebook_count)
558
836
                    floor_setup->data.t1.subclass_books[j][k] = bits;
559
560
                    ff_dlog(NULL, "    book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);
561
                }
562
            }
563
564
80
            floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1;
565
80
            floor_setup->data.t1.x_list_dim = 2;
566
567
546
            for (j = 0; j < floor_setup->data.t1.partitions; ++j)
568
466
                floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];
569
570
80
            floor_setup->data.t1.list = av_mallocz_array(floor_setup->data.t1.x_list_dim,
571
                                                   sizeof(*floor_setup->data.t1.list));
572
80
            if (!floor_setup->data.t1.list)
573
                return AVERROR(ENOMEM);
574
575
80
            rangebits = get_bits(gb, 4);
576

80
            if (!rangebits && floor_setup->data.t1.partitions) {
577
                av_log(vc->avctx, AV_LOG_ERROR,
578
                       "A rangebits value of 0 is not compliant with the Vorbis I specification.\n");
579
                return AVERROR_INVALIDDATA;
580
            }
581
80
            rangemax = (1 << rangebits);
582
80
            if (rangemax > vc->blocksize[1] / 2) {
583
                av_log(vc->avctx, AV_LOG_ERROR,
584
                       "Floor value is too large for blocksize: %u (%"PRIu32")\n",
585
                       rangemax, vc->blocksize[1] / 2);
586
                return AVERROR_INVALIDDATA;
587
            }
588
80
            floor_setup->data.t1.list[0].x = 0;
589
80
            floor_setup->data.t1.list[1].x = rangemax;
590
591
546
            for (j = 0; j < floor_setup->data.t1.partitions; ++j) {
592
1960
                for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) {
593
1494
                    floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits);
594
595
                    ff_dlog(NULL, " %u. floor1 Y coord. %d\n", floor1_values,
596
                            floor_setup->data.t1.list[floor1_values].x);
597
                }
598
            }
599
600
// Precalculate order of x coordinates - needed for decode
601
80
            if (ff_vorbis_ready_floor1_list(vc->avctx,
602
                                            floor_setup->data.t1.list,
603
80
                                            floor_setup->data.t1.x_list_dim)) {
604
                return AVERROR_INVALIDDATA;
605
            }
606
44
        } else if (floor_setup->floor_type == 0) {
607
44
            unsigned max_codebook_dim = 0;
608
609
44
            floor_setup->decode = vorbis_floor0_decode;
610
611
44
            floor_setup->data.t0.order          = get_bits(gb,  8);
612
44
            if (!floor_setup->data.t0.order) {
613
                av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");
614
                return AVERROR_INVALIDDATA;
615
            }
616
44
            floor_setup->data.t0.rate           = get_bits(gb, 16);
617
44
            if (!floor_setup->data.t0.rate) {
618
                av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");
619
                return AVERROR_INVALIDDATA;
620
            }
621
44
            floor_setup->data.t0.bark_map_size  = get_bits(gb, 16);
622
44
            if (!floor_setup->data.t0.bark_map_size) {
623
                av_log(vc->avctx, AV_LOG_ERROR,
624
                       "Floor 0 bark map size is 0.\n");
625
                return AVERROR_INVALIDDATA;
626
            }
627
44
            floor_setup->data.t0.amplitude_bits = get_bits(gb,  6);
628
44
            floor_setup->data.t0.amplitude_offset = get_bits(gb, 8);
629
44
            floor_setup->data.t0.num_books        = get_bits(gb, 4) + 1;
630
631
            /* allocate mem for booklist */
632
44
            floor_setup->data.t0.book_list =
633
44
                av_malloc(floor_setup->data.t0.num_books);
634
44
            if (!floor_setup->data.t0.book_list)
635
                return AVERROR(ENOMEM);
636
            /* read book indexes */
637
            {
638
                int idx;
639
                unsigned book_idx;
640
112
                for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
641
68
                    GET_VALIDATED_INDEX(book_idx, 8, vc->codebook_count)
642
68
                    floor_setup->data.t0.book_list[idx] = book_idx;
643
68
                    if (vc->codebooks[book_idx].dimensions > max_codebook_dim)
644
68
                        max_codebook_dim = vc->codebooks[book_idx].dimensions;
645
                }
646
            }
647
648
44
            if ((ret = create_map(vc, i)) < 0)
649
                return ret;
650
651
            /* codebook dim is for padding if codebook dim doesn't *
652
             * divide order+1 then we need to read more data       */
653
44
            floor_setup->data.t0.lsp =
654
44
                av_malloc_array((floor_setup->data.t0.order + 1 + max_codebook_dim),
655
                                sizeof(*floor_setup->data.t0.lsp));
656
44
            if (!floor_setup->data.t0.lsp)
657
                return AVERROR(ENOMEM);
658
659
            /* debug output parsed headers */
660
            ff_dlog(NULL, "floor0 order: %u\n", floor_setup->data.t0.order);
661
            ff_dlog(NULL, "floor0 rate: %u\n", floor_setup->data.t0.rate);
662
            ff_dlog(NULL, "floor0 bark map size: %u\n",
663
                    floor_setup->data.t0.bark_map_size);
664
            ff_dlog(NULL, "floor0 amplitude bits: %u\n",
665
                    floor_setup->data.t0.amplitude_bits);
666
            ff_dlog(NULL, "floor0 amplitude offset: %u\n",
667
                    floor_setup->data.t0.amplitude_offset);
668
            ff_dlog(NULL, "floor0 number of books: %u\n",
669
                    floor_setup->data.t0.num_books);
670
            ff_dlog(NULL, "floor0 book list pointer: %p\n",
671
                    floor_setup->data.t0.book_list);
672
            {
673
                int idx;
674
112
                for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {
675
                    ff_dlog(NULL, "  Book %d: %u\n", idx + 1,
676
                            floor_setup->data.t0.book_list[idx]);
677
                }
678
            }
679
        } else {
680
            av_log(vc->avctx, AV_LOG_ERROR, "Invalid floor type!\n");
681
            return AVERROR_INVALIDDATA;
682
        }
683
    }
684
62
    return 0;
685
}
686
687
// Process residues part
688
689
62
static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
690
{
691
62
    GetBitContext *gb = &vc->gb;
692
    unsigned i, j, k;
693
694
62
    vc->residue_count = get_bits(gb, 6)+1;
695
62
    vc->residues      = av_mallocz(vc->residue_count * sizeof(*vc->residues));
696
62
    if (!vc->residues)
697
        return AVERROR(ENOMEM);
698
699
    ff_dlog(NULL, " There are %d residues. \n", vc->residue_count);
700
701
186
    for (i = 0; i < vc->residue_count; ++i) {
702
124
        vorbis_residue *res_setup = &vc->residues[i];
703
        uint8_t cascade[64];
704
        unsigned high_bits, low_bits;
705
706
124
        res_setup->type = get_bits(gb, 16);
707
708
        ff_dlog(NULL, " %u. residue type %d\n", i, res_setup->type);
709
710
124
        res_setup->begin          = get_bits(gb, 24);
711
124
        res_setup->end            = get_bits(gb, 24);
712
124
        res_setup->partition_size = get_bits(gb, 24) + 1;
713
        /* Validations to prevent a buffer overflow later. */
714
124
        if (res_setup->begin>res_setup->end ||
715
124
            (res_setup->end-res_setup->begin) / res_setup->partition_size > FFMIN(V_MAX_PARTITIONS, 65535)) {
716
            av_log(vc->avctx, AV_LOG_ERROR,
717
                   "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",
718
                   res_setup->type, res_setup->begin, res_setup->end,
719
                   res_setup->partition_size, vc->blocksize[1] / 2);
720
            return AVERROR_INVALIDDATA;
721
        }
722
723
124
        res_setup->classifications = get_bits(gb, 6) + 1;
724
124
        GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)
725
726
124
        res_setup->ptns_to_read =
727
124
            (res_setup->end - res_setup->begin) / res_setup->partition_size;
728
248
        res_setup->classifs = av_malloc_array(res_setup->ptns_to_read,
729
124
                                        vc->audio_channels *
730
                                        sizeof(*res_setup->classifs));
731
124
        if (!res_setup->classifs)
732
            return AVERROR(ENOMEM);
733
734
        ff_dlog(NULL, "    begin %"PRIu32" end %"PRIu32" part.size %u classif.s %"PRIu8" classbook %"PRIu8"\n",
735
                res_setup->begin, res_setup->end, res_setup->partition_size,
736
                res_setup->classifications, res_setup->classbook);
737
738
1204
        for (j = 0; j < res_setup->classifications; ++j) {
739
1080
            high_bits = 0;
740
1080
            low_bits  = get_bits(gb, 3);
741
1080
            if (get_bits1(gb))
742
4
                high_bits = get_bits(gb, 5);
743
1080
            cascade[j] = (high_bits << 3) + low_bits;
744
745
            ff_dlog(NULL, "     %u class cascade depth: %d\n", j, ilog(cascade[j]));
746
        }
747
748
124
        res_setup->maxpass = 0;
749
1204
        for (j = 0; j < res_setup->classifications; ++j) {
750
9720
            for (k = 0; k < 8; ++k) {
751
8640
                if (cascade[j]&(1 << k)) {
752
1268
                    GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)
753
754
                    ff_dlog(NULL, "     %u class cascade depth %u book: %d\n",
755
                            j, k, res_setup->books[j][k]);
756
757
1268
                    if (k>res_setup->maxpass)
758
98
                        res_setup->maxpass = k;
759
                } else {
760
7372
                    res_setup->books[j][k] = -1;
761
                }
762
            }
763
        }
764
    }
765
62
    return 0;
766
}
767
768
// Process mappings part
769
770
62
static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)
771
{
772
62
    GetBitContext *gb = &vc->gb;
773
    unsigned i, j;
774
775
62
    vc->mapping_count = get_bits(gb, 6)+1;
776
62
    vc->mappings      = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));
777
62
    if (!vc->mappings)
778
        return AVERROR(ENOMEM);
779
780
    ff_dlog(NULL, " There are %d mappings. \n", vc->mapping_count);
781
782
184
    for (i = 0; i < vc->mapping_count; ++i) {
783
122
        vorbis_mapping *mapping_setup = &vc->mappings[i];
784
785
122
        if (get_bits(gb, 16)) {
786
            av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");
787
            return AVERROR_INVALIDDATA;
788
        }
789
122
        if (get_bits1(gb)) {
790
4
            mapping_setup->submaps = get_bits(gb, 4) + 1;
791
        } else {
792
118
            mapping_setup->submaps = 1;
793
        }
794
795
122
        if (get_bits1(gb)) {
796
50
            mapping_setup->coupling_steps = get_bits(gb, 8) + 1;
797
50
            if (vc->audio_channels < 2) {
798
                av_log(vc->avctx, AV_LOG_ERROR,
799
                       "Square polar channel mapping with less than two channels is not compliant with the Vorbis I specification.\n");
800
                return AVERROR_INVALIDDATA;
801
            }
802
50
            mapping_setup->magnitude      = av_mallocz(mapping_setup->coupling_steps *
803
                                                       sizeof(*mapping_setup->magnitude));
804
50
            mapping_setup->angle          = av_mallocz(mapping_setup->coupling_steps *
805
                                                       sizeof(*mapping_setup->angle));
806

50
            if (!mapping_setup->angle || !mapping_setup->magnitude)
807
                return AVERROR(ENOMEM);
808
809
112
            for (j = 0; j < mapping_setup->coupling_steps; ++j) {
810
62
                GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels)
811
62
                GET_VALIDATED_INDEX(mapping_setup->angle[j],     ilog(vc->audio_channels - 1), vc->audio_channels)
812
            }
813
        } else {
814
72
            mapping_setup->coupling_steps = 0;
815
        }
816
817
        ff_dlog(NULL, "   %u mapping coupling steps: %d\n",
818
                i, mapping_setup->coupling_steps);
819
820
122
        if (get_bits(gb, 2)) {
821
            av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);
822
            return AVERROR_INVALIDDATA; // following spec.
823
        }
824
825
122
        if (mapping_setup->submaps>1) {
826
4
            mapping_setup->mux = av_mallocz_array(vc->audio_channels,
827
                                            sizeof(*mapping_setup->mux));
828
4
            if (!mapping_setup->mux)
829
                return AVERROR(ENOMEM);
830
831
28
            for (j = 0; j < vc->audio_channels; ++j)
832
24
                mapping_setup->mux[j] = get_bits(gb, 4);
833
        }
834
835
248
        for (j = 0; j < mapping_setup->submaps; ++j) {
836
126
            skip_bits(gb, 8); // FIXME check?
837
126
            GET_VALIDATED_INDEX(mapping_setup->submap_floor[j],   8, vc->floor_count)
838
126
            GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)
839
840
            ff_dlog(NULL, "   %u mapping %u submap : floor %d, residue %d\n", i, j,
841
                    mapping_setup->submap_floor[j],
842
                    mapping_setup->submap_residue[j]);
843
        }
844
    }
845
62
    return 0;
846
}
847
848
// Process modes part
849
850
44
static int create_map(vorbis_context *vc, unsigned floor_number)
851
{
852
44
    vorbis_floor *floors = vc->floors;
853
    vorbis_floor0 *vf;
854
    int idx;
855
    int blockflag, n;
856
    int32_t *map;
857
858
132
    for (blockflag = 0; blockflag < 2; ++blockflag) {
859
88
        n = vc->blocksize[blockflag] / 2;
860
176
        floors[floor_number].data.t0.map[blockflag] =
861
88
            av_malloc_array(n + 1, sizeof(int32_t)); // n + sentinel
862
88
        if (!floors[floor_number].data.t0.map[blockflag])
863
            return AVERROR(ENOMEM);
864
865
88
        map =  floors[floor_number].data.t0.map[blockflag];
866
88
        vf  = &floors[floor_number].data.t0;
867
868
51288
        for (idx = 0; idx < n; ++idx) {
869
51200
            map[idx] = floor(BARK((vf->rate * idx) / (2.0f * n)) *
870
51200
                             (vf->bark_map_size / BARK(vf->rate / 2.0f)));
871
51200
            if (vf->bark_map_size-1 < map[idx])
872
                map[idx] = vf->bark_map_size - 1;
873
        }
874
88
        map[n] = -1;
875
88
        vf->map_size[blockflag] = n;
876
    }
877
878
45144
    for (idx = 0; idx <= n; ++idx) {
879
        ff_dlog(NULL, "floor0 map: map at pos %d is %"PRId32"\n", idx, map[idx]);
880
    }
881
882
44
    return 0;
883
}
884
885
62
static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)
886
{
887
62
    GetBitContext *gb = &vc->gb;
888
    unsigned i;
889
890
62
    vc->mode_count = get_bits(gb, 6) + 1;
891
62
    vc->modes      = av_mallocz(vc->mode_count * sizeof(*vc->modes));
892
62
    if (!vc->modes)
893
        return AVERROR(ENOMEM);
894
895
    ff_dlog(NULL, " There are %d modes.\n", vc->mode_count);
896
897
186
    for (i = 0; i < vc->mode_count; ++i) {
898
124
        vorbis_mode *mode_setup = &vc->modes[i];
899
900
124
        mode_setup->blockflag     = get_bits1(gb);
901
124
        mode_setup->windowtype    = get_bits(gb, 16); //FIXME check
902
124
        mode_setup->transformtype = get_bits(gb, 16); //FIXME check
903
124
        GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);
904
905
        ff_dlog(NULL, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",
906
                i, mode_setup->blockflag, mode_setup->windowtype,
907
                mode_setup->transformtype, mode_setup->mapping);
908
    }
909
62
    return 0;
910
}
911
912
// Process the whole setup header using the functions above
913
914
62
static int vorbis_parse_setup_hdr(vorbis_context *vc)
915
{
916
62
    GetBitContext *gb = &vc->gb;
917
    int ret;
918
919

124
    if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
920

186
        (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
921
124
        (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
922
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");
923
        return AVERROR_INVALIDDATA;
924
    }
925
926
62
    if ((ret = vorbis_parse_setup_hdr_codebooks(vc))) {
927
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");
928
        return ret;
929
    }
930
62
    if ((ret = vorbis_parse_setup_hdr_tdtransforms(vc))) {
931
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");
932
        return ret;
933
    }
934
62
    if ((ret = vorbis_parse_setup_hdr_floors(vc))) {
935
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");
936
        return ret;
937
    }
938
62
    if ((ret = vorbis_parse_setup_hdr_residues(vc))) {
939
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");
940
        return ret;
941
    }
942
62
    if ((ret = vorbis_parse_setup_hdr_mappings(vc))) {
943
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");
944
        return ret;
945
    }
946
62
    if ((ret = vorbis_parse_setup_hdr_modes(vc))) {
947
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");
948
        return ret;
949
    }
950
62
    if (!get_bits1(gb)) {
951
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");
952
        return AVERROR_INVALIDDATA; // framing flag bit unset error
953
    }
954
955
62
    return 0;
956
}
957
958
// Process the identification header
959
960
62
static int vorbis_parse_id_hdr(vorbis_context *vc)
961
{
962
62
    GetBitContext *gb = &vc->gb;
963
    unsigned bl0, bl1;
964
965

124
    if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||
966

186
        (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||
967
124
        (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {
968
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");
969
        return AVERROR_INVALIDDATA;
970
    }
971
972
62
    vc->version        = get_bits_long(gb, 32);    //FIXME check 0
973
62
    vc->audio_channels = get_bits(gb, 8);
974
62
    if (vc->audio_channels <= 0) {
975
        av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
976
        return AVERROR_INVALIDDATA;
977
    }
978
62
    vc->audio_samplerate = get_bits_long(gb, 32);
979
62
    if (vc->audio_samplerate <= 0) {
980
        av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");
981
        return AVERROR_INVALIDDATA;
982
    }
983
62
    vc->bitrate_maximum = get_bits_long(gb, 32);
984
62
    vc->bitrate_nominal = get_bits_long(gb, 32);
985
62
    vc->bitrate_minimum = get_bits_long(gb, 32);
986
62
    bl0 = get_bits(gb, 4);
987
62
    bl1 = get_bits(gb, 4);
988


62
    if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {
989
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");
990
        return AVERROR_INVALIDDATA;
991
    }
992
62
    vc->blocksize[0] = (1 << bl0);
993
62
    vc->blocksize[1] = (1 << bl1);
994
62
    vc->win[0] = ff_vorbis_vwin[bl0 - 6];
995
62
    vc->win[1] = ff_vorbis_vwin[bl1 - 6];
996
997
62
    if ((get_bits1(gb)) == 0) {
998
        av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");
999
        return AVERROR_INVALIDDATA;
1000
    }
1001
1002
62
    vc->channel_residues =  av_malloc_array(vc->blocksize[1]  / 2, vc->audio_channels * sizeof(*vc->channel_residues));
1003
62
    vc->saved            =  av_mallocz_array(vc->blocksize[1] / 4, vc->audio_channels * sizeof(*vc->saved));
1004

62
    if (!vc->channel_residues || !vc->saved)
1005
        return AVERROR(ENOMEM);
1006
1007
62
    vc->previous_window  = -1;
1008
1009
62
    ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);
1010
62
    ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);
1011
62
    vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & AV_CODEC_FLAG_BITEXACT);
1012
62
    if (!vc->fdsp)
1013
        return AVERROR(ENOMEM);
1014
1015
    ff_dlog(NULL, " vorbis version %"PRIu32" \n audio_channels %"PRIu8" \n audio_samplerate %"PRIu32" \n bitrate_max %"PRIu32" \n bitrate_nom %"PRIu32" \n bitrate_min %"PRIu32" \n blk_0 %"PRIu32" blk_1 %"PRIu32" \n ",
1016
            vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
1017
1018
/*
1019
    BLK = vc->blocksize[0];
1020
    for (i = 0; i < BLK / 2; ++i) {
1021
        vc->win[0][i] = sin(0.5*3.14159265358*(sin(((float)i + 0.5) / (float)BLK*3.14159265358))*(sin(((float)i + 0.5) / (float)BLK*3.14159265358)));
1022
    }
1023
*/
1024
1025
62
    return 0;
1026
}
1027
1028
// Process the extradata using the functions above (identification header, setup header)
1029
1030
62
static av_cold int vorbis_decode_init(AVCodecContext *avctx)
1031
{
1032
62
    vorbis_context *vc = avctx->priv_data;
1033
62
    uint8_t *headers   = avctx->extradata;
1034
62
    int headers_len    = avctx->extradata_size;
1035
    const uint8_t *header_start[3];
1036
    int header_len[3];
1037
62
    GetBitContext *gb = &vc->gb;
1038
    int hdr_type, ret;
1039
1040
62
    vc->avctx = avctx;
1041
62
    ff_vorbisdsp_init(&vc->dsp);
1042
1043
62
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1044
1045
62
    if (!headers_len) {
1046
        av_log(avctx, AV_LOG_ERROR, "Extradata missing.\n");
1047
        return AVERROR_INVALIDDATA;
1048
    }
1049
1050
62
    if ((ret = avpriv_split_xiph_headers(headers, headers_len, 30, header_start, header_len)) < 0) {
1051
        av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");
1052
        return ret;
1053
    }
1054
1055
62
    init_get_bits(gb, header_start[0], header_len[0]*8);
1056
62
    hdr_type = get_bits(gb, 8);
1057
62
    if (hdr_type != 1) {
1058
        av_log(avctx, AV_LOG_ERROR, "First header is not the id header.\n");
1059
        return AVERROR_INVALIDDATA;
1060
    }
1061
62
    if ((ret = vorbis_parse_id_hdr(vc))) {
1062
        av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1063
        vorbis_free(vc);
1064
        return ret;
1065
    }
1066
1067
62
    init_get_bits(gb, header_start[2], header_len[2]*8);
1068
62
    hdr_type = get_bits(gb, 8);
1069
62
    if (hdr_type != 5) {
1070
        av_log(avctx, AV_LOG_ERROR, "Third header is not the setup header.\n");
1071
        vorbis_free(vc);
1072
        return AVERROR_INVALIDDATA;
1073
    }
1074
62
    if ((ret = vorbis_parse_setup_hdr(vc))) {
1075
        av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1076
        vorbis_free(vc);
1077
        return ret;
1078
    }
1079
1080
62
    if (vc->audio_channels > 8)
1081
        avctx->channel_layout = 0;
1082
    else
1083
62
        avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
1084
1085
62
    avctx->channels    = vc->audio_channels;
1086
62
    avctx->sample_rate = vc->audio_samplerate;
1087
1088
62
    return 0;
1089
}
1090
1091
// Decode audiopackets -------------------------------------------------
1092
1093
// Read and decode floor
1094
1095
6352
static int vorbis_floor0_decode(vorbis_context *vc,
1096
                                vorbis_floor_data *vfu, float *vec)
1097
{
1098
6352
    vorbis_floor0 *vf = &vfu->t0;
1099
6352
    float *lsp = vf->lsp;
1100
    unsigned book_idx;
1101
    uint64_t amplitude;
1102
6352
    unsigned blockflag = vc->modes[vc->mode_number].blockflag;
1103
1104
6352
    if (!vf->amplitude_bits)
1105
        return 1;
1106
1107
6352
    amplitude = get_bits64(&vc->gb, vf->amplitude_bits);
1108
6352
    if (amplitude > 0) {
1109
6241
        float last = 0;
1110
6241
        unsigned idx, lsp_len = 0;
1111
        vorbis_codebook codebook;
1112
1113
6241
        book_idx = get_bits(&vc->gb, ilog(vf->num_books));
1114
6241
        if (book_idx >= vf->num_books) {
1115
            av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");
1116
            book_idx =  0;
1117
        }
1118
        ff_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);
1119
6241
        codebook = vc->codebooks[vf->book_list[book_idx]];
1120
        /* Invalid codebook! */
1121
6241
        if (!codebook.codevectors)
1122
            return AVERROR_INVALIDDATA;
1123
1124
56551
        while (lsp_len<vf->order) {
1125
            int vec_off;
1126
1127
            ff_dlog(NULL, "floor0 dec: book dimension: %d\n", codebook.dimensions);
1128
            ff_dlog(NULL, "floor0 dec: maximum depth: %d\n", codebook.maxdepth);
1129
            /* read temp vector */
1130
50310
            vec_off = get_vlc2(&vc->gb, codebook.vlc.table,
1131
50310
                               codebook.nb_bits, codebook.maxdepth);
1132
50310
            if (vec_off < 0)
1133
                return AVERROR_INVALIDDATA;
1134
50310
            vec_off *= codebook.dimensions;
1135
            ff_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);
1136
            /* copy each vector component and add last to it */
1137
195768
            for (idx = 0; idx < codebook.dimensions; ++idx)
1138
145458
                lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;
1139
50310
            last = lsp[lsp_len+idx-1]; /* set last to last vector component */
1140
1141
50310
            lsp_len += codebook.dimensions;
1142
        }
1143
        /* DEBUG: output lsp coeffs */
1144
        {
1145
            int idx;
1146
151699
            for (idx = 0; idx < lsp_len; ++idx)
1147
                ff_dlog(NULL, "floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);
1148
        }
1149
1150
        /* synthesize floor output vector */
1151
        {
1152
            int i;
1153
6241
            int order = vf->order;
1154
6241
            float wstep = M_PI / vf->bark_map_size;
1155
1156
151699
            for (i = 0; i < order; i++)
1157
145458
                lsp[i] = 2.0f * cos(lsp[i]);
1158
1159
            ff_dlog(NULL, "floor0 synth: map_size = %"PRIu32"; m = %d; wstep = %f\n",
1160
                    vf->map_size[blockflag], order, wstep);
1161
1162
6241
            i = 0;
1163
944889
            while (i < vf->map_size[blockflag]) {
1164
938648
                int j, iter_cond = vf->map[blockflag][i];
1165
938648
                float p = 0.5f;
1166
938648
                float q = 0.5f;
1167
938648
                float two_cos_w = 2.0f * cos(wstep * iter_cond); // needed all times
1168
1169
                /* similar part for the q and p products */
1170
14104804
                for (j = 0; j + 1 < order; j += 2) {
1171
13166156
                    q *= lsp[j]     - two_cos_w;
1172
13166156
                    p *= lsp[j + 1] - two_cos_w;
1173
                }
1174
938648
                if (j == order) { // even order
1175
925080
                    p *= p * (2.0f - two_cos_w);
1176
925080
                    q *= q * (2.0f + two_cos_w);
1177
                } else { // odd order
1178
13568
                    q *= two_cos_w-lsp[j]; // one more time for q
1179
1180
                    /* final step and square */
1181
13568
                    p *= p * (4.f - two_cos_w * two_cos_w);
1182
13568
                    q *= q;
1183
                }
1184
1185
938648
                if (p + q == 0.0)
1186
                    return AVERROR_INVALIDDATA;
1187
1188
                /* calculate linear floor value */
1189
938648
                q = exp((((amplitude*vf->amplitude_offset) /
1190
938648
                          (((1ULL << vf->amplitude_bits) - 1) * sqrt(p + q)))
1191
938648
                         - vf->amplitude_offset) * .11512925f);
1192
1193
                /* fill vector */
1194
                do {
1195
4382464
                    vec[i] = q; ++i;
1196
4382464
                } while (vf->map[blockflag][i] == iter_cond);
1197
            }
1198
        }
1199
    } else {
1200
        /* this channel is unused */
1201
111
        return 1;
1202
    }
1203
1204
    ff_dlog(NULL, " Floor0 decoded\n");
1205
1206
6241
    return 0;
1207
}
1208
1209
11420
static int vorbis_floor1_decode(vorbis_context *vc,
1210
                                vorbis_floor_data *vfu, float *vec)
1211
{
1212
11420
    vorbis_floor1 *vf = &vfu->t1;
1213
11420
    GetBitContext *gb = &vc->gb;
1214
11420
    uint16_t range_v[4] = { 256, 128, 86, 64 };
1215
11420
    unsigned range = range_v[vf->multiplier - 1];
1216
    uint16_t floor1_Y[258];
1217
    uint16_t floor1_Y_final[258];
1218
    int floor1_flag[258];
1219
    unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;
1220
    int book, adx, ady, dy, off, predicted, err;
1221
1222
1223
11420
    if (!get_bits1(gb)) // silence
1224
1987
        return 1;
1225
1226
// Read values (or differences) for the floor's points
1227
1228
9433
    floor1_Y[0] = get_bits(gb, ilog(range - 1));
1229
9433
    floor1_Y[1] = get_bits(gb, ilog(range - 1));
1230
1231
    ff_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);
1232
1233
9433
    offset = 2;
1234
78107
    for (i = 0; i < vf->partitions; ++i) {
1235
68674
        partition_class = vf->partition_class[i];
1236
68674
        cdim   = vf->class_dimensions[partition_class];
1237
68674
        cbits  = vf->class_subclasses[partition_class];
1238
68674
        csub = (1 << cbits) - 1;
1239
68674
        cval = 0;
1240
1241
        ff_dlog(NULL, "Cbits %u\n", cbits);
1242
1243
68674
        if (cbits) // this reads all subclasses for this partition's class
1244
62770
            cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,
1245
62770
                            vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);
1246
1247
284750
        for (j = 0; j < cdim; ++j) {
1248
216076
            book = vf->subclass_books[partition_class][cval & csub];
1249
1250
            ff_dlog(NULL, "book %d Cbits %u cval %u  bits:%d\n",
1251
                    book, cbits, cval, get_bits_count(gb));
1252
1253
216076
            cval = cval >> cbits;
1254
216076
            if (book > -1) {
1255
113688
                int v = get_vlc2(gb, vc->codebooks[book].vlc.table,
1256
113688
                                 vc->codebooks[book].nb_bits, 3);
1257
113688
                if (v < 0)
1258
                    return AVERROR_INVALIDDATA;
1259
113688
                floor1_Y[offset+j] = v;
1260
            } else {
1261
102388
                floor1_Y[offset+j] = 0;
1262
            }
1263
1264
            ff_dlog(NULL, " floor(%d) = %d \n",
1265
                    vf->list[offset+j].x, floor1_Y[offset+j]);
1266
        }
1267
68674
        offset+=cdim;
1268
    }
1269
1270
// Amplitude calculation from the differences
1271
1272
9433
    floor1_flag[0] = 1;
1273
9433
    floor1_flag[1] = 1;
1274
9433
    floor1_Y_final[0] = floor1_Y[0];
1275
9433
    floor1_Y_final[1] = floor1_Y[1];
1276
1277
225509
    for (i = 2; i < vf->x_list_dim; ++i) {
1278
        unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;
1279
1280
216076
        low_neigh_offs  = vf->list[i].low;
1281
216076
        high_neigh_offs = vf->list[i].high;
1282
216076
        dy  = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs];  // render_point begin
1283
216076
        adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;
1284
216076
        ady = FFABS(dy);
1285
216076
        err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);
1286
216076
        off = err / adx;
1287
216076
        if (dy < 0) {
1288
119376
            predicted = floor1_Y_final[low_neigh_offs] - off;
1289
        } else {
1290
96700
            predicted = floor1_Y_final[low_neigh_offs] + off;
1291
        } // render_point end
1292
1293
216076
        val = floor1_Y[i];
1294
216076
        highroom = range-predicted;
1295
216076
        lowroom  = predicted;
1296
216076
        if (highroom < lowroom) {
1297
87946
            room = highroom * 2;
1298
        } else {
1299
128130
            room = lowroom * 2;   // SPEC misspelling
1300
        }
1301
216076
        if (val) {
1302
97796
            floor1_flag[low_neigh_offs]  = 1;
1303
97796
            floor1_flag[high_neigh_offs] = 1;
1304
97796
            floor1_flag[i]               = 1;
1305
97796
            if (val >= room) {
1306
102
                if (highroom > lowroom) {
1307
74
                    floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);
1308
                } else {
1309
28
                    floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);
1310
                }
1311
            } else {
1312
97694
                if (val & 1) {
1313
63405
                    floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);
1314
                } else {
1315
34289
                    floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);
1316
                }
1317
            }
1318
        } else {
1319
118280
            floor1_flag[i]    = 0;
1320
118280
            floor1_Y_final[i] = av_clip_uint16(predicted);
1321
        }
1322
1323
        ff_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",
1324
                vf->list[i].x, floor1_Y_final[i], val);
1325
    }
1326
1327
// Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?
1328
1329
9433
    ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);
1330
1331
    ff_dlog(NULL, " Floor decoded\n");
1332
1333
9433
    return 0;
1334
}
1335
1336
134366
static av_always_inline int setup_classifs(vorbis_context *vc,
1337
                                           vorbis_residue *vr,
1338
                                           uint8_t *do_not_decode,
1339
                                           unsigned ch_used,
1340
                                           int partition_count,
1341
                                           int ptns_to_read
1342
                                          )
1343
{
1344
134366
    vorbis_codebook *codebook = vc->codebooks + vr->classbook;
1345
    int p, j, i;
1346
134366
    unsigned c_p_c         = codebook->dimensions;
1347
134366
    unsigned inverse_class = ff_inverse[vr->classifications];
1348
    int temp, temp2;
1349
297962
    for (p = 0, j = 0; j < ch_used; ++j) {
1350
163596
        if (!do_not_decode[j]) {
1351
162302
            temp = get_vlc2(&vc->gb, codebook->vlc.table,
1352
162302
                                     codebook->nb_bits, 3);
1353
1354
            ff_dlog(NULL, "Classword: %u\n", temp);
1355
1356
162302
            av_assert0(temp < 65536);
1357
1358
162302
            if (temp < 0) {
1359
                av_log(vc->avctx, AV_LOG_ERROR,
1360
                       "Invalid vlc code decoding %d channel.", j);
1361
                return AVERROR_INVALIDDATA;
1362
            }
1363
1364
162302
            if (vr->classifications == 1) {
1365
                for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1366
                    if (i < ptns_to_read)
1367
                        vr->classifs[p + i] = 0;
1368
                }
1369
            } else {
1370
505997
            for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {
1371
343695
                temp2 = (((uint64_t)temp) * inverse_class) >> 32;
1372
1373
343695
                if (i < ptns_to_read)
1374
343488
                    vr->classifs[p + i] = temp - temp2 * vr->classifications;
1375
343695
                temp = temp2;
1376
            }
1377
            }
1378
        }
1379
163596
        p += ptns_to_read;
1380
    }
1381
134366
    return 0;
1382
}
1383
// Read and decode residue
1384
1385
9458
static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,
1386
                                                           vorbis_residue *vr,
1387
                                                           unsigned ch,
1388
                                                           uint8_t *do_not_decode,
1389
                                                           float *vec,
1390
                                                           unsigned vlen,
1391
                                                           unsigned ch_left,
1392
                                                           int vr_type)
1393
{
1394
9458
    GetBitContext *gb = &vc->gb;
1395
9458
    unsigned c_p_c        = vc->codebooks[vr->classbook].dimensions;
1396
9458
    uint8_t *classifs = vr->classifs;
1397
    unsigned pass, ch_used, i, j, k, l;
1398
9458
    unsigned max_output = (ch - 1) * vlen;
1399
9458
    int ptns_to_read = vr->ptns_to_read;
1400
9458
    int libvorbis_bug = 0;
1401
1402
9458
    if (vr_type == 2) {
1403
9630
        for (j = 1; j < ch; ++j)
1404
5370
            do_not_decode[0] &= do_not_decode[j];  // FIXME - clobbering input
1405
4260
        if (do_not_decode[0])
1406
117
            return 0;
1407
4143
        ch_used = 1;
1408
4143
        max_output += vr->end / ch;
1409
    } else {
1410
5198
        ch_used = ch;
1411
5198
        max_output += vr->end;
1412
    }
1413
1414
9341
    if (max_output > ch_left * vlen) {
1415
        if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {
1416
            ptns_to_read--;
1417
            libvorbis_bug = 1;
1418
        } else {
1419
            av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");
1420
            return AVERROR_INVALIDDATA;
1421
        }
1422
    }
1423
1424
    ff_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d  cpc %d  \n", ch, c_p_c);
1425
1426
30866
    for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?
1427
        int voffset, partition_count, j_times_ptns_to_read;
1428
1429
21525
        voffset = vr->begin;
1430
370645
        for (partition_count = 0; partition_count < ptns_to_read;) {  // SPEC        error
1431
349120
            if (!pass) {
1432
134366
                int ret = setup_classifs(vc, vr, do_not_decode, ch_used, partition_count, ptns_to_read);
1433
134366
                if (ret < 0)
1434
                    return ret;
1435
            }
1436

1082914
            for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {
1437
1530064
                for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {
1438
                    unsigned voffs;
1439
1440
796270
                    if (!do_not_decode[j]) {
1441
792332
                        unsigned vqclass = classifs[j_times_ptns_to_read + partition_count];
1442
792332
                        int vqbook  = vr->books[vqclass][pass];
1443
1444

792332
                        if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {
1445
                            int coffs;
1446
321319
                            unsigned dim  = vc->codebooks[vqbook].dimensions;
1447
321319
                            unsigned step = FASTDIV(vr->partition_size << 1, dim << 1);
1448
321319
                            vorbis_codebook codebook = vc->codebooks[vqbook];
1449
1450
321319
                            if (vr_type == 0) {
1451
1452
115024
                                voffs = voffset+j*vlen;
1453
1357436
                                for (k = 0; k < step; ++k) {
1454
1242412
                                    coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1455
1242412
                                    if (coffs < 0)
1456
                                        return coffs;
1457
1242412
                                    coffs *= dim;
1458
4777020
                                    for (l = 0; l < dim; ++l)
1459
3534608
                                        vec[voffs + k + l * step] += codebook.codevectors[coffs + l];
1460
                                }
1461
206295
                            } else if (vr_type == 1) {
1462
27632
                                voffs = voffset + j * vlen;
1463
313498
                                for (k = 0; k < step; ++k) {
1464
285866
                                    coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1465
285866
                                    if (coffs < 0)
1466
                                        return coffs;
1467
285866
                                    coffs *= dim;
1468
1073374
                                    for (l = 0; l < dim; ++l, ++voffs) {
1469
787508
                                        vec[voffs]+=codebook.codevectors[coffs+l];
1470
1471
                                        ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d  \n",
1472
                                                pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);
1473
                                    }
1474
                                }
1475


178663
                            } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized
1476
150956
                                voffs = voffset >> 1;
1477
1478
150956
                                if (dim == 2) {
1479
1066456
                                    for (k = 0; k < step; ++k) {
1480
1002098
                                        coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1481
1002098
                                        if (coffs < 0)
1482
                                            return coffs;
1483
1002098
                                        coffs *= 2;
1484
1002098
                                        vec[voffs + k       ] += codebook.codevectors[coffs    ];
1485
1002098
                                        vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];
1486
                                    }
1487
86598
                                } else if (dim == 4) {
1488
509671
                                    for (k = 0; k < step; ++k, voffs += 2) {
1489
446670
                                        coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1490
446670
                                        if (coffs < 0)
1491
                                            return coffs;
1492
446670
                                        coffs *= 4;
1493
446670
                                        vec[voffs           ] += codebook.codevectors[coffs    ];
1494
446670
                                        vec[voffs + 1       ] += codebook.codevectors[coffs + 2];
1495
446670
                                        vec[voffs + vlen    ] += codebook.codevectors[coffs + 1];
1496
446670
                                        vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];
1497
                                    }
1498
                                } else
1499
117641
                                for (k = 0; k < step; ++k) {
1500
94044
                                    coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1501
94044
                                    if (coffs < 0)
1502
                                        return coffs;
1503
94044
                                    coffs *= dim;
1504
470220
                                    for (l = 0; l < dim; l += 2, voffs++) {
1505
376176
                                        vec[voffs       ] += codebook.codevectors[coffs + l    ];
1506
376176
                                        vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];
1507
1508
                                        ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n",
1509
                                                pass, voffset / ch + (voffs % ch) * vlen,
1510
                                                vec[voffset / ch + (voffs % ch) * vlen],
1511
                                                codebook.codevectors[coffs + l], coffs, l);
1512
                                    }
1513
                                }
1514
1515
27707
                            } else if (vr_type == 2) {
1516
27707
                                unsigned voffs_div = ch == 1 ? voffset : FASTDIV(voffset, ch);
1517
27707
                                unsigned voffs_mod = voffset - voffs_div * ch;
1518
1519
191750
                                for (k = 0; k < step; ++k) {
1520
164043
                                    coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3);
1521
164043
                                    if (coffs < 0)
1522
                                        return coffs;
1523
164043
                                    coffs *= dim;
1524
912258
                                    for (l = 0; l < dim; ++l) {
1525
748215
                                        vec[voffs_div + voffs_mod * vlen] +=
1526
748215
                                            codebook.codevectors[coffs + l];
1527
1528
                                        ff_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d  \n",
1529
                                                pass, voffs_div + voffs_mod * vlen,
1530
                                                vec[voffs_div + voffs_mod * vlen],
1531
                                                codebook.codevectors[coffs + l], coffs, l);
1532
1533
748215
                                        if (++voffs_mod == ch) {
1534
149643
                                            voffs_div++;
1535
149643
                                            voffs_mod = 0;
1536
                                        }
1537
                                    }
1538
                                }
1539
                            }
1540
                        }
1541
                    }
1542
796270
                    j_times_ptns_to_read += ptns_to_read;
1543
                }
1544
733794
                ++partition_count;
1545
733794
                voffset += vr->partition_size;
1546
            }
1547
        }
1548

21525
        if (libvorbis_bug && !pass) {
1549
            for (j = 0; j < ch_used; ++j) {
1550
                if (!do_not_decode[j]) {
1551
                    get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,
1552
                                vc->codebooks[vr->classbook].nb_bits, 3);
1553
                }
1554
            }
1555
        }
1556
    }
1557
9341
    return 0;
1558
}
1559
1560
9458
static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,
1561
                                        unsigned ch,
1562
                                        uint8_t *do_not_decode,
1563
                                        float *vec, unsigned vlen,
1564
                                        unsigned ch_left)
1565
{
1566
9458
    if (vr->type == 2)
1567
4260
        return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);
1568
5198
    else if (vr->type == 1)
1569
1790
        return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);
1570
3408
    else if (vr->type == 0)
1571
3408
        return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);
1572
    else {
1573
        av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");
1574
        return AVERROR_INVALIDDATA;
1575
    }
1576
}
1577
1578
5370
void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)
1579
{
1580
    int i;
1581
4053626
    for (i = 0;  i < blocksize;  i++) {
1582
4048256
        if (mag[i] > 0.0) {
1583
625193
            if (ang[i] > 0.0) {
1584
156334
                ang[i] = mag[i] - ang[i];
1585
            } else {
1586
468859
                float temp = ang[i];
1587
468859
                ang[i]     = mag[i];
1588
468859
                mag[i]    += temp;
1589
            }
1590
        } else {
1591
3423063
            if (ang[i] > 0.0) {
1592
160284
                ang[i] += mag[i];
1593
            } else {
1594
3262779
                float temp = ang[i];
1595
3262779
                ang[i]     = mag[i];
1596
3262779
                mag[i]    -= temp;
1597
            }
1598
        }
1599
    }
1600
5370
}
1601
1602
// Decode the audio packet using the functions above
1603
1604
9088
static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)
1605
{
1606
9088
    GetBitContext *gb = &vc->gb;
1607
    FFTContext *mdct;
1608
9088
    int previous_window = vc->previous_window;
1609
    unsigned mode_number, blockflag, blocksize;
1610
    int i, j;
1611
    uint8_t no_residue[255];
1612
    uint8_t do_not_decode[255];
1613
    vorbis_mapping *mapping;
1614
9088
    float *ch_res_ptr   = vc->channel_residues;
1615
    uint8_t res_chan[255];
1616
9088
    unsigned res_num = 0;
1617
9088
    int retlen  = 0;
1618
9088
    unsigned ch_left = vc->audio_channels;
1619
    unsigned vlen;
1620
1621
9088
    if (get_bits1(gb)) {
1622
        av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");
1623
        return AVERROR_INVALIDDATA; // packet type not audio
1624
    }
1625
1626
9088
    if (vc->mode_count == 1) {
1627
        mode_number = 0;
1628
    } else {
1629
9088
        GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)
1630
    }
1631
9088
    vc->mode_number = mode_number;
1632
9088
    mapping = &vc->mappings[vc->modes[mode_number].mapping];
1633
1634
    ff_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,
1635
            vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);
1636
1637
9088
    blockflag = vc->modes[mode_number].blockflag;
1638
9088
    blocksize = vc->blocksize[blockflag];
1639
9088
    vlen = blocksize / 2;
1640
9088
    if (blockflag) {
1641
5972
        int code = get_bits(gb, 2);
1642
5972
        if (previous_window < 0)
1643
1
            previous_window = code>>1;
1644
3116
    } else if (previous_window < 0)
1645
20
        previous_window = 0;
1646
1647
9088
    memset(ch_res_ptr,   0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?
1648
26860
    for (i = 0; i < vc->audio_channels; ++i)
1649
17772
        memset(floor_ptr[i], 0, vlen * sizeof(floor_ptr[0][0])); //FIXME can this be removed ?
1650
1651
// Decode floor
1652
1653
26860
    for (i = 0; i < vc->audio_channels; ++i) {
1654
        vorbis_floor *floor;
1655
        int ret;
1656
17772
        if (mapping->submaps > 1) {
1657
2220
            floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];
1658
        } else {
1659
15552
            floor = &vc->floors[mapping->submap_floor[0]];
1660
        }
1661
1662
17772
        ret = floor->decode(vc, &floor->data, floor_ptr[i]);
1663
1664
17772
        if (ret < 0) {
1665
            av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");
1666
            return AVERROR_INVALIDDATA;
1667
        }
1668
17772
        no_residue[i] = ret;
1669
    }
1670
1671
// Nonzero vector propagate
1672
1673
14458
    for (i = mapping->coupling_steps - 1; i >= 0; --i) {
1674
5370
        if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {
1675
4717
            no_residue[mapping->magnitude[i]] = 0;
1676
4717
            no_residue[mapping->angle[i]]     = 0;
1677
        }
1678
    }
1679
1680
// Decode residue
1681
1682
18546
    for (i = 0; i < mapping->submaps; ++i) {
1683
        vorbis_residue *residue;
1684
9458
        unsigned ch = 0;
1685
        int ret;
1686
1687
29450
        for (j = 0; j < vc->audio_channels; ++j) {
1688

19992
            if ((mapping->submaps == 1) || (i == mapping->mux[j])) {
1689
17772
                res_chan[j] = res_num;
1690
17772
                if (no_residue[j]) {
1691
1206
                    do_not_decode[ch] = 1;
1692
                } else {
1693
16566
                    do_not_decode[ch] = 0;
1694
                }
1695
17772
                ++ch;
1696
17772
                ++res_num;
1697
            }
1698
        }
1699
9458
        residue = &vc->residues[mapping->submap_residue[i]];
1700
9458
        if (ch_left < ch) {
1701
            av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");
1702
            return AVERROR_INVALIDDATA;
1703
        }
1704
9458
        if (ch) {
1705
9458
            ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);
1706
9458
            if (ret < 0)
1707
                return ret;
1708
        }
1709
1710
9458
        ch_res_ptr += ch * vlen;
1711
9458
        ch_left -= ch;
1712
    }
1713
1714
9088
    if (ch_left > 0)
1715
        return AVERROR_INVALIDDATA;
1716
1717
// Inverse coupling
1718
1719
14458
    for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed
1720
        float *mag, *ang;
1721
1722
5370
        mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;
1723
5370
        ang = vc->channel_residues+res_chan[mapping->angle[i]]     * blocksize / 2;
1724
5370
        vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);
1725
    }
1726
1727
// Dotproduct, MDCT
1728
1729
9088
    mdct = &vc->mdct[blockflag];
1730
1731
26860
    for (j = vc->audio_channels-1;j >= 0; j--) {
1732
17772
        ch_res_ptr   = vc->channel_residues + res_chan[j] * blocksize / 2;
1733
17772
        vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);
1734
17772
        mdct->imdct_half(mdct, ch_res_ptr, floor_ptr[j]);
1735
    }
1736
1737
// Overlap/add, save data for next overlapping
1738
1739
9088
    retlen = (blocksize + vc->blocksize[previous_window]) / 4;
1740
26860
    for (j = 0; j < vc->audio_channels; j++) {
1741
17772
        unsigned bs0 = vc->blocksize[0];
1742
17772
        unsigned bs1 = vc->blocksize[1];
1743
17772
        float *residue    = vc->channel_residues + res_chan[j] * blocksize / 2;
1744
17772
        float *saved      = vc->saved + j * bs1 / 4;
1745
17772
        float *ret        = floor_ptr[j];
1746
17772
        float *buf        = residue;
1747
17772
        const float *win  = vc->win[blockflag & previous_window];
1748
1749
17772
        if (blockflag == previous_window) {
1750
16341
            vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);
1751
1431
        } else if (blockflag > previous_window) {
1752
735
            vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);
1753
735
            memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) * sizeof(float));
1754
        } else {
1755
696
            memcpy(ret, saved, ((bs1 - bs0) / 4) * sizeof(float));
1756
696
            vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);
1757
        }
1758
17772
        memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));
1759
    }
1760
1761
9088
    vc->previous_window = blockflag;
1762
9088
    return retlen;
1763
}
1764
1765
// Return the decoded audio packet through the standard api
1766
1767
9088
static int vorbis_decode_frame(AVCodecContext *avctx, void *data,
1768
                               int *got_frame_ptr, AVPacket *avpkt)
1769
{
1770
9088
    const uint8_t *buf = avpkt->data;
1771
9088
    int buf_size       = avpkt->size;
1772
9088
    vorbis_context *vc = avctx->priv_data;
1773
9088
    AVFrame *frame     = data;
1774
9088
    GetBitContext *gb = &vc->gb;
1775
    float *channel_ptrs[255];
1776
    int i, len, ret;
1777
1778
    ff_dlog(NULL, "packet length %d \n", buf_size);
1779
1780

9088
    if (*buf == 1 && buf_size > 7) {
1781
        if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1782
            return ret;
1783
1784
        vorbis_free(vc);
1785
        if ((ret = vorbis_parse_id_hdr(vc))) {
1786
            av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");
1787
            vorbis_free(vc);
1788
            return ret;
1789
        }
1790
1791
        if (vc->audio_channels > 8)
1792
            avctx->channel_layout = 0;
1793
        else
1794
            avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];
1795
1796
        avctx->channels    = vc->audio_channels;
1797
        avctx->sample_rate = vc->audio_samplerate;
1798
        return buf_size;
1799
    }
1800
1801

9088
    if (*buf == 3 && buf_size > 7) {
1802
        av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");
1803
        return buf_size;
1804
    }
1805
1806


9088
    if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {
1807
        if ((ret = init_get_bits8(gb, buf + 1, buf_size - 1)) < 0)
1808
            return ret;
1809
1810
        if ((ret = vorbis_parse_setup_hdr(vc))) {
1811
            av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");
1812
            vorbis_free(vc);
1813
            return ret;
1814
        }
1815
        return buf_size;
1816
    }
1817
1818

9088
    if (!vc->channel_residues || !vc->modes) {
1819
        av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");
1820
        return AVERROR_INVALIDDATA;
1821
    }
1822
1823
    /* get output buffer */
1824
9088
    frame->nb_samples = vc->blocksize[1] / 2;
1825
9088
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1826
        return ret;
1827
1828
9088
    if (vc->audio_channels > 8) {
1829
        for (i = 0; i < vc->audio_channels; i++)
1830
            channel_ptrs[i] = (float *)frame->extended_data[i];
1831
    } else {
1832
26860
        for (i = 0; i < vc->audio_channels; i++) {
1833
17772
            int ch = ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];
1834
17772
            channel_ptrs[ch] = (float *)frame->extended_data[i];
1835
        }
1836
    }
1837
1838
9088
    if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
1839
        return ret;
1840
1841
9088
    if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)
1842
        return len;
1843
1844
9088
    if (!vc->first_frame) {
1845
21
        vc->first_frame = 1;
1846
21
        *got_frame_ptr = 0;
1847
21
        av_frame_unref(frame);
1848
21
        return buf_size;
1849
    }
1850
1851
    ff_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
1852
            get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
1853
1854
9067
    frame->nb_samples = len;
1855
9067
    *got_frame_ptr    = 1;
1856
1857
9067
    return buf_size;
1858
}
1859
1860
// Close decoder
1861
1862
62
static av_cold int vorbis_decode_close(AVCodecContext *avctx)
1863
{
1864
62
    vorbis_context *vc = avctx->priv_data;
1865
1866
62
    vorbis_free(vc);
1867
1868
62
    return 0;
1869
}
1870
1871
static av_cold void vorbis_decode_flush(AVCodecContext *avctx)
1872
{
1873
    vorbis_context *vc = avctx->priv_data;
1874
1875
    if (vc->saved) {
1876
        memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *
1877
                             sizeof(*vc->saved));
1878
    }
1879
    vc->previous_window = -1;
1880
    vc->first_frame = 0;
1881
}
1882
1883
AVCodec ff_vorbis_decoder = {
1884
    .name            = "vorbis",
1885
    .long_name       = NULL_IF_CONFIG_SMALL("Vorbis"),
1886
    .type            = AVMEDIA_TYPE_AUDIO,
1887
    .id              = AV_CODEC_ID_VORBIS,
1888
    .priv_data_size  = sizeof(vorbis_context),
1889
    .init            = vorbis_decode_init,
1890
    .close           = vorbis_decode_close,
1891
    .decode          = vorbis_decode_frame,
1892
    .flush           = vorbis_decode_flush,
1893
    .capabilities    = AV_CODEC_CAP_DR1,
1894
    .caps_internal   = FF_CODEC_CAP_INIT_CLEANUP,
1895
    .channel_layouts = ff_vorbis_channel_layouts,
1896
    .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1897
                                                       AV_SAMPLE_FMT_NONE },
1898
};