Revision dfd2a005 libavcodec/wmaprodec.c

View differences:

libavcodec/wmaprodec.c
288 288
        s->bits_per_sample = AV_RL16(edata_ptr);
289 289
        /** dump the extradata */
290 290
        for (i = 0; i < avctx->extradata_size; i++)
291
            dprintf(avctx, "[%x] ", avctx->extradata[i]);
292
        dprintf(avctx, "\n");
291
            av_dlog(avctx, "[%x] ", avctx->extradata[i]);
292
        av_dlog(avctx, "\n");
293 293

  
294 294
    } else {
295 295
        av_log_ask_for_sample(avctx, "Unknown extradata size\n");
......
582 582
        int i;
583 583
        int offset = 0;
584 584
        for (i = 0; i < s->channel[c].num_subframes; i++) {
585
            dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
585
            av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
586 586
                    " len %i\n", s->frame_num, c, i,
587 587
                    s->channel[c].subframe_len[i]);
588 588
            s->channel[c].subframe_offset[i] = offset;
......
781 781
    const uint16_t* run;
782 782
    const float* level;
783 783

  
784
    dprintf(s->avctx, "decode coefficients for channel %i\n", c);
784
    av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
785 785

  
786 786
    vlctable = get_bits1(&s->gb);
787 787
    vlc = &coef_vlc[vlctable];
......
1066 1066
        }
1067 1067
    }
1068 1068

  
1069
    dprintf(s->avctx,
1069
    av_dlog(s->avctx,
1070 1070
            "processing subframe with offset %i len %i\n", offset, subframe_len);
1071 1071

  
1072 1072
    /** get a list of all channels that contain the estimated block */
......
1093 1093
        s->parsed_all_subframes = 1;
1094 1094

  
1095 1095

  
1096
    dprintf(s->avctx, "subframe is part of %i channels\n",
1096
    av_dlog(s->avctx, "subframe is part of %i channels\n",
1097 1097
            s->channels_for_cur_subframe);
1098 1098

  
1099 1099
    /** calculate number of scale factor bands and their offsets */
......
1204 1204
            return AVERROR_INVALIDDATA;
1205 1205
    }
1206 1206

  
1207
    dprintf(s->avctx, "BITSTREAM: subframe header length was %i\n",
1207
    av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
1208 1208
            get_bits_count(&s->gb) - s->subframe_offset);
1209 1209

  
1210 1210
    /** parse coefficients */
......
1218 1218
                   sizeof(*s->channel[c].coeffs) * subframe_len);
1219 1219
    }
1220 1220

  
1221
    dprintf(s->avctx, "BITSTREAM: subframe length was %i\n",
1221
    av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
1222 1222
            get_bits_count(&s->gb) - s->subframe_offset);
1223 1223

  
1224 1224
    if (transmit_coeffs) {
......
1294 1294
    if (s->len_prefix)
1295 1295
        len = get_bits(gb, s->log2_frame_size);
1296 1296

  
1297
    dprintf(s->avctx, "decoding frame with length %x\n", len);
1297
    av_dlog(s->avctx, "decoding frame with length %x\n", len);
1298 1298

  
1299 1299
    /** decode tile information */
1300 1300
    if (decode_tilehdr(s)) {
......
1313 1313
    /** read drc info */
1314 1314
    if (s->dynamic_range_compression) {
1315 1315
        s->drc_gain = get_bits(gb, 8);
1316
        dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
1316
        av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
1317 1317
    }
1318 1318

  
1319 1319
    /** no idea what these are for, might be the number of samples
......
1324 1324
        /** usually true for the first frame */
1325 1325
        if (get_bits1(gb)) {
1326 1326
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1327
            dprintf(s->avctx, "start skip: %i\n", skip);
1327
            av_dlog(s->avctx, "start skip: %i\n", skip);
1328 1328
        }
1329 1329

  
1330 1330
        /** sometimes true for the last frame */
1331 1331
        if (get_bits1(gb)) {
1332 1332
            skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
1333
            dprintf(s->avctx, "end skip: %i\n", skip);
1333
            av_dlog(s->avctx, "end skip: %i\n", skip);
1334 1334
        }
1335 1335

  
1336 1336
    }
1337 1337

  
1338
    dprintf(s->avctx, "BITSTREAM: frame header length was %i\n",
1338
    av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
1339 1339
            get_bits_count(gb) - s->frame_offset);
1340 1340

  
1341 1341
    /** reset subframe states */
......
1505 1505

  
1506 1506
        /** get number of bits that need to be added to the previous frame */
1507 1507
        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
1508
        dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1508
        av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
1509 1509
                num_bits_prev_frame);
1510 1510

  
1511 1511
        /** check for packet loss */
......
1527 1527
            /** append the previous frame data to the remaining data from the
1528 1528
                previous packet to create a full frame */
1529 1529
            save_bits(s, gb, num_bits_prev_frame, 1);
1530
            dprintf(avctx, "accumulated %x bits of frame data\n",
1530
            av_dlog(avctx, "accumulated %x bits of frame data\n",
1531 1531
                    s->num_saved_bits - s->frame_offset);
1532 1532

  
1533 1533
            /** decode the cross packet frame if it is valid */
1534 1534
            if (!s->packet_loss)
1535 1535
                decode_frame(s);
1536 1536
        } else if (s->num_saved_bits - s->frame_offset) {
1537
            dprintf(avctx, "ignoring %x previously saved bits\n",
1537
            av_dlog(avctx, "ignoring %x previously saved bits\n",
1538 1538
                    s->num_saved_bits - s->frame_offset);
1539 1539
        }
1540 1540

  

Also available in: Unified diff