Revision 7ae7300e

View differences:

libavcodec/alac.c
201 201

  
202 202
                if (extrabits > 1) {
203 203
                    x += extrabits - 1;
204
                    get_bits(&alac->gb, k);
204
                    skip_bits(&alac->gb, k);
205 205
                } else
206
                    get_bits(&alac->gb, k - 1);
206
                    skip_bits(&alac->gb, k - 1);
207 207
            }
208 208
        }
209 209

  
......
250 250
                if (extrabits < 2) {
251 251
                    x = 1 - extrabits;
252 252
                    block_size += x;
253
                    get_bits(&alac->gb, k - 1);
253
                    skip_bits(&alac->gb, k - 1);
254 254
                } else {
255
                    get_bits(&alac->gb, k);
255
                    skip_bits(&alac->gb, k);
256 256
                }
257 257
            }
258 258

  
......
484 484
    /* 2^result = something to do with output waiting.
485 485
     * perhaps matters if we read > 1 frame in a pass?
486 486
     */
487
    get_bits(&alac->gb, 4);
487
    skip_bits(&alac->gb, 4);
488 488

  
489
    get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
489
    skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */
490 490

  
491 491
    /* the output sample size is stored soon */
492 492
    hassize = get_bits1(&alac->gb);
libavcodec/mpegaudiodec.c
2288 2288

  
2289 2289
    /* skip error protection field */
2290 2290
    if (s->error_protection)
2291
        get_bits(&s->gb, 16);
2291
        skip_bits(&s->gb, 16);
2292 2292

  
2293 2293
    dprintf(s->avctx, "frame %d:\n", s->frame_count);
2294 2294
    switch(s->layer) {
libavcodec/rv10.c
200 200
                else
201 201
                    code = (int8_t)(get_bits(&s->gb, 8));
202 202
            } else if (code == 0x7f) {
203
                get_bits(&s->gb, 11);
203
                skip_bits(&s->gb, 11);
204 204
                code = 1;
205 205
            }
206 206
        } else {
......
216 216
            } else if (code == 0x1fd) {
217 217
                code = -128 + get_bits(&s->gb, 7);
218 218
            } else if (code == 0x1fe) {
219
                get_bits(&s->gb, 9);
219
                skip_bits(&s->gb, 9);
220 220
                code = 1;
221 221
            } else {
222 222
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
libavcodec/shorten.c
299 299
        }
300 300
    }
301 301
    init_get_bits(&s->gb, buf, buf_size*8);
302
    get_bits(&s->gb, s->bitindex);
302
    skip_bits(&s->gb, s->bitindex);
303 303
    if (!s->blocksize)
304 304
    {
305 305
        int maxnlpc = 0;
libavcodec/smacker.c
201 201

  
202 202
    if(get_bits1(gb)) {
203 203
        smacker_decode_tree(gb, &tmp1, 0, 0);
204
        get_bits1(gb);
204
        skip_bits1(gb);
205 205
        res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
206 206
                    tmp1.lengths, sizeof(int), sizeof(int),
207 207
                    tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
......
214 214
    }
215 215
    if(get_bits1(gb)){
216 216
        smacker_decode_tree(gb, &tmp2, 0, 0);
217
        get_bits1(gb);
217
        skip_bits1(gb);
218 218
        res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
219 219
                    tmp2.lengths, sizeof(int), sizeof(int),
220 220
                    tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
......
250 250
    huff.values = av_mallocz(huff.length * sizeof(int));
251 251

  
252 252
    smacker_decode_bigtree(gb, &huff, &ctx);
253
    get_bits1(gb);
253
    skip_bits1(gb);
254 254
    if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
255 255
    if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
256 256
    if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
......
601 601
        h[i].bits = av_mallocz(256 * 4);
602 602
        h[i].lengths = av_mallocz(256 * sizeof(int));
603 603
        h[i].values = av_mallocz(256 * sizeof(int));
604
        get_bits1(&gb);
604
        skip_bits1(&gb);
605 605
        smacker_decode_tree(&gb, &h[i], 0, 0);
606
        get_bits1(&gb);
606
        skip_bits1(&gb);
607 607
        if(h[i].current > 1) {
608 608
            res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
609 609
                    h[i].lengths, sizeof(int), sizeof(int),
libavcodec/vorbis_dec.c
729 729
        }
730 730

  
731 731
        for(j=0;j<mapping_setup->submaps;++j) {
732
            get_bits(gb, 8); // FIXME check?
732
            skip_bits(gb, 8); // FIXME check?
733 733
            mapping_setup->submap_floor[j]=get_bits(gb, 8);
734 734
            mapping_setup->submap_residue[j]=get_bits(gb, 8);
735 735

  
libavcodec/wmadec.c
780 780

  
781 781
    if (s->use_bit_reservoir) {
782 782
        /* read super frame header */
783
        get_bits(&s->gb, 4); /* super frame index */
783
        skip_bits(&s->gb, 4); /* super frame index */
784 784
        nb_frames = get_bits(&s->gb, 4) - 1;
785 785

  
786 786
        bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);

Also available in: Unified diff