Revision dfd2a005 libavcodec/mpegaudiodec.c

View differences:

libavcodec/mpegaudiodec.c
352 352
            scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);
353 353
            scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
354 354
            scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
355
            dprintf(avctx, "%d: norm=%x s=%x %x %x\n",
355
            av_dlog(avctx, "%d: norm=%x s=%x %x %x\n",
356 356
                    i, norm,
357 357
                    scale_factor_mult[i][0],
358 358
                    scale_factor_mult[i][1],
......
457 457
                k = i & 1;
458 458
                is_table_lsf[j][k ^ 1][i] = FIXR(f);
459 459
                is_table_lsf[j][k][i] = FIXR(1.0);
460
                dprintf(avctx, "is_table_lsf %d %d: %x %x\n",
460
                av_dlog(avctx, "is_table_lsf %d %d: %x %x\n",
461 461
                        i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);
462 462
            }
463 463
        }
......
986 986
    else
987 987
        bound = sblimit;
988 988

  
989
    dprintf(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
989
    av_dlog(s->avctx, "bound=%d sblimit=%d\n", bound, sblimit);
990 990

  
991 991
    /* sanity check */
992 992
    if( bound > sblimit ) bound = sblimit;
......
1309 1309

  
1310 1310
            exponent= exponents[s_index];
1311 1311

  
1312
            dprintf(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
1312
            av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
1313 1313
                    i, g->region_size[i] - j, x, y, exponent);
1314 1314
            if(y&16){
1315 1315
                x = y >> 5;
......
1377 1377
        last_pos= pos;
1378 1378

  
1379 1379
        code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
1380
        dprintf(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
1380
        av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
1381 1381
        g->sb_hybrid[s_index+0]=
1382 1382
        g->sb_hybrid[s_index+1]=
1383 1383
        g->sb_hybrid[s_index+2]=
......
1735 1735

  
1736 1736
    for(gr=0;gr<nb_granules;gr++) {
1737 1737
        for(ch=0;ch<s->nb_channels;ch++) {
1738
            dprintf(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1738
            av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
1739 1739
            g = &s->granules[ch][gr];
1740 1740
            g->part2_3_length = get_bits(&s->gb, 12);
1741 1741
            g->big_values = get_bits(&s->gb, 9);
......
1776 1776
                /* compute huffman coded region sizes */
1777 1777
                region_address1 = get_bits(&s->gb, 4);
1778 1778
                region_address2 = get_bits(&s->gb, 3);
1779
                dprintf(s->avctx, "region1=%d region2=%d\n",
1779
                av_dlog(s->avctx, "region1=%d region2=%d\n",
1780 1780
                        region_address1, region_address2);
1781 1781
                ff_init_long_region(s, g, region_address1, region_address2);
1782 1782
            }
......
1788 1788
                g->preflag = get_bits1(&s->gb);
1789 1789
            g->scalefac_scale = get_bits1(&s->gb);
1790 1790
            g->count1table_select = get_bits1(&s->gb);
1791
            dprintf(s->avctx, "block_type=%d switch_point=%d\n",
1791
            av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
1792 1792
                    g->block_type, g->switch_point);
1793 1793
        }
1794 1794
    }
......
1797 1797
    const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
1798 1798
    assert((get_bits_count(&s->gb) & 7) == 0);
1799 1799
    /* now we get bits from the main_data_begin offset */
1800
    dprintf(s->avctx, "seekback: %d\n", main_data_begin);
1800
    av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
1801 1801
//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);
1802 1802

  
1803 1803
    memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
......
1831 1831
                /* MPEG1 scale factors */
1832 1832
                slen1 = slen_table[0][g->scalefac_compress];
1833 1833
                slen2 = slen_table[1][g->scalefac_compress];
1834
                dprintf(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1834
                av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
1835 1835
                if (g->block_type == 2) {
1836 1836
                    n = g->switch_point ? 17 : 18;
1837 1837
                    j = 0;
......
1964 1964
    if (s->error_protection)
1965 1965
        skip_bits(&s->gb, 16);
1966 1966

  
1967
    dprintf(s->avctx, "frame %d:\n", s->frame_count);
1967
    av_dlog(s->avctx, "frame %d:\n", s->frame_count);
1968 1968
    switch(s->layer) {
1969 1969
    case 1:
1970 1970
        s->avctx->frame_size = 384;

Also available in: Unified diff