← Back to branch summary

~siretart/xine-lib/ubuntu

« back to all changes in this revision

Viewing changes to src/libfaad/sbr_syntax.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2005-12-15 13:13:45 UTC
  • mfrom: (0.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051215131345-8n4osv1j7fy9c1s1
* SECURITY UPDATE: Fix arbitrary code execution with crafted PNG images in
  embedded ffmpeg copy.
* src/libffmpeg/libavcodec/utils.c, avcodec_default_get_buffer(): Apply
  upstream patch to fix buffer overflow on decoding of small PIX_FMT_PAL8
  PNG files.
* References:
  CVE-2005-4048
  http://mplayerhq.hu/pipermail/ffmpeg-devel/2005-November/005333.html
  http://www1.mplayerhq.hu/cgi-bin/cvsweb.cgi/ffmpeg/libavcodec/
  utils.c.diff?r1=1.161&r2=1.162&cvsroot=FFMpeg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libfaad/sbr_syntax.c
22
22
** Commercial non-GPL licensing of this software is possible.
23
23
** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
24
24
**
25
 
** $Id: sbr_syntax.c,v 1.6 2004/12/03 01:15:30 tmattern Exp $
 
25
** $Id: sbr_syntax.c,v 1.7 2005/10/29 23:57:07 tmmm Exp $
26
26
**/
27
27
 
28
28
#include "common.h"
47
47
 
48
48
/* static function declarations */
49
49
static void sbr_header(bitfile *ld, sbr_info *sbr);
 
50
static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
 
51
                               uint8_t samplerate_mode, uint8_t freq_scale,
 
52
                               uint8_t alter_scale, uint8_t xover_band);
50
53
static uint8_t sbr_data(bitfile *ld, sbr_info *sbr);
51
54
static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
52
55
                              uint8_t bs_extension_id, uint16_t num_bits_left);
73
76
    if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
74
77
        (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
75
78
        (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
76
 
        (sbr->bs_alter_scale != sbr->bs_alter_scale_prev))
77
 
    {
78
 
        sbr->Reset = 1;
79
 
    } else {
80
 
        sbr->Reset = 0;
81
 
    }
82
 
 
83
 
    if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
84
 
        (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
85
 
        (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
86
79
        (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
87
80
        (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
88
81
        (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
98
91
    sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
99
92
    sbr->bs_xover_band_prev = sbr->bs_xover_band;
100
93
    sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
101
 
 
102
 
    if (sbr->frame == 0)
103
 
    {
104
 
        sbr->Reset = 1;
105
 
    }
 
94
}
 
95
 
 
96
static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
 
97
                               uint8_t samplerate_mode, uint8_t freq_scale,
 
98
                               uint8_t alter_scale, uint8_t xover_band)
 
99
{
 
100
    uint8_t result = 0;
 
101
    uint8_t k2;
 
102
 
 
103
    /* calculate the Master Frequency Table */
 
104
    sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate);
 
105
    k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0);
 
106
 
 
107
    /* check k0 and k2 */
 
108
    if (sbr->sample_rate >= 48000)
 
109
    {
 
110
        if ((k2 - sbr->k0) > 32)
 
111
            result += 1;
 
112
    } else if (sbr->sample_rate <= 32000) {
 
113
        if ((k2 - sbr->k0) > 48)
 
114
            result += 1;
 
115
    } else { /* (sbr->sample_rate == 44100) */
 
116
        if ((k2 - sbr->k0) > 45)
 
117
            result += 1;
 
118
    }
 
119
 
 
120
    if (freq_scale == 0)
 
121
    {
 
122
        result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale);
 
123
    } else {
 
124
        result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale);
 
125
    }
 
126
    result += derived_frequency_table(sbr, xover_band, k2);
 
127
 
 
128
    result = (result > 0) ? 1 : 0;
 
129
 
 
130
    return result;
106
131
}
107
132
 
108
133
/* table 2 */
112
137
    uint16_t num_align_bits = 0;
113
138
    uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld);
114
139
 
 
140
    uint8_t saved_start_freq, saved_samplerate_mode;
 
141
    uint8_t saved_stop_freq, saved_freq_scale;
 
142
    uint8_t saved_alter_scale, saved_xover_band;
 
143
 
115
144
#ifdef DRM
116
145
    if (!sbr->Is_DRM_SBR)
117
146
#endif
126
155
        }
127
156
    }
128
157
 
 
158
    /* save old header values, in case the new ones are corrupted */
 
159
    saved_start_freq = sbr->bs_start_freq;
 
160
    saved_samplerate_mode = sbr->bs_samplerate_mode;
 
161
    saved_stop_freq = sbr->bs_stop_freq;
 
162
    saved_freq_scale = sbr->bs_freq_scale;
 
163
    saved_alter_scale = sbr->bs_alter_scale;
 
164
    saved_xover_band = sbr->bs_xover_band;
 
165
 
129
166
    sbr->bs_header_flag = faad_get1bit(ld
130
167
        DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
131
168
 
141
178
    {
142
179
        if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
143
180
        {
144
 
            uint8_t k2;
145
 
 
146
 
            /* calculate the Master Frequency Table */
147
 
            sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode,
148
 
                sbr->sample_rate);
149
 
            k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0);
150
 
 
151
 
            /* check k0 and k2 */
152
 
            if (sbr->sample_rate >= 48000)
153
 
            {
154
 
                if ((k2 - sbr->k0) > 32)
155
 
                    result += 1;
156
 
            } else if (sbr->sample_rate <= 32000) {
157
 
                if ((k2 - sbr->k0) > 48)
158
 
                    result += 1;
159
 
            } else { /* (sbr->sample_rate == 44100) */
160
 
                if ((k2 - sbr->k0) > 45)
161
 
                    result += 1;
162
 
            }
163
 
 
164
 
            if (sbr->bs_freq_scale == 0)
165
 
            {
166
 
                result += master_frequency_table_fs0(sbr, sbr->k0, k2,
167
 
                    sbr->bs_alter_scale);
168
 
            } else {
169
 
                result += master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale,
170
 
                    sbr->bs_alter_scale);
171
 
            }
172
 
            result += derived_frequency_table(sbr, sbr->bs_xover_band, k2);
173
 
 
174
 
            result = (result > 0) ? 1 : 0;
 
181
            uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq,
 
182
                sbr->bs_samplerate_mode, sbr->bs_freq_scale,
 
183
                sbr->bs_alter_scale, sbr->bs_xover_band);
 
184
 
 
185
            /* if an error occured with the new header values revert to the old ones */
 
186
            if (rt > 0)
 
187
            {
 
188
                calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
 
189
                    saved_samplerate_mode, saved_freq_scale,
 
190
                    saved_alter_scale, saved_xover_band);
 
191
            }
175
192
        }
176
193
 
177
194
        if (result == 0)
 
195
        {
178
196
            result = sbr_data(ld, sbr);
 
197
 
 
198
            /* sbr_data() returning an error means that there was an error in
 
199
               envelope_time_border_vector().
 
200
               In this case the old time border vector is saved and all the previous
 
201
               data normally read after sbr_grid() is saved.
 
202
            */
 
203
            /* to be on the safe side, calculate old sbr tables in case of error */
 
204
            if ((result > 0) &&
 
205
                (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)))
 
206
            {
 
207
                calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
 
208
                    saved_samplerate_mode, saved_freq_scale,
 
209
                    saved_alter_scale, saved_xover_band);
 
210
            }
 
211
 
 
212
            /* we should be able to safely set result to 0 now */
 
213
            result = 0;
 
214
        }
179
215
    } else {
180
216
        result = 1;
181
217
    }
185
221
#endif
186
222
    {
187
223
        num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits;
 
224
 
 
225
        /* check if we read more bits then were available for sbr */
 
226
        if (8*cnt < num_sbr_bits)
 
227
            return 1;
 
228
 
188
229
        /* -4 does not apply, bs_extension_type is re-read in this function */
189
230
        num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits;
190
231
 
333
374
    sbr_envelope(ld, sbr, 0);
334
375
    sbr_noise(ld, sbr, 0);
335
376
 
 
377
#ifndef FIXED_POINT
336
378
    envelope_noise_dequantisation(sbr, 0);
 
379
#endif
337
380
 
338
381
    memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
339
382
 
344
387
 
345
388
    sbr->bs_extended_data = faad_get1bit(ld
346
389
        DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
 
390
 
347
391
    if (sbr->bs_extended_data)
348
392
    {
349
393
        uint16_t nr_bits_left;
 
394
#if (defined(PS_DEC) || defined(DRM_PS))
 
395
        uint8_t ps_ext_read = 0;
 
396
#endif
350
397
        uint16_t cnt = (uint16_t)faad_getbits(ld, 4
351
398
            DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
352
399
        if (cnt == 15)
358
405
        nr_bits_left = 8 * cnt;
359
406
        while (nr_bits_left > 7)
360
407
        {
 
408
            uint16_t tmp_nr_bits = 0;
 
409
 
361
410
            sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
362
411
                DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
363
 
            nr_bits_left -= 2;
364
 
            nr_bits_left -= sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 
412
            tmp_nr_bits += 2;
 
413
 
 
414
            /* allow only 1 PS extension element per extension data */
 
415
#if (defined(PS_DEC) || defined(DRM_PS))
 
416
#if (defined(PS_DEC) && defined(DRM_PS))
 
417
            if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
 
418
#else
 
419
#ifdef PS_DEC
 
420
            if (sbr->bs_extension_id == EXTENSION_ID_PS)
 
421
#else
 
422
#ifdef DRM_PS
 
423
            if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
 
424
#endif
 
425
#endif
 
426
#endif
 
427
            {
 
428
                if (ps_ext_read == 0)
 
429
                {
 
430
                    ps_ext_read = 1;
 
431
                } else {
 
432
                    /* to be safe make it 3, will switch to "default"
 
433
                     * in sbr_extension() */
 
434
                    sbr->bs_extension_id = 3;
 
435
                }
 
436
            }
 
437
#endif
 
438
 
 
439
            tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 
440
 
 
441
            /* check if the data read is bigger than the number of available bits */
 
442
            if (tmp_nr_bits > nr_bits_left)
 
443
                return 1;
 
444
 
 
445
            nr_bits_left -= tmp_nr_bits;
365
446
        }
366
447
 
367
448
        /* Corrigendum */
437
518
        if (sbr->bs_add_harmonic_flag[1])
438
519
            sinusoidal_coding(ld, sbr, 1);
439
520
    } else {
 
521
        uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0};
 
522
        uint8_t saved_L_E = sbr->L_E[0];
 
523
        uint8_t saved_L_Q = sbr->L_Q[0];
 
524
        uint8_t saved_frame_class = sbr->bs_frame_class[0];
 
525
 
 
526
        for (n = 0; n < saved_L_E; n++)
 
527
            saved_t_E[n] = sbr->t_E[0][n];
 
528
        for (n = 0; n < saved_L_Q; n++)
 
529
            saved_t_Q[n] = sbr->t_Q[0][n];
 
530
 
440
531
        if ((result = sbr_grid(ld, sbr, 0)) > 0)
441
532
            return result;
442
533
        if ((result = sbr_grid(ld, sbr, 1)) > 0)
 
534
        {
 
535
            /* restore first channel data as well */
 
536
            sbr->bs_frame_class[0] = saved_frame_class;
 
537
            sbr->L_E[0] = saved_L_E;
 
538
            sbr->L_Q[0] = saved_L_Q;
 
539
            for (n = 0; n < 6; n++)
 
540
                sbr->t_E[0][n] = saved_t_E[n];
 
541
            for (n = 0; n < 3; n++)
 
542
                sbr->t_Q[0][n] = saved_t_Q[n];
 
543
 
443
544
            return result;
 
545
        }
444
546
        sbr_dtdf(ld, sbr, 0);
445
547
        sbr_dtdf(ld, sbr, 1);
446
548
        invf_mode(ld, sbr, 0);
463
565
        if (sbr->bs_add_harmonic_flag[1])
464
566
            sinusoidal_coding(ld, sbr, 1);
465
567
    }
 
568
#ifndef FIXED_POINT
466
569
    envelope_noise_dequantisation(sbr, 0);
467
570
    envelope_noise_dequantisation(sbr, 1);
468
571
 
469
572
    if (sbr->bs_coupling)
470
573
        unmap_envelope_noise(sbr);
 
574
#endif
471
575
 
472
576
    sbr->bs_extended_data = faad_get1bit(ld
473
577
        DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
485
589
        nr_bits_left = 8 * cnt;
486
590
        while (nr_bits_left > 7)
487
591
        {
 
592
            uint16_t tmp_nr_bits = 0;
 
593
 
488
594
            sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
489
595
                DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
490
 
            nr_bits_left -= 2;
491
 
            sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 
596
            tmp_nr_bits += 2;
 
597
            tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 
598
 
 
599
            /* check if the data read is bigger than the number of available bits */
 
600
            if (tmp_nr_bits > nr_bits_left)
 
601
                return 1;
 
602
 
 
603
            nr_bits_left -= tmp_nr_bits;
492
604
        }
493
605
 
494
606
        /* Corrigendum */
519
631
    uint8_t i, env, rel, result;
520
632
    uint8_t bs_abs_bord, bs_abs_bord_1;
521
633
    uint8_t bs_num_env = 0;
 
634
    uint8_t saved_L_E = sbr->L_E[ch];
 
635
    uint8_t saved_L_Q = sbr->L_Q[ch];
 
636
    uint8_t saved_frame_class = sbr->bs_frame_class[ch];
522
637
 
523
638
    sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
524
639
        DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
650
765
 
651
766
    /* TODO: this code can probably be integrated into the code above! */
652
767
    if ((result = envelope_time_border_vector(sbr, ch)) > 0)
 
768
    {
 
769
        sbr->bs_frame_class[ch] = saved_frame_class;
 
770
        sbr->L_E[ch] = saved_L_E;
 
771
        sbr->L_Q[ch] = saved_L_Q;
653
772
        return result;
 
773
    }
654
774
    noise_floor_time_border_vector(sbr, ch);
655
775
 
 
776
#if 0
 
777
    for (env = 0; env < bs_num_env; env++)
 
778
    {
 
779
        printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]);
 
780
    }
 
781
#endif
 
782
 
656
783
    return 0;
657
784
}
658
785
 
689
816
static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
690
817
                              uint8_t bs_extension_id, uint16_t num_bits_left)
691
818
{
 
819
#ifdef PS_DEC
 
820
    uint8_t header;
 
821
    uint16_t ret;
 
822
#endif
 
823
 
692
824
    switch (bs_extension_id)
693
825
    {
694
826
#ifdef PS_DEC
695
827
    case EXTENSION_ID_PS:
696
 
        sbr->ps_used = 1;
697
 
        return ps_data(&(sbr->ps), ld);
 
828
        if (!sbr->ps)
 
829
        {
 
830
            sbr->ps = ps_init(get_sr_index(sbr->sample_rate));
 
831
        }
 
832
        ret = ps_data(sbr->ps, ld, &header);
 
833
 
 
834
        /* enable PS if and only if: a header has been decoded */
 
835
        if (sbr->ps_used == 0 && header == 1)
 
836
        {
 
837
            sbr->ps_used = 1;
 
838
        }
 
839
 
 
840
        return ret;
698
841
#endif
699
842
#ifdef DRM_PS
700
843
    case DRM_PARAMETRIC_STEREO:
701
844
        sbr->ps_used = 1;
702
 
        return drm_ps_data(&(sbr->drm_ps), ld);
 
845
        if (!sbr->drm_ps)
 
846
        {
 
847
            sbr->drm_ps = drm_ps_init();
 
848
        }
 
849
        return drm_ps_data(sbr->drm_ps, ld);
703
850
#endif
704
851
    default:
705
852
        sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6