← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/mpegaudio.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060401161343-08cyx5z9c530gtrd
Tags: 0.10.1-0ubuntu1
* New upstream release:
  Features since 0.10.0:
    + Parallel installability with 0.8.x series
    + Threadsafe design and API
    + ffvideoscale ported
    + ffdeinterlace ported
    + demuxer wrapper works pull-based
    + disabled mpeg2 video and mp3 audio autoplugging
    + fixes for Indeo3, PNG, smc, H264 HD, H263, FLV1, G2
  Bugs fixed since 0.10.0:
    + [ffdemux_mp3] ffmpeg mp3 decoder miss seeking
    + Reading mpeg-ts stream from standard input does not work
    + configure script doesn't accept --with-pkg-config-path ar...
    + Fails to build under powerpc
    + avcodec_open()/close() aren't thread-safe
    + [ffdec_cinepak] chef.avi causes gstreamer to hang in preroll
    + Indeo AVI files do not play with 0.10
    + [ffdec] Memory leak when joining pcache
    + MS Video 1 palettized AVI doesn't work
    + ffdeinterlace port to 0.10
    + [ffmpegenc] FFMpeg audio encoders do not set caps to buffers
    + gstreamer CVS doesn't work with ffmpeg codecs
    + Wrap the ffmpeg demuxers
    + [ffdec_h264] seeking in " IntoTheBlue_Cin_AVC.mp4 " crashes...
    + Too fast playback of h263p encoded file
    + FFmpeg video scale port to 0.10
    + segfault in ffmpeg enc
    + Memory leak in ffmpegenc
    + [CVE-2005-4048] avcodec_default_get_buffer heap overflow
* debian/patches/32_CVE-2005-4048_avcodec-default-get-buffer-heap-overflow.patch:
  - Dropped, this is upstream now

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/mpegaudio.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
 
 
 
19
 
20
20
/**
21
21
 * @file mpegaudio.c
22
22
 * The simplest mpeg audio layer 2 encoder.
23
23
 */
24
 
 
 
24
 
25
25
#include "avcodec.h"
26
26
#include "bitstream.h"
27
27
#include "mpegaudio.h"
49
49
    int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT];
50
50
    unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */
51
51
    /* code to group 3 scale factors */
52
 
    unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];       
 
52
    unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
53
53
    int sblimit; /* number of used subbands */
54
54
    const unsigned char *alloc_table;
55
55
} MpegAudioContext;
79
79
    /* encoding freq */
80
80
    s->lsf = 0;
81
81
    for(i=0;i<3;i++) {
82
 
        if (mpa_freq_tab[i] == freq) 
 
82
        if (mpa_freq_tab[i] == freq)
83
83
            break;
84
84
        if ((mpa_freq_tab[i] / 2) == freq) {
85
85
            s->lsf = 1;
94
94
 
95
95
    /* encoding bitrate & frequency */
96
96
    for(i=0;i<15;i++) {
97
 
        if (mpa_bitrate_tab[s->lsf][1][i] == bitrate) 
 
97
        if (mpa_bitrate_tab[s->lsf][1][i] == bitrate)
98
98
            break;
99
99
    }
100
100
    if (i == 15){
104
104
    s->bitrate_index = i;
105
105
 
106
106
    /* compute total header size & pad bit */
107
 
    
 
107
 
108
108
    a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
109
109
    s->frame_size = ((int)a) * 8;
110
110
 
111
111
    /* frame fractional size to compute padding */
112
112
    s->frame_frac = 0;
113
113
    s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
114
 
    
 
114
 
115
115
    /* select the right allocation table */
116
116
    table = l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
117
117
 
120
120
    s->alloc_table = alloc_tables[table];
121
121
 
122
122
#ifdef DEBUG
123
 
    av_log(avctx, AV_LOG_DEBUG, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n", 
 
123
    av_log(avctx, AV_LOG_DEBUG, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
124
124
           bitrate, freq, s->frame_size, table, s->frame_frac_incr);
125
125
#endif
126
126
 
163
163
            v = 2;
164
164
        else if (v < 3)
165
165
            v = 3;
166
 
        else 
 
166
        else
167
167
            v = 4;
168
168
        scale_diff_table[i] = v;
169
169
    }
170
170
 
171
171
    for(i=0;i<17;i++) {
172
172
        v = quant_bits[i];
173
 
        if (v < 0) 
 
173
        if (v < 0)
174
174
            v = -v;
175
175
        else
176
176
            v = v * 3;
191
191
    const int *xp = costab32;
192
192
 
193
193
    for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
194
 
    
 
194
 
195
195
    t = tab + 30;
196
196
    t1 = tab + 2;
197
197
    do {
209
209
        t[3] += t[3-8];
210
210
        t -= 8;
211
211
    } while (t != t1);
212
 
    
 
212
 
213
213
    t = tab;
214
214
    t1 = tab + 32;
215
215
    do {
216
 
        t[ 3] = -t[ 3];    
217
 
        t[ 6] = -t[ 6];    
218
 
        
219
 
        t[11] = -t[11];    
220
 
        t[12] = -t[12];    
221
 
        t[13] = -t[13];    
222
 
        t[15] = -t[15]; 
 
216
        t[ 3] = -t[ 3];
 
217
        t[ 6] = -t[ 6];
 
218
 
 
219
        t[11] = -t[11];
 
220
        t[12] = -t[12];
 
221
        t[13] = -t[13];
 
222
        t[15] = -t[15];
223
223
        t += 16;
224
224
    } while (t != t1);
225
225
 
226
 
    
 
226
 
227
227
    t = tab;
228
228
    t1 = tab + 8;
229
229
    do {
230
230
        int x1, x2, x3, x4;
231
 
        
 
231
 
232
232
        x3 = MUL(t[16], FIX(SQRT2*0.5));
233
233
        x4 = t[0] - x3;
234
234
        x3 = t[0] + x3;
235
 
        
 
235
 
236
236
        x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5));
237
237
        x1 = MUL((t[8] - x2), xp[0]);
238
238
        x2 = MUL((t[8] + x2), xp[1]);
255
255
        xr = MUL(t[4],xp[1]);
256
256
        t[ 4] = (t[24] - xr);
257
257
        t[24] = (t[24] + xr);
258
 
        
 
258
 
259
259
        xr = MUL(t[20],xp[2]);
260
260
        t[20] = (t[8] - xr);
261
261
        t[ 8] = (t[8] + xr);
262
 
            
 
262
 
263
263
        xr = MUL(t[12],xp[3]);
264
264
        t[12] = (t[16] - xr);
265
265
        t[16] = (t[16] + xr);
271
271
        xr = MUL(tab[30-i*4],xp[0]);
272
272
        tab[30-i*4] = (tab[i*4] - xr);
273
273
        tab[   i*4] = (tab[i*4] + xr);
274
 
        
 
274
 
275
275
        xr = MUL(tab[ 2+i*4],xp[1]);
276
276
        tab[ 2+i*4] = (tab[28-i*4] - xr);
277
277
        tab[28-i*4] = (tab[28-i*4] + xr);
278
 
        
 
278
 
279
279
        xr = MUL(tab[31-i*4],xp[0]);
280
280
        tab[31-i*4] = (tab[1+i*4] - xr);
281
281
        tab[ 1+i*4] = (tab[1+i*4] + xr);
282
 
        
 
282
 
283
283
        xr = MUL(tab[ 3+i*4],xp[1]);
284
284
        tab[ 3+i*4] = (tab[29-i*4] - xr);
285
285
        tab[29-i*4] = (tab[29-i*4] + xr);
286
 
        
 
286
 
287
287
        xp += 2;
288
288
    }
289
289
 
352
352
        out += 32;
353
353
        /* handle the wrap around */
354
354
        if (offset < 0) {
355
 
            memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32), 
 
355
            memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
356
356
                    s->samples_buf[ch], (512 - 32) * 2);
357
357
            offset = SAMPLES_BUF_SIZE - 512;
358
358
        }
363
363
}
364
364
 
365
365
static void compute_scale_factors(unsigned char scale_code[SBLIMIT],
366
 
                                  unsigned char scale_factors[SBLIMIT][3], 
 
366
                                  unsigned char scale_factors[SBLIMIT][3],
367
367
                                  int sb_samples[3][12][SBLIMIT],
368
368
                                  int sblimit)
369
369
{
370
370
    int *p, vmax, v, n, i, j, k, code;
371
371
    int index, d1, d2;
372
372
    unsigned char *sf = &scale_factors[0][0];
373
 
    
 
373
 
374
374
    for(j=0;j<sblimit;j++) {
375
375
        for(i=0;i<3;i++) {
376
376
            /* find the max absolute value */
385
385
            /* compute the scale factor index using log 2 computations */
386
386
            if (vmax > 0) {
387
387
                n = av_log2(vmax);
388
 
                /* n is the position of the MSB of vmax. now 
 
388
                /* n is the position of the MSB of vmax. now
389
389
                   use at most 2 compares to find the index */
390
390
                index = (21 - n) * 3 - 3;
391
391
                if (index >= 0) {
399
399
            }
400
400
 
401
401
#if 0
402
 
            printf("%2d:%d in=%x %x %d\n", 
 
402
            printf("%2d:%d in=%x %x %d\n",
403
403
                   j, i, vmax, scale_factor_table[index], index);
404
404
#endif
405
405
            /* store the scale factor */
411
411
           are close enough to each other */
412
412
        d1 = scale_diff_table[sf[0] - sf[1] + 64];
413
413
        d2 = scale_diff_table[sf[1] - sf[2] + 64];
414
 
        
 
414
 
415
415
        /* handle the 25 cases */
416
416
        switch(d1 * 5 + d2) {
417
417
        case 0*5+0:
468
468
            assert(0); //cant happen
469
469
            code = 0;           /* kill warning */
470
470
        }
471
 
        
 
471
 
472
472
#if 0
473
 
        printf("%d: %2d %2d %2d %d %d -> %d\n", j, 
 
473
        printf("%d: %2d %2d %2d %d %d -> %d\n", j,
474
474
               sf[0], sf[1], sf[2], d1, d2, code);
475
475
#endif
476
476
        scale_code[j] = code;
498
498
/* Try to maximize the smr while using a number of bits inferior to
499
499
   the frame size. I tried to make the code simpler, faster and
500
500
   smaller than other encoders :-) */
501
 
static void compute_bit_allocation(MpegAudioContext *s, 
 
501
static void compute_bit_allocation(MpegAudioContext *s,
502
502
                                   short smr1[MPA_MAX_CHANNELS][SBLIMIT],
503
503
                                   unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
504
504
                                   int *padding)
512
512
    memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
513
513
    memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
514
514
    memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
515
 
    
 
515
 
516
516
    /* compute frame size and padding */
517
517
    max_frame_size = s->frame_size;
518
518
    s->frame_frac += s->frame_frac_incr;
547
547
            }
548
548
        }
549
549
#if 0
550
 
        printf("current=%d max=%d max_sb=%d alloc=%d\n", 
 
550
        printf("current=%d max=%d max_sb=%d alloc=%d\n",
551
551
               current_frame_size, max_frame_size, max_sb,
552
552
               bit_alloc[max_sb]);
553
 
#endif        
 
553
#endif
554
554
        if (max_sb < 0)
555
555
            break;
556
 
        
 
556
 
557
557
        /* find alloc table entry (XXX: not optimal, should use
558
558
           pointer table) */
559
559
        alloc = s->alloc_table;
568
568
        } else {
569
569
            /* increments bit allocation */
570
570
            b = bit_alloc[max_ch][max_sb];
571
 
            incr = total_quant_bits[alloc[b + 1]] - 
 
571
            incr = total_quant_bits[alloc[b + 1]] -
572
572
                total_quant_bits[alloc[b]];
573
573
        }
574
574
 
637
637
        }
638
638
        j += 1 << bit_alloc_bits;
639
639
    }
640
 
    
 
640
 
641
641
    /* scale codes */
642
642
    for(i=0;i<s->sblimit;i++) {
643
643
        for(ch=0;ch<s->nb_channels;ch++) {
644
 
            if (bit_alloc[ch][i]) 
 
644
            if (bit_alloc[ch][i])
645
645
                put_bits(p, 2, s->scale_code[ch][i]);
646
646
        }
647
647
    }
669
669
            }
670
670
        }
671
671
    }
672
 
    
 
672
 
673
673
    /* quantization & write sub band samples */
674
674
 
675
675
    for(k=0;k<3;k++) {
699
699
                                e = s->scale_factors[ch][i][k];
700
700
                                shift = scale_factor_shift[e];
701
701
                                mult = scale_factor_mult[e];
702
 
                                
 
702
 
703
703
                                /* normalize to P bits */
704
704
                                if (shift < 0)
705
705
                                    q1 = sample << (-shift);
716
716
                        bits = quant_bits[qindex];
717
717
                        if (bits < 0) {
718
718
                            /* group the 3 values to save bits */
719
 
                            put_bits(p, -bits, 
 
719
                            put_bits(p, -bits,
720
720
                                     q[0] + steps * (q[1] + steps * q[2]));
721
721
#if 0
722
 
                            printf("%d: gr1 %d\n", 
 
722
                            printf("%d: gr1 %d\n",
723
723
                                   i, q[0] + steps * (q[1] + steps * q[2]));
724
724
#endif
725
725
                        } else {
726
726
#if 0
727
 
                            printf("%d: gr3 %d %d %d\n", 
 
727
                            printf("%d: gr3 %d %d %d\n",
728
728
                                   i, q[0], q[1], q[2]);
729
 
#endif                               
 
729
#endif
730
730
                            put_bits(p, bits, q[0]);
731
731
                            put_bits(p, bits, q[1]);
732
732
                            put_bits(p, bits, q[2]);
734
734
                    }
735
735
                }
736
736
                /* next subband in alloc table */
737
 
                j += 1 << bit_alloc_bits; 
 
737
                j += 1 << bit_alloc_bits;
738
738
            }
739
739
        }
740
740
    }
748
748
}
749
749
 
750
750
static int MPA_encode_frame(AVCodecContext *avctx,
751
 
                            unsigned char *frame, int buf_size, void *data)
 
751
                            unsigned char *frame, int buf_size, void *data)
752
752
{
753
753
    MpegAudioContext *s = avctx->priv_data;
754
754
    short *samples = data;
761
761
    }
762
762
 
763
763
    for(i=0;i<s->nb_channels;i++) {
764
 
        compute_scale_factors(s->scale_code[i], s->scale_factors[i], 
 
764
        compute_scale_factors(s->scale_code[i], s->scale_factors[i],
765
765
                              s->sb_samples[i], s->sblimit);
766
766
    }
767
767
    for(i=0;i<s->nb_channels;i++) {
772
772
    init_put_bits(&s->pb, frame, MPA_MAX_CODED_FRAME_SIZE);
773
773
 
774
774
    encode_frame(s, bit_alloc, padding);
775
 
    
 
775
 
776
776
    s->nb_samples += MPA_FRAME_SIZE;
777
777
    return pbBufPtr(&s->pb) - s->pb.buf;
778
778
}