Revision dfd2a005

View differences:

libavcodec/alsdec.c
253 253
    AVCodecContext *avctx    = ctx->avctx;
254 254
    ALSSpecificConfig *sconf = &ctx->sconf;
255 255

  
256
    dprintf(avctx, "resolution = %i\n",           sconf->resolution);
257
    dprintf(avctx, "floating = %i\n",             sconf->floating);
258
    dprintf(avctx, "frame_length = %i\n",         sconf->frame_length);
259
    dprintf(avctx, "ra_distance = %i\n",          sconf->ra_distance);
260
    dprintf(avctx, "ra_flag = %i\n",              sconf->ra_flag);
261
    dprintf(avctx, "adapt_order = %i\n",          sconf->adapt_order);
262
    dprintf(avctx, "coef_table = %i\n",           sconf->coef_table);
263
    dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
264
    dprintf(avctx, "max_order = %i\n",            sconf->max_order);
265
    dprintf(avctx, "block_switching = %i\n",      sconf->block_switching);
266
    dprintf(avctx, "bgmc = %i\n",                 sconf->bgmc);
267
    dprintf(avctx, "sb_part = %i\n",              sconf->sb_part);
268
    dprintf(avctx, "joint_stereo = %i\n",         sconf->joint_stereo);
269
    dprintf(avctx, "mc_coding = %i\n",            sconf->mc_coding);
270
    dprintf(avctx, "chan_config = %i\n",          sconf->chan_config);
271
    dprintf(avctx, "chan_sort = %i\n",            sconf->chan_sort);
272
    dprintf(avctx, "RLSLMS = %i\n",               sconf->rlslms);
273
    dprintf(avctx, "chan_config_info = %i\n",     sconf->chan_config_info);
256
    av_dlog(avctx, "resolution = %i\n",           sconf->resolution);
257
    av_dlog(avctx, "floating = %i\n",             sconf->floating);
258
    av_dlog(avctx, "frame_length = %i\n",         sconf->frame_length);
259
    av_dlog(avctx, "ra_distance = %i\n",          sconf->ra_distance);
260
    av_dlog(avctx, "ra_flag = %i\n",              sconf->ra_flag);
261
    av_dlog(avctx, "adapt_order = %i\n",          sconf->adapt_order);
262
    av_dlog(avctx, "coef_table = %i\n",           sconf->coef_table);
263
    av_dlog(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
264
    av_dlog(avctx, "max_order = %i\n",            sconf->max_order);
265
    av_dlog(avctx, "block_switching = %i\n",      sconf->block_switching);
266
    av_dlog(avctx, "bgmc = %i\n",                 sconf->bgmc);
267
    av_dlog(avctx, "sb_part = %i\n",              sconf->sb_part);
268
    av_dlog(avctx, "joint_stereo = %i\n",         sconf->joint_stereo);
269
    av_dlog(avctx, "mc_coding = %i\n",            sconf->mc_coding);
270
    av_dlog(avctx, "chan_config = %i\n",          sconf->chan_config);
271
    av_dlog(avctx, "chan_sort = %i\n",            sconf->chan_sort);
272
    av_dlog(avctx, "RLSLMS = %i\n",               sconf->rlslms);
273
    av_dlog(avctx, "chan_config_info = %i\n",     sconf->chan_config_info);
274 274
#endif
275 275
}
276 276

  
libavcodec/dnxhddec.c
107 107
    ctx->height = AV_RB16(buf + 0x18);
108 108
    ctx->width  = AV_RB16(buf + 0x1a);
109 109

  
110
    dprintf(ctx->avctx, "width %d, heigth %d\n", ctx->width, ctx->height);
110
    av_dlog(ctx->avctx, "width %d, heigth %d\n", ctx->width, ctx->height);
111 111

  
112 112
    if (buf[0x21] & 0x40) {
113 113
        av_log(ctx->avctx, AV_LOG_ERROR, "10 bit per component\n");
......
115 115
    }
116 116

  
117 117
    ctx->cid = AV_RB32(buf + 0x28);
118
    dprintf(ctx->avctx, "compression id %d\n", ctx->cid);
118
    av_dlog(ctx->avctx, "compression id %d\n", ctx->cid);
119 119

  
120 120
    if (dnxhd_init_vlc(ctx, ctx->cid) < 0)
121 121
        return -1;
......
128 128
    ctx->mb_width = ctx->width>>4;
129 129
    ctx->mb_height = buf[0x16d];
130 130

  
131
    dprintf(ctx->avctx, "mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height);
131
    av_dlog(ctx->avctx, "mb width %d, mb height %d\n", ctx->mb_width, ctx->mb_height);
132 132

  
133 133
    if ((ctx->height+15)>>4 == ctx->mb_height && ctx->picture.interlaced_frame)
134 134
        ctx->height <<= 1;
......
141 141

  
142 142
    for (i = 0; i < ctx->mb_height; i++) {
143 143
        ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2));
144
        dprintf(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
144
        av_dlog(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
145 145
        if (buf_size < ctx->mb_scan_index[i] + 0x280) {
146 146
            av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n");
147 147
            return -1;
......
293 293
    AVFrame *picture = data;
294 294
    int first_field = 1;
295 295

  
296
    dprintf(avctx, "frame size %d\n", buf_size);
296
    av_dlog(avctx, "frame size %d\n", buf_size);
297 297

  
298 298
 decode_coding_unit:
299 299
    if (dnxhd_decode_header(ctx, buf, buf_size, first_field) < 0)
libavcodec/dnxhdenc.c
552 552
            if (bits > ctx->frame_bits)
553 553
                break;
554 554
        }
555
        //dprintf(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n",
555
        //av_dlog(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n",
556 556
        //        lambda, last_higher, last_lower, bits, ctx->frame_bits);
557 557
        if (end) {
558 558
            if (bits > ctx->frame_bits)
......
582 582
            down_step = 1<<LAMBDA_FRAC_BITS;
583 583
        }
584 584
    }
585
    //dprintf(ctx->m.avctx, "out lambda %d\n", lambda);
585
    //av_dlog(ctx->m.avctx, "out lambda %d\n", lambda);
586 586
    ctx->lambda = lambda;
587 587
    return 0;
588 588
}
......
610 610
            if (bits > ctx->frame_bits)
611 611
                break;
612 612
        }
613
        //dprintf(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
613
        //av_dlog(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
614 614
        //        ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits, last_higher, last_lower);
615 615
        if (bits < ctx->frame_bits) {
616 616
            if (qscale == 1)
......
640 640
                return -1;
641 641
        }
642 642
    }
643
    //dprintf(ctx->m.avctx, "out qscale %d\n", qscale);
643
    //av_dlog(ctx->m.avctx, "out qscale %d\n", qscale);
644 644
    ctx->qscale = qscale;
645 645
    return 0;
646 646
}
libavcodec/dvbsub_parser.c
55 55
    uint8_t *p, *p_end;
56 56
    int len, buf_pos = 0;
57 57

  
58
    dprintf(avctx, "DVB parse packet pts=%"PRIx64", lpts=%"PRIx64", cpts=%"PRIx64":\n",
58
    av_dlog(avctx, "DVB parse packet pts=%"PRIx64", lpts=%"PRIx64", cpts=%"PRIx64":\n",
59 59
            s->pts, s->last_pts, s->cur_frame_pts[s->cur_frame_start_index]);
60 60

  
61 61
#ifdef DEBUG_PACKET_CONTENTS
......
82 82
    {
83 83
        if (pc->packet_index != pc->packet_start)
84 84
        {
85
            dprintf(avctx, "Discarding %d bytes\n",
85
            av_dlog(avctx, "Discarding %d bytes\n",
86 86
                    pc->packet_index - pc->packet_start);
87 87
        }
88 88

  
......
90 90
        pc->packet_index = 0;
91 91

  
92 92
        if (buf_size < 2 || buf[0] != 0x20 || buf[1] != 0x00) {
93
            dprintf(avctx, "Bad packet header\n");
93
            av_dlog(avctx, "Bad packet header\n");
94 94
            return -1;
95 95
        }
96 96

  
......
147 147
        } else if (*p == 0xff) {
148 148
            if (p + 1 < p_end)
149 149
            {
150
                dprintf(avctx, "Junk at end of packet\n");
150
                av_dlog(avctx, "Junk at end of packet\n");
151 151
            }
152 152
            pc->packet_index = p - pc->packet_buf;
153 153
            pc->in_packet = 0;
libavcodec/dvbsubdec.c
749 749
                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
750 750
    uint8_t *map_table;
751 751

  
752
    dprintf(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
752
    av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
753 753
            top_bottom ? "bottom" : "top");
754 754

  
755 755
#ifdef DEBUG_PACKET_CONTENTS
......
984 984
        YUV_TO_RGB1_CCIR(cb, cr);
985 985
        YUV_TO_RGB2_CCIR(r, g, b, y);
986 986

  
987
        dprintf(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
987
        av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
988 988

  
989 989
        if (depth & 0x80)
990 990
            clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
......
1060 1060
            region->bgcolor = (((*buf++) >> 2) & 3);
1061 1061
    }
1062 1062

  
1063
    dprintf(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1063
    av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
1064 1064

  
1065 1065
    if (fill) {
1066 1066
        memset(region->pbuf, region->bgcolor, region->buf_size);
1067
        dprintf(avctx, "Fill region (%d)\n", region->bgcolor);
1067
        av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
1068 1068
    }
1069 1069

  
1070 1070
    delete_region_display_list(ctx, region);
......
1125 1125
    ctx->time_out = *buf++;
1126 1126
    page_state = ((*buf++) >> 2) & 3;
1127 1127

  
1128
    dprintf(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1128
    av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
1129 1129

  
1130 1130
    if (page_state == 2) {
1131 1131
        delete_state(ctx);
......
1163 1163
        ctx->display_list = display;
1164 1164
        ctx->display_list_size++;
1165 1165

  
1166
        dprintf(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1166
        av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1167 1167
    }
1168 1168

  
1169 1169
    while (tmp_display_list) {
......
1461 1461
                *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
1462 1462
                break;
1463 1463
            default:
1464
                dprintf(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1464
                av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
1465 1465
                        segment_type, page_id, segment_length);
1466 1466
                break;
1467 1467
            }
......
1471 1471
    }
1472 1472

  
1473 1473
    if (p != p_end) {
1474
        dprintf(avctx, "Junk at end of packet\n");
1474
        av_dlog(avctx, "Junk at end of packet\n");
1475 1475
        return -1;
1476 1476
    }
1477 1477

  
libavcodec/dvdsubdec.c
190 190
    while (cmd_pos > 0 && cmd_pos < buf_size - 2 - offset_size) {
191 191
        date = AV_RB16(buf + cmd_pos);
192 192
        next_cmd_pos = READ_OFFSET(buf + cmd_pos + 2);
193
        dprintf(NULL, "cmd_pos=0x%04x next=0x%04x date=%d\n",
193
        av_dlog(NULL, "cmd_pos=0x%04x next=0x%04x date=%d\n",
194 194
                cmd_pos, next_cmd_pos, date);
195 195
        pos = cmd_pos + 2 + offset_size;
196 196
        offset1 = -1;
......
198 198
        x1 = y1 = x2 = y2 = 0;
199 199
        while (pos < buf_size) {
200 200
            cmd = buf[pos++];
201
            dprintf(NULL, "cmd=%02x\n", cmd);
201
            av_dlog(NULL, "cmd=%02x\n", cmd);
202 202
            switch(cmd) {
203 203
            case 0x00:
204 204
                /* menu subpicture */
......
231 231
                alpha[1] = buf[pos + 1] >> 4;
232 232
                alpha[0] = buf[pos + 1] & 0x0f;
233 233
                pos += 2;
234
            dprintf(NULL, "alpha=%x%x%x%x\n", alpha[0],alpha[1],alpha[2],alpha[3]);
234
            av_dlog(NULL, "alpha=%x%x%x%x\n", alpha[0],alpha[1],alpha[2],alpha[3]);
235 235
                break;
236 236
            case 0x05:
237 237
            case 0x85:
......
243 243
                y2 = ((buf[pos + 4] & 0x0f) << 8) | buf[pos + 5];
244 244
                if (cmd & 0x80)
245 245
                    is_8bit = 1;
246
                dprintf(NULL, "x1=%d x2=%d y1=%d y2=%d\n", x1, x2, y1, y2);
246
                av_dlog(NULL, "x1=%d x2=%d y1=%d y2=%d\n", x1, x2, y1, y2);
247 247
                pos += 6;
248 248
                break;
249 249
            case 0x06:
......
251 251
                    goto fail;
252 252
                offset1 = AV_RB16(buf + pos);
253 253
                offset2 = AV_RB16(buf + pos + 2);
254
                dprintf(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
254
                av_dlog(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
255 255
                pos += 4;
256 256
                break;
257 257
            case 0x86:
......
259 259
                    goto fail;
260 260
                offset1 = AV_RB32(buf + pos);
261 261
                offset2 = AV_RB32(buf + pos + 4);
262
                dprintf(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
262
                av_dlog(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
263 263
                pos += 8;
264 264
                break;
265 265

  
......
282 282
            case 0xff:
283 283
                goto the_end;
284 284
            default:
285
                dprintf(NULL, "unrecognised subpicture command 0x%x\n", cmd);
285
                av_dlog(NULL, "unrecognised subpicture command 0x%x\n", cmd);
286 286
                goto the_end;
287 287
            }
288 288
        }
......
475 475
        goto no_subtitle;
476 476

  
477 477
#if defined(DEBUG)
478
    dprintf(NULL, "start=%d ms end =%d ms\n",
478
    av_dlog(NULL, "start=%d ms end =%d ms\n",
479 479
            sub->start_display_time,
480 480
            sub->end_display_time);
481 481
    ppm_save("/tmp/a.ppm", sub->rects[0]->pict.data[0],
libavcodec/gifdec.c
77 77
    has_local_palette = flags & 0x80;
78 78
    bits_per_pixel = (flags & 0x07) + 1;
79 79

  
80
    dprintf(s->avctx, "gif: image x=%d y=%d w=%d h=%d\n", left, top, width, height);
80
    av_dlog(s->avctx, "gif: image x=%d y=%d w=%d h=%d\n", left, top, width, height);
81 81

  
82 82
    if (has_local_palette) {
83 83
        bytestream_get_buffer(&s->bytestream, s->local_palette, 3 * (1 << bits_per_pixel));
......
163 163
    ext_code = bytestream_get_byte(&s->bytestream);
164 164
    ext_len = bytestream_get_byte(&s->bytestream);
165 165

  
166
    dprintf(s->avctx, "gif: ext_code=0x%x len=%d\n", ext_code, ext_len);
166
    av_dlog(s->avctx, "gif: ext_code=0x%x len=%d\n", ext_code, ext_len);
167 167

  
168 168
    switch(ext_code) {
169 169
    case 0xf9:
......
179 179
            s->transparent_color_index = -1;
180 180
        s->gce_disposal = (gce_flags >> 2) & 0x7;
181 181

  
182
        dprintf(s->avctx, "gif: gce_flags=%x delay=%d tcolor=%d disposal=%d\n",
182
        av_dlog(s->avctx, "gif: gce_flags=%x delay=%d tcolor=%d disposal=%d\n",
183 183
               gce_flags, s->gce_delay,
184 184
               s->transparent_color_index, s->gce_disposal);
185 185

  
......
194 194
            bytestream_get_byte(&s->bytestream);
195 195
        ext_len = bytestream_get_byte(&s->bytestream);
196 196

  
197
        dprintf(s->avctx, "gif: ext_len1=%d\n", ext_len);
197
        av_dlog(s->avctx, "gif: ext_len1=%d\n", ext_len);
198 198
    }
199 199
    return 0;
200 200
}
......
231 231
    s->background_color_index = bytestream_get_byte(&s->bytestream);
232 232
    bytestream_get_byte(&s->bytestream);                /* ignored */
233 233

  
234
    dprintf(s->avctx, "gif: screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
234
    av_dlog(s->avctx, "gif: screen_w=%d screen_h=%d bpp=%d global_palette=%d\n",
235 235
           s->screen_width, s->screen_height, s->bits_per_pixel,
236 236
           has_global_palette);
237 237

  
......
249 249
    while (s->bytestream < s->bytestream_end) {
250 250
        int code = bytestream_get_byte(&s->bytestream);
251 251

  
252
        dprintf(s->avctx, "gif: code=%02x '%c'\n", code, code);
252
        av_dlog(s->avctx, "gif: code=%02x '%c'\n", code, code);
253 253

  
254 254
        switch (code) {
255 255
        case ',':
libavcodec/h261dec.c
553 553
    int ret;
554 554
    AVFrame *pict = data;
555 555

  
556
    dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
557
    dprintf(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
556
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
557
    av_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
558 558
    s->flags= avctx->flags;
559 559
    s->flags2= avctx->flags2;
560 560

  
libavcodec/ituh263dec.c
325 325
   code >>= 1;
326 326

  
327 327
   code = (sign) ? (pred - code) : (pred + code);
328
   dprintf(s->avctx,"H.263+ UMV Motion = %d\n", code);
328
   av_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
329 329
   return code;
330 330

  
331 331
}
......
951 951
        if (ufep == 1) {
952 952
            /* OPPTYPE */
953 953
            format = get_bits(&s->gb, 3);
954
            dprintf(s->avctx, "ufep=1, format: %d\n", format);
954
            av_dlog(s->avctx, "ufep=1, format: %d\n", format);
955 955
            s->custom_pcf= get_bits1(&s->gb);
956 956
            s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
957 957
            if (get_bits1(&s->gb) != 0) {
......
1002 1002
            if (format == 6) {
1003 1003
                /* Custom Picture Format (CPFMT) */
1004 1004
                s->aspect_ratio_info = get_bits(&s->gb, 4);
1005
                dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
1005
                av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
1006 1006
                /* aspect ratios:
1007 1007
                0 - forbidden
1008 1008
                1 - 1:1
......
1015 1015
                width = (get_bits(&s->gb, 9) + 1) * 4;
1016 1016
                skip_bits1(&s->gb);
1017 1017
                height = get_bits(&s->gb, 9) * 4;
1018
                dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1018
                av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1019 1019
                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
1020 1020
                    /* aspected dimensions */
1021 1021
                    s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
libavcodec/mjpegdec.c
1255 1255
    }
1256 1256
    val = -1;
1257 1257
found:
1258
    dprintf(NULL, "find_marker skipped %d bytes\n", skipped);
1258
    av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
1259 1259
    *pbuf_ptr = buf_ptr;
1260 1260
    return val;
1261 1261
}
libavcodec/mpeg12.c
213 213
    int i, j, k, cbp, val, mb_type, motion_type;
214 214
    const int mb_block_count = 4 + (1<< s->chroma_format);
215 215

  
216
    dprintf(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
216
    av_dlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
217 217

  
218 218
    assert(s->mb_skipped==0);
219 219

  
......
272 272
        mb_type = btype2mb_type[ mb_type ];
273 273
        break;
274 274
    }
275
    dprintf(s->avctx, "mb_type=%x\n", mb_type);
275
    av_dlog(s->avctx, "mb_type=%x\n", mb_type);
276 276
//    motion_type = 0; /* avoid warning */
277 277
    if (IS_INTRA(mb_type)) {
278 278
        s->dsp.clear_blocks(s->block[0]);
......
370 370

  
371 371
            /* motion vectors */
372 372
            s->mv_dir= (mb_type>>13)&3;
373
            dprintf(s->avctx, "motion_type=%d\n", motion_type);
373
            av_dlog(s->avctx, "motion_type=%d\n", motion_type);
374 374
            switch(motion_type) {
375 375
            case MT_FRAME: /* or MT_16X8 */
376 376
                if (s->picture_structure == PICT_FRAME) {
......
421 421
                                                         s->last_mv[i][j][0]);
422 422
                                s->last_mv[i][j][0] = val;
423 423
                                s->mv[i][j][0] = val;
424
                                dprintf(s->avctx, "fmx=%d\n", val);
424
                                av_dlog(s->avctx, "fmx=%d\n", val);
425 425
                                val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
426 426
                                                         s->last_mv[i][j][1] >> 1);
427 427
                                s->last_mv[i][j][1] = val << 1;
428 428
                                s->mv[i][j][1] = val;
429
                                dprintf(s->avctx, "fmy=%d\n", val);
429
                                av_dlog(s->avctx, "fmy=%d\n", val);
430 430
                            }
431 431
                        }
432 432
                    }
......
632 632
    dc += diff;
633 633
    s->last_dc[component] = dc;
634 634
    block[0] = dc*quant_matrix[0];
635
    dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
635
    av_dlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
636 636
    i = 0;
637 637
    {
638 638
        OPEN_READER(re, &s->gb);
......
1012 1012
    dc += diff;
1013 1013
    s->last_dc[component] = dc;
1014 1014
    block[0] = dc << (3 - s->intra_dc_precision);
1015
    dprintf(s->avctx, "dc=%d\n", block[0]);
1015
    av_dlog(s->avctx, "dc=%d\n", block[0]);
1016 1016
    mismatch = block[0] ^ 1;
1017 1017
    i = 0;
1018 1018
    if (s->intra_vlc_format)
......
1386 1386
    s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
1387 1387
    s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1388 1388

  
1389
    dprintf(s->avctx, "sequence extension\n");
1389
    av_dlog(s->avctx, "sequence extension\n");
1390 1390
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1391 1391
    s->avctx->sub_id = 2; /* indicates MPEG-2 found */
1392 1392

  
......
1477 1477

  
1478 1478
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1479 1479
{
1480
    dprintf(s->avctx, "matrix extension\n");
1480
    av_dlog(s->avctx, "matrix extension\n");
1481 1481

  
1482 1482
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1483 1483
    if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
......
1551 1551
    }
1552 1552

  
1553 1553
    /* composite display not parsed */
1554
    dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1555
    dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
1556
    dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
1557
    dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1558
    dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1559
    dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1560
    dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1561
    dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1562
    dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1554
    av_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1555
    av_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1556
    av_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1557
    av_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1558
    av_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1559
    av_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1560
    av_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1561
    av_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1562
    av_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1563 1563
}
1564 1564

  
1565 1565
static void exchange_uv(MpegEncContext *s){
......
2200 2200
    Mpeg1Context *s = avctx->priv_data;
2201 2201
    AVFrame *picture = data;
2202 2202
    MpegEncContext *s2 = &s->mpeg_enc_ctx;
2203
    dprintf(avctx, "fill_buffer\n");
2203
    av_dlog(avctx, "fill_buffer\n");
2204 2204

  
2205 2205
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2206 2206
        /* special case for last picture */
......
2524 2524
    if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2525 2525
        return -1;
2526 2526
    if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2527
        dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2527
        av_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2528 2528
    }
2529 2529
    mpeg_decode_init(avctx);
2530 2530

  
libavcodec/mpeg12enc.c
890 890
    next_coef:
891 891
#if 0
892 892
        if (level != 0)
893
            dprintf(s->avctx, "level[%d]=%d\n", i, level);
893
            av_dlog(s->avctx, "level[%d]=%d\n", i, level);
894 894
#endif
895 895
        /* encode using VLC */
896 896
        if (level != 0) {
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;
libavcodec/mpegaudiodecheader.c
91 91
    }
92 92

  
93 93
#if defined(DEBUG)
94
    dprintf(NULL, "layer%d, %d Hz, %d kbits/s, ",
94
    av_dlog(NULL, "layer%d, %d Hz, %d kbits/s, ",
95 95
           s->layer, s->sample_rate, s->bit_rate);
96 96
    if (s->nb_channels == 2) {
97 97
        if (s->layer == 3) {
98 98
            if (s->mode_ext & MODE_EXT_MS_STEREO)
99
                dprintf(NULL, "ms-");
99
                av_dlog(NULL, "ms-");
100 100
            if (s->mode_ext & MODE_EXT_I_STEREO)
101
                dprintf(NULL, "i-");
101
                av_dlog(NULL, "i-");
102 102
        }
103
        dprintf(NULL, "stereo");
103
        av_dlog(NULL, "stereo");
104 104
    } else {
105
        dprintf(NULL, "mono");
105
        av_dlog(NULL, "mono");
106 106
    }
107
    dprintf(NULL, "\n");
107
    av_dlog(NULL, "\n");
108 108
#endif
109 109
    return 0;
110 110
}
libavcodec/mpegaudioenc.c
122 122
    s->sblimit = ff_mpa_sblimit_table[table];
123 123
    s->alloc_table = ff_mpa_alloc_tables[table];
124 124

  
125
    dprintf(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
125
    av_dlog(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
126 126
            bitrate, freq, s->frame_size, table, s->frame_frac_incr);
127 127

  
128 128
    for(i=0;i<s->nb_channels;i++)
libavcodec/pcm-mpeg.c
64 64
    uint8_t channel_layout = header[2] >> 4;
65 65

  
66 66
    if (avctx->debug & FF_DEBUG_PICT_INFO)
67
        dprintf(avctx, "pcm_bluray_parse_header: header = %02x%02x%02x%02x\n",
67
        av_dlog(avctx, "pcm_bluray_parse_header: header = %02x%02x%02x%02x\n",
68 68
                header[0], header[1], header[2], header[3]);
69 69

  
70 70
    /* get the sample depth and derive the sample format from it */
......
112 112
                      avctx->bits_per_coded_sample;
113 113

  
114 114
    if (avctx->debug & FF_DEBUG_PICT_INFO)
115
        dprintf(avctx,
115
        av_dlog(avctx,
116 116
                "pcm_bluray_parse_header: %d channels, %d bits per sample, %d kHz, %d kbit\n",
117 117
                avctx->channels, avctx->bits_per_coded_sample,
118 118
                avctx->sample_rate, avctx->bit_rate);
......
291 291

  
292 292
    retval = src - avpkt->data;
293 293
    if (avctx->debug & FF_DEBUG_BITSTREAM)
294
        dprintf(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
294
        av_dlog(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
295 295
                retval, *data_size);
296 296
    return retval;
297 297
}
libavcodec/pgssubdec.c
141 141
        return -1;
142 142
    }
143 143

  
144
    dprintf(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, sub->rects[0]->w * sub->rects[0]->h);
144
    av_dlog(avctx, "Pixel Count = %d, Area = %d\n", pixel_count, sub->rects[0]->w * sub->rects[0]->h);
145 145

  
146 146
    return 0;
147 147
}
......
253 253
        YUV_TO_RGB1(cb, cr);
254 254
        YUV_TO_RGB2(r, g, b, y);
255 255

  
256
        dprintf(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);
256
        av_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);
257 257

  
258 258
        /* Store color in palette */
259 259
        ctx->clut[color_id] = RGBA(r,g,b,alpha);
......
282 282
    int w = bytestream_get_be16(&buf);
283 283
    int h = bytestream_get_be16(&buf);
284 284

  
285
    dprintf(avctx, "Video Dimensions %dx%d\n",
285
    av_dlog(avctx, "Video Dimensions %dx%d\n",
286 286
            w, h);
287 287
    if (av_image_check_size(w, h, 0, avctx) >= 0)
288 288
        avcodec_set_dimensions(avctx, w, h);
......
317 317

  
318 318
    /* TODO If cropping, cropping_x, cropping_y, cropping_width, cropping_height (all 2 bytes).*/
319 319

  
320
    dprintf(avctx, "Subtitle Placement x=%d, y=%d\n", x, y);
320
    av_dlog(avctx, "Subtitle Placement x=%d, y=%d\n", x, y);
321 321

  
322 322
    if (x > avctx->width || y > avctx->height) {
323 323
        av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n",
......
433 433
        segment_type   = bytestream_get_byte(&buf);
434 434
        segment_length = bytestream_get_be16(&buf);
435 435

  
436
        dprintf(avctx, "Segment Length %d, Segment Type %x\n", segment_length, segment_type);
436
        av_dlog(avctx, "Segment Length %d, Segment Type %x\n", segment_length, segment_type);
437 437

  
438 438
        if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf)
439 439
            break;
libavcodec/pngdec.c
431 431
            goto fail;
432 432
        tag32 = bytestream_get_be32(&s->bytestream);
433 433
        tag = av_bswap32(tag32);
434
        dprintf(avctx, "png: tag=%c%c%c%c length=%u\n",
434
        av_dlog(avctx, "png: tag=%c%c%c%c length=%u\n",
435 435
                (tag & 0xff),
436 436
                ((tag >> 8) & 0xff),
437 437
                ((tag >> 16) & 0xff),
......
453 453
            s->interlace_type = *s->bytestream++;
454 454
            crc = bytestream_get_be32(&s->bytestream);
455 455
            s->state |= PNG_IHDR;
456
            dprintf(avctx, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
456
            av_dlog(avctx, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
457 457
                    s->width, s->height, s->bit_depth, s->color_type,
458 458
                    s->compression_type, s->filter_type, s->interlace_type);
459 459
            break;
......
517 517
                                                         s->width);
518 518
                    s->crow_size = s->pass_row_size + 1;
519 519
                }
520
                dprintf(avctx, "row_size=%d crow_size =%d\n",
520
                av_dlog(avctx, "row_size=%d crow_size =%d\n",
521 521
                        s->row_size, s->crow_size);
522 522
                s->image_buf = p->data[0];
523 523
                s->image_linesize = p->linesize[0];
libavcodec/rv10.c
246 246
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
247 247
    pb_frame = get_bits1(&s->gb);
248 248

  
249
    dprintf(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
249
    av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
250 250

  
251 251
    if (pb_frame){
252 252
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
......
265 265
            s->last_dc[0] = get_bits(&s->gb, 8);
266 266
            s->last_dc[1] = get_bits(&s->gb, 8);
267 267
            s->last_dc[2] = get_bits(&s->gb, 8);
268
            dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
268
            av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
269 269
                    s->last_dc[1], s->last_dc[2]);
270 270
        }
271 271
    }
......
561 561
        ff_er_frame_start(s);
562 562
    }
563 563

  
564
    dprintf(avctx, "qscale=%d\n", s->qscale);
564
    av_dlog(avctx, "qscale=%d\n", s->qscale);
565 565

  
566 566
    /* default quantization values */
567 567
    if(s->codec_id== CODEC_ID_RV10){
......
600 600
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
601 601
        int ret;
602 602
        ff_update_block_index(s);
603
        dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
603
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
604 604

  
605 605
        s->mv_dir = MV_DIR_FORWARD;
606 606
        s->mv_type = MV_TYPE_16X16;
......
655 655
    int slice_count;
656 656
    const uint8_t *slices_hdr = NULL;
657 657

  
658
    dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
658
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
659 659

  
660 660
    /* no supplementary picture */
661 661
    if (buf_size == 0) {
libavcodec/shorten.c
305 305
        s->bitstream_size= buf_size;
306 306

  
307 307
        if(buf_size < s->max_framesize){
308
            //dprintf(avctx, "wanna more data ... %d\n", buf_size);
308
            //av_dlog(avctx, "wanna more data ... %d\n", buf_size);
309 309
            *data_size = 0;
310 310
            return input_buf_size;
311 311
        }
libavcodec/vaapi.c
180 180
    struct vaapi_context * const vactx = s->avctx->hwaccel_context;
181 181
    int ret = -1;
182 182

  
183
    dprintf(s->avctx, "ff_vaapi_common_end_frame()\n");
183
    av_dlog(s->avctx, "ff_vaapi_common_end_frame()\n");
184 184

  
185 185
    if (commit_slices(vactx) < 0)
186 186
        goto done;
libavcodec/vaapi_h264.c
227 227
    VAPictureParameterBufferH264 *pic_param;
228 228
    VAIQMatrixBufferH264 *iq_matrix;
229 229

  
230
    dprintf(avctx, "start_frame()\n");
230
    av_dlog(avctx, "start_frame()\n");
231 231

  
232 232
    vactx->slice_param_size = sizeof(VASliceParameterBufferH264);
233 233

  
......
289 289
{
290 290
    H264Context * const h = avctx->priv_data;
291 291

  
292
    dprintf(avctx, "end_frame()\n");
292
    av_dlog(avctx, "end_frame()\n");
293 293
    return ff_vaapi_common_end_frame(&h->s);
294 294
}
295 295

  
......
302 302
    MpegEncContext * const s = &h->s;
303 303
    VASliceParameterBufferH264 *slice_param;
304 304

  
305
    dprintf(avctx, "decode_slice(): buffer %p, size %d\n", buffer, size);
305
    av_dlog(avctx, "decode_slice(): buffer %p, size %d\n", buffer, size);
306 306

  
307 307
    /* Fill in VASliceParameterBufferH264. */
308 308
    slice_param = (VASliceParameterBufferH264 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);
libavcodec/vaapi_mpeg2.c
44 44
    VAIQMatrixBufferMPEG2 *iq_matrix;
45 45
    int i;
46 46

  
47
    dprintf(avctx, "vaapi_mpeg2_start_frame()\n");
47
    av_dlog(avctx, "vaapi_mpeg2_start_frame()\n");
48 48

  
49 49
    vactx->slice_param_size = sizeof(VASliceParameterBufferMPEG2);
50 50

  
......
111 111
    GetBitContext gb;
112 112
    uint32_t start_code, quantiser_scale_code, intra_slice_flag, macroblock_offset;
113 113

  
114
    dprintf(avctx, "vaapi_mpeg2_decode_slice(): buffer %p, size %d\n", buffer, size);
114
    av_dlog(avctx, "vaapi_mpeg2_decode_slice(): buffer %p, size %d\n", buffer, size);
115 115

  
116 116
    /* Determine macroblock_offset */
117 117
    init_get_bits(&gb, buffer, 8 * size);
libavcodec/vaapi_mpeg4.c
47 47
    VAIQMatrixBufferMPEG4 *iq_matrix;
48 48
    int i;
49 49

  
50
    dprintf(avctx, "vaapi_mpeg4_start_frame()\n");
50
    av_dlog(avctx, "vaapi_mpeg4_start_frame()\n");
51 51

  
52 52
    vactx->slice_param_size = sizeof(VASliceParameterBufferMPEG4);
53 53

  
......
125 125
    MpegEncContext * const s = avctx->priv_data;
126 126
    VASliceParameterBufferMPEG4 *slice_param;
127 127

  
128
    dprintf(avctx, "vaapi_mpeg4_decode_slice(): buffer %p, size %d\n", buffer, size);
128
    av_dlog(avctx, "vaapi_mpeg4_decode_slice(): buffer %p, size %d\n", buffer, size);
129 129

  
130 130
    /* video_plane_with_short_video_header() contains all GOBs
131 131
     * in-order, and this is what VA API (Intel backend) expects: only
libavcodec/vaapi_vc1.c
138 138
    struct vaapi_context * const vactx = avctx->hwaccel_context;
139 139
    VAPictureParameterBufferVC1 *pic_param;
140 140

  
141
    dprintf(avctx, "vaapi_vc1_start_frame()\n");
141
    av_dlog(avctx, "vaapi_vc1_start_frame()\n");
142 142

  
143 143
    vactx->slice_param_size = sizeof(VASliceParameterBufferVC1);
144 144

  
......
308 308
    MpegEncContext * const s = &v->s;
309 309
    VASliceParameterBufferVC1 *slice_param;
310 310

  
311
    dprintf(avctx, "vaapi_vc1_decode_slice(): buffer %p, size %d\n", buffer, size);
311
    av_dlog(avctx, "vaapi_vc1_decode_slice(): buffer %p, size %d\n", buffer, size);
312 312

  
313 313
    /* Current bit buffer is beyond any marker for VC-1, so skip it */
314 314
    if (avctx->codec_id == CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {
libavcodec/wma.c
217 217
            high_freq = high_freq * 0.5;
218 218
        }
219 219
    }
220
    dprintf(s->avctx, "flags2=0x%x\n", flags2);
221
    dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
220
    av_dlog(s->avctx, "flags2=0x%x\n", flags2);
221
    av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
222 222
            s->version, s->nb_channels, s->sample_rate, s->bit_rate,
223 223
            s->block_align);
224
    dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
224
    av_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
225 225
            bps, bps1, high_freq, s->byte_offset_bits);
226
    dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
226
    av_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
227 227
            s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
228 228

  
229 229
    /* compute the scale factor band sizes for each MDCT block size */
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

  
libavfilter/avfilter.c
217 217
    return buf;
218 218
}
219 219

  
220
static void ff_dprintf_ref(void *ctx, AVFilterBufferRef *ref, int end)
220
static void ff_dlog_ref(void *ctx, AVFilterBufferRef *ref, int end)
221 221
{
222 222
    av_unused char buf[16];
223
    dprintf(ctx,
223
    av_dlog(ctx,
224 224
            "ref[%p buf:%p refcount:%d perms:%s data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
225 225
            ref, ref->buf, ref->buf->refcount, ff_get_ref_perms_string(buf, sizeof(buf), ref->perms), ref->data[0],
226 226
            ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
227 227
            ref->pts, ref->pos);
228 228

  
229 229
    if (ref->video) {
230
        dprintf(ctx, " a:%d/%d s:%dx%d i:%c",
230
        av_dlog(ctx, " a:%d/%d s:%dx%d i:%c",
231 231
                ref->video->pixel_aspect.num, ref->video->pixel_aspect.den,
232 232
                ref->video->w, ref->video->h,
233 233
                !ref->video->interlaced     ? 'P' :         /* Progressive  */
234 234
                ref->video->top_field_first ? 'T' : 'B');   /* Top / Bottom */
235 235
    }
236 236
    if (ref->audio) {
237
        dprintf(ctx, " cl:%"PRId64"d sn:%d s:%d sr:%d p:%d",
237
        av_dlog(ctx, " cl:%"PRId64"d sn:%d s:%d sr:%d p:%d",
238 238
                ref->audio->channel_layout,
239 239
                ref->audio->nb_samples,
240 240
                ref->audio->size,
......
242 242
                ref->audio->planar);
243 243
    }
244 244

  
245
    dprintf(ctx, "]%s", end ? "\n" : "");
245
    av_dlog(ctx, "]%s", end ? "\n" : "");
246 246
}
247 247

  
248
static void ff_dprintf_link(void *ctx, AVFilterLink *link, int end)
248
static void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
249 249
{
250 250
    if (link->type == AVMEDIA_TYPE_VIDEO) {
251
        dprintf(ctx,
251
        av_dlog(ctx,
252 252
                "link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s",
253 253
                link, link->w, link->h,
254 254
                av_pix_fmt_descriptors[link->format].name,
......
259 259
        char buf[128];
260 260
        av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
261 261

  
262
        dprintf(ctx,
262
        av_dlog(ctx,
263 263
                "link[%p r:%"PRId64" cl:%s fmt:%-16s %-16s->%-16s]%s",
264 264
                link, link->sample_rate, buf,
265 265
                av_get_sample_fmt_name(link->format),
......
269 269
    }
270 270
}
271 271

  
272
#define FF_DPRINTF_START(ctx, func) dprintf(NULL, "%-16s: ", #func)
272
#define FF_DPRINTF_START(ctx, func) av_dlog(NULL, "%-16s: ", #func)
273 273

  
274 274
AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
275 275
{
276 276
    AVFilterBufferRef *ret = NULL;
277 277

  
278 278
    av_unused char buf[16];
279
    FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0);
280
    dprintf(NULL, " perms:%s w:%d h:%d\n", ff_get_ref_perms_string(buf, sizeof(buf), perms), w, h);
279
    FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0);
280
    av_dlog(NULL, " perms:%s w:%d h:%d\n", ff_get_ref_perms_string(buf, sizeof(buf), perms), w, h);
281 281

  
282 282
    if (link->dstpad->get_video_buffer)
283 283
        ret = link->dstpad->get_video_buffer(link, perms, w, h);
......
288 288
    if (ret)
289 289
        ret->type = AVMEDIA_TYPE_VIDEO;
290 290

  
291
    FF_DPRINTF_START(NULL, get_video_buffer); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " returning "); ff_dprintf_ref(NULL, ret, 1);
291
    FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " returning "); ff_dlog_ref(NULL, ret, 1);
292 292

  
293 293
    return ret;
294 294
}
......
353 353

  
354 354
int avfilter_request_frame(AVFilterLink *link)
355 355
{
356
    FF_DPRINTF_START(NULL, request_frame); ff_dprintf_link(NULL, link, 1);
356
    FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);
357 357

  
358 358
    if (link->srcpad->request_frame)
359 359
        return link->srcpad->request_frame(link);
......
388 388
    AVFilterPad *dst = link->dstpad;
389 389
    int perms = picref->perms;
390 390

  
391
    FF_DPRINTF_START(NULL, start_frame); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " "); ff_dprintf_ref(NULL, picref, 1);
391
    FF_DPRINTF_START(NULL, start_frame); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " "); ff_dlog_ref(NULL, picref, 1);
392 392

  
393 393
    if (!(start_frame = dst->start_frame))
394 394
        start_frame = avfilter_default_start_frame;
......
435 435
    int i, j, vsub;
436 436
    void (*draw_slice)(AVFilterLink *, int, int, int);
437 437

  
438
    FF_DPRINTF_START(NULL, draw_slice); ff_dprintf_link(NULL, link, 0); dprintf(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
438
    FF_DPRINTF_START(NULL, draw_slice); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
439 439

  
440 440
    /* copy the slice if needed for permission reasons */
441 441
    if (link->src_buf) {
libavformat/asfdec.c
57 57
#ifdef DEBUG
58 58
#define PRINT_IF_GUID(g,cmp) \
59 59
if (!ff_guidcmp(g, &cmp)) \
60
    dprintf(NULL, "(GUID: %s) ", #cmp)
60
    av_dlog(NULL, "(GUID: %s) ", #cmp)
61 61

  
62 62
static void print_guid(const ff_asf_guid *g)
63 63
{
......
87 87
    else PRINT_IF_GUID(g, stream_bitrate_guid);
88 88
    else PRINT_IF_GUID(g, ff_asf_language_guid);
89 89
    else
90
        dprintf(NULL, "(GUID: unknown) ");
90
        av_dlog(NULL, "(GUID: unknown) ");
91 91
    for(i=0;i<16;i++)
92
        dprintf(NULL, " 0x%02x,", (*g)[i]);
93
    dprintf(NULL, "}\n");
92
        av_dlog(NULL, " 0x%02x,", (*g)[i]);
93
    av_dlog(NULL, "}\n");
94 94
}
95 95
#undef PRINT_IF_GUID
96 96
#else
......
177 177
        int ret;
178 178
        ff_get_guid(pb, &g);
179 179
        gsize = get_le64(pb);
180
        dprintf(s, "%08"PRIx64": ", gpos);
180
        av_dlog(s, "%08"PRIx64": ", gpos);
181 181
        print_guid(&g);
182
        dprintf(s, "  size=0x%"PRIx64"\n", gsize);
182
        av_dlog(s, "  size=0x%"PRIx64"\n", gsize);
183 183
        if (!ff_guidcmp(&g, &ff_asf_data_header)) {
184 184
            asf->data_object_offset = url_ftell(pb);
185 185
            // if not streaming, gsize is not unlimited (how?), and there is enough space in the file..
......
704 704
    if (packet_length < asf->hdr.min_pktsize)
705 705
        padsize += asf->hdr.min_pktsize - packet_length;
706 706
    asf->packet_padsize = padsize;
707
    dprintf(s, "packet: size=%d padsize=%d  left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
707
    av_dlog(s, "packet: size=%d padsize=%d  left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
708 708
    return 0;
709 709
}
710 710

  
libavformat/avidec.c
85 85
static int guess_ni_flag(AVFormatContext *s);
86 86

  
87 87
#define print_tag(str, tag, size)                       \
88
    dprintf(NULL, "%s: tag=%c%c%c%c size=0x%x\n",       \
88
    av_dlog(NULL, "%s: tag=%c%c%c%c size=0x%x\n",       \
89 89
           str, tag & 0xff,                             \
90 90
           (tag >> 8) & 0xff,                           \
91 91
           (tag >> 16) & 0xff,                          \
......
380 380
                avi->movi_list = url_ftell(pb) - 4;
381 381
                if(size) avi->movi_end = avi->movi_list + size + (size & 1);
382 382
                else     avi->movi_end = url_fsize(pb);
383
                dprintf(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
383
                av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
384 384
                goto end_of_header;
385 385
            }
386 386
            else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
libavformat/ffmdec.c
408 408
        if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
409 409
            return ret;
410 410

  
411
        dprintf(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
411
        av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
412 412
               url_ftell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);
413 413
        if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
414 414
            FRAME_HEADER_SIZE)
libavformat/flvdec.c
424 424
                    st->codec->sample_rate = cfg.ext_sample_rate;
425 425
                else
426 426
                    st->codec->sample_rate = cfg.sample_rate;
427
                dprintf(s, "mp4a config channels %d sample rate %d\n",
427
                av_dlog(s, "mp4a config channels %d sample rate %d\n",
428 428
                        st->codec->channels, st->codec->sample_rate);
429 429
            }
430 430

  
libavformat/http.c
225 225
            p++;
226 226
        s->http_code = strtol(p, &end, 10);
227 227

  
228
        dprintf(NULL, "http_code=%d\n", s->http_code);
228
        av_dlog(NULL, "http_code=%d\n", s->http_code);
229 229

  
230 230
        /* error codes are 4xx and 5xx, but regard 401 as a success, so we
231 231
         * don't abort until all headers have been parsed. */
......
356 356
        if (http_get_line(s, line, sizeof(line)) < 0)
357 357
            return AVERROR(EIO);
358 358

  
359
        dprintf(NULL, "header='%s'\n", line);
359
        av_dlog(NULL, "header='%s'\n", line);
360 360

  
361 361
        err = process_line(h, line, s->line_count, new_location);
362 362
        if (err < 0)
......
387 387

  
388 388
                s->chunksize = strtoll(line, NULL, 16);
389 389

  
390
                dprintf(NULL, "Chunked encoding data size: %"PRId64"'\n", s->chunksize);
390
                av_dlog(NULL, "Chunked encoding data size: %"PRId64"'\n", s->chunksize);
391 391

  
392 392
                if (!s->chunksize)
393 393
                    return 0;
libavformat/isom.c
350 350
    int len;
351 351
    *tag = get_byte(pb);
352 352
    len = ff_mp4_read_descr_len(pb);
353
    dprintf(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
353
    av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
354 354
    return len;
355 355
}
356 356

  
......
373 373
    get_be32(pb); /* avg bitrate */
374 374

  
375 375
    st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
376
    dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
376
    av_dlog(fc, "esds object type id 0x%02x\n", object_type_id);
377 377
    len = ff_mp4_read_descr(fc, pb, &tag);
378 378
    if (tag == MP4DecSpecificDescrTag) {
379
        dprintf(fc, "Specific MPEG4 header len=%d\n", len);
379
        av_dlog(fc, "Specific MPEG4 header len=%d\n", len);
380 380
        if((uint64_t)len > (1<<30))
381 381
            return -1;
382 382
        av_free(st->codec->extradata);
......
396 396
                st->codec->sample_rate = cfg.ext_sample_rate;
397 397
            else
398 398
                st->codec->sample_rate = cfg.sample_rate;
399
            dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
399
            av_dlog(fc, "mp4a config channels %d obj %d ext obj %d "
400 400
                    "sample rate %d ext sample rate %d\n", st->codec->channels,
401 401
                    cfg.object_type, cfg.ext_object_type,
402 402
                    cfg.sample_rate, cfg.ext_sample_rate);
libavformat/mmsh.c
122 122
        return AVERROR(EIO);
123 123
    }
124 124
    res = url_read_complete(mms->mms_hd, mms->in_buffer, len);
125
    dprintf(NULL, "Data packet len = %d\n", len);
125
    av_dlog(NULL, "Data packet len = %d\n", len);
126 126
    if (res != len) {
127 127
        av_log(NULL, AV_LOG_ERROR, "Read data packet failed!\n");
128 128
        return AVERROR(EIO);
......
156 156
                if (mms->asf_header) {
157 157
                    if (len != mms->asf_header_size) {
158 158
                        mms->asf_header_size = len;
159
                        dprintf(NULL, "Header len changed from %d to %d\n",
159
                        av_dlog(NULL, "Header len changed from %d to %d\n",
160 160
                                mms->asf_header_size, len);
161 161
                        av_freep(&mms->asf_header);
162 162
                    }
......
201 201
                    av_log(NULL, AV_LOG_ERROR, "Read other chunk type data failed!\n");
202 202
                    return AVERROR(EIO);
203 203
                } else {
204
                    dprintf(NULL, "Skip chunk type %d \n", chunk_type);
204
                    av_dlog(NULL, "Skip chunk type %d \n", chunk_type);
205 205
                    continue;
206 206
                }
207 207
            }
......
290 290
        av_log(NULL, AV_LOG_ERROR, "Build play request failed!\n");
291 291
        goto fail;
292 292
    }
293
    dprintf(NULL, "out_buffer is %s", headers);
293
    av_dlog(NULL, "out_buffer is %s", headers);
294 294
    ff_http_set_headers(mms->mms_hd, headers);
295 295

  
296 296
    err = url_connect(mms->mms_hd);
......
304 304
        goto fail;
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff