falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Replace dprintf with av_dlog 

dprintf clashes with POSIX.1-2008
tags/n0.8
Luca Barbato 14 years ago
parent
243f8241db
commit
dfd2a005eb
47 changed files with 312 additions and 308 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +18
    -18
      libavcodec/alsdec.c
  2. +5
    -5
      libavcodec/dnxhddec.c
  3. +4
    -4
      libavcodec/dnxhdenc.c
  4. +4
    -4
      libavcodec/dvbsub_parser.c
  5. +8
    -8
      libavcodec/dvbsubdec.c
  6. +8
    -8
      libavcodec/dvdsubdec.c
  7. +6
    -6
      libavcodec/gifdec.c
  8. +2
    -2
      libavcodec/h261dec.c
  9. +4
    -4
      libavcodec/ituh263dec.c
  10. +1
    -1
      libavcodec/mjpegdec.c
  11. +20
    -20
      libavcodec/mpeg12.c
  12. +1
    -1
      libavcodec/mpeg12enc.c
  13. +11
    -11
      libavcodec/mpegaudiodec.c
  14. +6
    -6
      libavcodec/mpegaudiodecheader.c
  15. +1
    -1
      libavcodec/mpegaudioenc.c
  16. +3
    -3
      libavcodec/pcm-mpeg.c
  17. +5
    -5
      libavcodec/pgssubdec.c
  18. +3
    -3
      libavcodec/pngdec.c
  19. +5
    -5
      libavcodec/rv10.c
  20. +1
    -1
      libavcodec/shorten.c
  21. +1
    -1
      libavcodec/vaapi.c
  22. +3
    -3
      libavcodec/vaapi_h264.c
  23. +2
    -2
      libavcodec/vaapi_mpeg2.c
  24. +2
    -2
      libavcodec/vaapi_mpeg4.c
  25. +2
    -2
      libavcodec/vaapi_vc1.c
  26. +4
    -4
      libavcodec/wma.c
  27. +16
    -16
      libavcodec/wmaprodec.c
  28. +15
    -15
      libavfilter/avfilter.c
  29. +7
    -7
      libavformat/asfdec.c
  30. +2
    -2
      libavformat/avidec.c
  31. +1
    -1
      libavformat/ffmdec.c
  32. +1
    -1
      libavformat/flvdec.c
  33. +3
    -3
      libavformat/http.c
  34. +4
    -4
      libavformat/isom.c
  35. +6
    -6
      libavformat/mmsh.c
  36. +10
    -10
      libavformat/mmst.c
  37. +36
    -36
      libavformat/mov.c
  38. +15
    -15
      libavformat/mpegts.c
  39. +1
    -1
      libavformat/mxf.h
  40. +12
    -12
      libavformat/mxfdec.c
  41. +30
    -30
      libavformat/r3d.c
  42. +2
    -2
      libavformat/rtpdec.c
  43. +3
    -3
      libavformat/rtpenc.c
  44. +5
    -5
      libavformat/rtsp.c
  45. +2
    -2
      libavformat/rtspdec.c
  46. +0
    -7
      libavutil/internal.h
  47. +11
    -0
      libavutil/log.h

+ 18
- 18
libavcodec/alsdec.c View File

@@ -253,24 +253,24 @@ static av_cold void dprint_specific_config(ALSDecContext *ctx)
AVCodecContext *avctx = ctx->avctx; AVCodecContext *avctx = ctx->avctx;
ALSSpecificConfig *sconf = &ctx->sconf; ALSSpecificConfig *sconf = &ctx->sconf;


dprintf(avctx, "resolution = %i\n", sconf->resolution);
dprintf(avctx, "floating = %i\n", sconf->floating);
dprintf(avctx, "frame_length = %i\n", sconf->frame_length);
dprintf(avctx, "ra_distance = %i\n", sconf->ra_distance);
dprintf(avctx, "ra_flag = %i\n", sconf->ra_flag);
dprintf(avctx, "adapt_order = %i\n", sconf->adapt_order);
dprintf(avctx, "coef_table = %i\n", sconf->coef_table);
dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
dprintf(avctx, "max_order = %i\n", sconf->max_order);
dprintf(avctx, "block_switching = %i\n", sconf->block_switching);
dprintf(avctx, "bgmc = %i\n", sconf->bgmc);
dprintf(avctx, "sb_part = %i\n", sconf->sb_part);
dprintf(avctx, "joint_stereo = %i\n", sconf->joint_stereo);
dprintf(avctx, "mc_coding = %i\n", sconf->mc_coding);
dprintf(avctx, "chan_config = %i\n", sconf->chan_config);
dprintf(avctx, "chan_sort = %i\n", sconf->chan_sort);
dprintf(avctx, "RLSLMS = %i\n", sconf->rlslms);
dprintf(avctx, "chan_config_info = %i\n", sconf->chan_config_info);
av_dlog(avctx, "resolution = %i\n", sconf->resolution);
av_dlog(avctx, "floating = %i\n", sconf->floating);
av_dlog(avctx, "frame_length = %i\n", sconf->frame_length);
av_dlog(avctx, "ra_distance = %i\n", sconf->ra_distance);
av_dlog(avctx, "ra_flag = %i\n", sconf->ra_flag);
av_dlog(avctx, "adapt_order = %i\n", sconf->adapt_order);
av_dlog(avctx, "coef_table = %i\n", sconf->coef_table);
av_dlog(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
av_dlog(avctx, "max_order = %i\n", sconf->max_order);
av_dlog(avctx, "block_switching = %i\n", sconf->block_switching);
av_dlog(avctx, "bgmc = %i\n", sconf->bgmc);
av_dlog(avctx, "sb_part = %i\n", sconf->sb_part);
av_dlog(avctx, "joint_stereo = %i\n", sconf->joint_stereo);
av_dlog(avctx, "mc_coding = %i\n", sconf->mc_coding);
av_dlog(avctx, "chan_config = %i\n", sconf->chan_config);
av_dlog(avctx, "chan_sort = %i\n", sconf->chan_sort);
av_dlog(avctx, "RLSLMS = %i\n", sconf->rlslms);
av_dlog(avctx, "chan_config_info = %i\n", sconf->chan_config_info);
#endif #endif
} }




+ 5
- 5
libavcodec/dnxhddec.c View File

@@ -107,7 +107,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_si
ctx->height = AV_RB16(buf + 0x18); ctx->height = AV_RB16(buf + 0x18);
ctx->width = AV_RB16(buf + 0x1a); ctx->width = AV_RB16(buf + 0x1a);


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


if (buf[0x21] & 0x40) { if (buf[0x21] & 0x40) {
av_log(ctx->avctx, AV_LOG_ERROR, "10 bit per component\n"); av_log(ctx->avctx, AV_LOG_ERROR, "10 bit per component\n");
@@ -115,7 +115,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_si
} }


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


if (dnxhd_init_vlc(ctx, ctx->cid) < 0) if (dnxhd_init_vlc(ctx, ctx->cid) < 0)
return -1; return -1;
@@ -128,7 +128,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_si
ctx->mb_width = ctx->width>>4; ctx->mb_width = ctx->width>>4;
ctx->mb_height = buf[0x16d]; ctx->mb_height = buf[0x16d];


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


if ((ctx->height+15)>>4 == ctx->mb_height && ctx->picture.interlaced_frame) if ((ctx->height+15)>>4 == ctx->mb_height && ctx->picture.interlaced_frame)
ctx->height <<= 1; ctx->height <<= 1;
@@ -141,7 +141,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, const uint8_t *buf, int buf_si


for (i = 0; i < ctx->mb_height; i++) { for (i = 0; i < ctx->mb_height; i++) {
ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2)); ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i<<2));
dprintf(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
av_dlog(ctx->avctx, "mb scan index %d\n", ctx->mb_scan_index[i]);
if (buf_size < ctx->mb_scan_index[i] + 0x280) { if (buf_size < ctx->mb_scan_index[i] + 0x280) {
av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n"); av_log(ctx->avctx, AV_LOG_ERROR, "invalid mb scan index\n");
return -1; return -1;
@@ -293,7 +293,7 @@ static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVFrame *picture = data; AVFrame *picture = data;
int first_field = 1; int first_field = 1;


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


decode_coding_unit: decode_coding_unit:
if (dnxhd_decode_header(ctx, buf, buf_size, first_field) < 0) if (dnxhd_decode_header(ctx, buf, buf_size, first_field) < 0)


+ 4
- 4
libavcodec/dnxhdenc.c View File

@@ -552,7 +552,7 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
break; break;
} }
//dprintf(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n",
//av_dlog(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n",
// lambda, last_higher, last_lower, bits, ctx->frame_bits); // lambda, last_higher, last_lower, bits, ctx->frame_bits);
if (end) { if (end) {
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
@@ -582,7 +582,7 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
down_step = 1<<LAMBDA_FRAC_BITS; down_step = 1<<LAMBDA_FRAC_BITS;
} }
} }
//dprintf(ctx->m.avctx, "out lambda %d\n", lambda);
//av_dlog(ctx->m.avctx, "out lambda %d\n", lambda);
ctx->lambda = lambda; ctx->lambda = lambda;
return 0; return 0;
} }
@@ -610,7 +610,7 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
if (bits > ctx->frame_bits) if (bits > ctx->frame_bits)
break; break;
} }
//dprintf(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
//av_dlog(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
// ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits, last_higher, last_lower); // ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits, last_higher, last_lower);
if (bits < ctx->frame_bits) { if (bits < ctx->frame_bits) {
if (qscale == 1) if (qscale == 1)
@@ -640,7 +640,7 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
return -1; return -1;
} }
} }
//dprintf(ctx->m.avctx, "out qscale %d\n", qscale);
//av_dlog(ctx->m.avctx, "out qscale %d\n", qscale);
ctx->qscale = qscale; ctx->qscale = qscale;
return 0; return 0;
} }


+ 4
- 4
libavcodec/dvbsub_parser.c View File

@@ -55,7 +55,7 @@ static int dvbsub_parse(AVCodecParserContext *s,
uint8_t *p, *p_end; uint8_t *p, *p_end;
int len, buf_pos = 0; int len, buf_pos = 0;


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


#ifdef DEBUG_PACKET_CONTENTS #ifdef DEBUG_PACKET_CONTENTS
@@ -82,7 +82,7 @@ static int dvbsub_parse(AVCodecParserContext *s,
{ {
if (pc->packet_index != pc->packet_start) if (pc->packet_index != pc->packet_start)
{ {
dprintf(avctx, "Discarding %d bytes\n",
av_dlog(avctx, "Discarding %d bytes\n",
pc->packet_index - pc->packet_start); pc->packet_index - pc->packet_start);
} }


@@ -90,7 +90,7 @@ static int dvbsub_parse(AVCodecParserContext *s,
pc->packet_index = 0; pc->packet_index = 0;


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


@@ -147,7 +147,7 @@ static int dvbsub_parse(AVCodecParserContext *s,
} else if (*p == 0xff) { } else if (*p == 0xff) {
if (p + 1 < p_end) if (p + 1 < p_end)
{ {
dprintf(avctx, "Junk at end of packet\n");
av_dlog(avctx, "Junk at end of packet\n");
} }
pc->packet_index = p - pc->packet_buf; pc->packet_index = p - pc->packet_buf;
pc->in_packet = 0; pc->in_packet = 0;


+ 8
- 8
libavcodec/dvbsubdec.c View File

@@ -749,7 +749,7 @@ static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDis
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}; 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8_t *map_table; uint8_t *map_table;


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


#ifdef DEBUG_PACKET_CONTENTS #ifdef DEBUG_PACKET_CONTENTS
@@ -984,7 +984,7 @@ static void dvbsub_parse_clut_segment(AVCodecContext *avctx,
YUV_TO_RGB1_CCIR(cb, cr); YUV_TO_RGB1_CCIR(cb, cr);
YUV_TO_RGB2_CCIR(r, g, b, y); YUV_TO_RGB2_CCIR(r, g, b, y);


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


if (depth & 0x80) if (depth & 0x80)
clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha); clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
@@ -1060,11 +1060,11 @@ static void dvbsub_parse_region_segment(AVCodecContext *avctx,
region->bgcolor = (((*buf++) >> 2) & 3); region->bgcolor = (((*buf++) >> 2) & 3);
} }


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


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


delete_region_display_list(ctx, region); delete_region_display_list(ctx, region);
@@ -1125,7 +1125,7 @@ static void dvbsub_parse_page_segment(AVCodecContext *avctx,
ctx->time_out = *buf++; ctx->time_out = *buf++;
page_state = ((*buf++) >> 2) & 3; page_state = ((*buf++) >> 2) & 3;


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


if (page_state == 2) { if (page_state == 2) {
delete_state(ctx); delete_state(ctx);
@@ -1163,7 +1163,7 @@ static void dvbsub_parse_page_segment(AVCodecContext *avctx,
ctx->display_list = display; ctx->display_list = display;
ctx->display_list_size++; ctx->display_list_size++;


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


while (tmp_display_list) { while (tmp_display_list) {
@@ -1461,7 +1461,7 @@ static int dvbsub_decode(AVCodecContext *avctx,
*data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub); *data_size = dvbsub_display_end_segment(avctx, p, segment_length, sub);
break; break;
default: default:
dprintf(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
segment_type, page_id, segment_length); segment_type, page_id, segment_length);
break; break;
} }
@@ -1471,7 +1471,7 @@ static int dvbsub_decode(AVCodecContext *avctx,
} }


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




+ 8
- 8
libavcodec/dvdsubdec.c View File

@@ -190,7 +190,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
while (cmd_pos > 0 && cmd_pos < buf_size - 2 - offset_size) { while (cmd_pos > 0 && cmd_pos < buf_size - 2 - offset_size) {
date = AV_RB16(buf + cmd_pos); date = AV_RB16(buf + cmd_pos);
next_cmd_pos = READ_OFFSET(buf + cmd_pos + 2); next_cmd_pos = READ_OFFSET(buf + cmd_pos + 2);
dprintf(NULL, "cmd_pos=0x%04x next=0x%04x date=%d\n",
av_dlog(NULL, "cmd_pos=0x%04x next=0x%04x date=%d\n",
cmd_pos, next_cmd_pos, date); cmd_pos, next_cmd_pos, date);
pos = cmd_pos + 2 + offset_size; pos = cmd_pos + 2 + offset_size;
offset1 = -1; offset1 = -1;
@@ -198,7 +198,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
x1 = y1 = x2 = y2 = 0; x1 = y1 = x2 = y2 = 0;
while (pos < buf_size) { while (pos < buf_size) {
cmd = buf[pos++]; cmd = buf[pos++];
dprintf(NULL, "cmd=%02x\n", cmd);
av_dlog(NULL, "cmd=%02x\n", cmd);
switch(cmd) { switch(cmd) {
case 0x00: case 0x00:
/* menu subpicture */ /* menu subpicture */
@@ -231,7 +231,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
alpha[1] = buf[pos + 1] >> 4; alpha[1] = buf[pos + 1] >> 4;
alpha[0] = buf[pos + 1] & 0x0f; alpha[0] = buf[pos + 1] & 0x0f;
pos += 2; pos += 2;
dprintf(NULL, "alpha=%x%x%x%x\n", alpha[0],alpha[1],alpha[2],alpha[3]);
av_dlog(NULL, "alpha=%x%x%x%x\n", alpha[0],alpha[1],alpha[2],alpha[3]);
break; break;
case 0x05: case 0x05:
case 0x85: case 0x85:
@@ -243,7 +243,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
y2 = ((buf[pos + 4] & 0x0f) << 8) | buf[pos + 5]; y2 = ((buf[pos + 4] & 0x0f) << 8) | buf[pos + 5];
if (cmd & 0x80) if (cmd & 0x80)
is_8bit = 1; is_8bit = 1;
dprintf(NULL, "x1=%d x2=%d y1=%d y2=%d\n", x1, x2, y1, y2);
av_dlog(NULL, "x1=%d x2=%d y1=%d y2=%d\n", x1, x2, y1, y2);
pos += 6; pos += 6;
break; break;
case 0x06: case 0x06:
@@ -251,7 +251,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
goto fail; goto fail;
offset1 = AV_RB16(buf + pos); offset1 = AV_RB16(buf + pos);
offset2 = AV_RB16(buf + pos + 2); offset2 = AV_RB16(buf + pos + 2);
dprintf(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
av_dlog(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
pos += 4; pos += 4;
break; break;
case 0x86: case 0x86:
@@ -259,7 +259,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
goto fail; goto fail;
offset1 = AV_RB32(buf + pos); offset1 = AV_RB32(buf + pos);
offset2 = AV_RB32(buf + pos + 4); offset2 = AV_RB32(buf + pos + 4);
dprintf(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
av_dlog(NULL, "offset1=0x%04x offset2=0x%04x\n", offset1, offset2);
pos += 8; pos += 8;
break; break;


@@ -282,7 +282,7 @@ static int decode_dvd_subtitles(AVSubtitle *sub_header,
case 0xff: case 0xff:
goto the_end; goto the_end;
default: default:
dprintf(NULL, "unrecognised subpicture command 0x%x\n", cmd);
av_dlog(NULL, "unrecognised subpicture command 0x%x\n", cmd);
goto the_end; goto the_end;
} }
} }
@@ -475,7 +475,7 @@ static int dvdsub_decode(AVCodecContext *avctx,
goto no_subtitle; goto no_subtitle;


#if defined(DEBUG) #if defined(DEBUG)
dprintf(NULL, "start=%d ms end =%d ms\n",
av_dlog(NULL, "start=%d ms end =%d ms\n",
sub->start_display_time, sub->start_display_time,
sub->end_display_time); sub->end_display_time);
ppm_save("/tmp/a.ppm", sub->rects[0]->pict.data[0], ppm_save("/tmp/a.ppm", sub->rects[0]->pict.data[0],


+ 6
- 6
libavcodec/gifdec.c View File

@@ -77,7 +77,7 @@ static int gif_read_image(GifState *s)
has_local_palette = flags & 0x80; has_local_palette = flags & 0x80;
bits_per_pixel = (flags & 0x07) + 1; bits_per_pixel = (flags & 0x07) + 1;


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


if (has_local_palette) { if (has_local_palette) {
bytestream_get_buffer(&s->bytestream, s->local_palette, 3 * (1 << bits_per_pixel)); bytestream_get_buffer(&s->bytestream, s->local_palette, 3 * (1 << bits_per_pixel));
@@ -163,7 +163,7 @@ static int gif_read_extension(GifState *s)
ext_code = bytestream_get_byte(&s->bytestream); ext_code = bytestream_get_byte(&s->bytestream);
ext_len = bytestream_get_byte(&s->bytestream); ext_len = bytestream_get_byte(&s->bytestream);


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


switch(ext_code) { switch(ext_code) {
case 0xf9: case 0xf9:
@@ -179,7 +179,7 @@ static int gif_read_extension(GifState *s)
s->transparent_color_index = -1; s->transparent_color_index = -1;
s->gce_disposal = (gce_flags >> 2) & 0x7; s->gce_disposal = (gce_flags >> 2) & 0x7;


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


@@ -194,7 +194,7 @@ static int gif_read_extension(GifState *s)
bytestream_get_byte(&s->bytestream); bytestream_get_byte(&s->bytestream);
ext_len = bytestream_get_byte(&s->bytestream); ext_len = bytestream_get_byte(&s->bytestream);


dprintf(s->avctx, "gif: ext_len1=%d\n", ext_len);
av_dlog(s->avctx, "gif: ext_len1=%d\n", ext_len);
} }
return 0; return 0;
} }
@@ -231,7 +231,7 @@ static int gif_read_header1(GifState *s)
s->background_color_index = bytestream_get_byte(&s->bytestream); s->background_color_index = bytestream_get_byte(&s->bytestream);
bytestream_get_byte(&s->bytestream); /* ignored */ bytestream_get_byte(&s->bytestream); /* ignored */


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


@@ -249,7 +249,7 @@ static int gif_parse_next_image(GifState *s)
while (s->bytestream < s->bytestream_end) { while (s->bytestream < s->bytestream_end) {
int code = bytestream_get_byte(&s->bytestream); int code = bytestream_get_byte(&s->bytestream);


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


switch (code) { switch (code) {
case ',': case ',':


+ 2
- 2
libavcodec/h261dec.c View File

@@ -553,8 +553,8 @@ static int h261_decode_frame(AVCodecContext *avctx,
int ret; int ret;
AVFrame *pict = data; AVFrame *pict = data;


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




+ 4
- 4
libavcodec/ituh263dec.c View File

@@ -325,7 +325,7 @@ static int h263p_decode_umotion(MpegEncContext * s, int pred)
code >>= 1; code >>= 1;


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


} }
@@ -951,7 +951,7 @@ int h263_decode_picture_header(MpegEncContext *s)
if (ufep == 1) { if (ufep == 1) {
/* OPPTYPE */ /* OPPTYPE */
format = get_bits(&s->gb, 3); format = get_bits(&s->gb, 3);
dprintf(s->avctx, "ufep=1, format: %d\n", format);
av_dlog(s->avctx, "ufep=1, format: %d\n", format);
s->custom_pcf= get_bits1(&s->gb); s->custom_pcf= get_bits1(&s->gb);
s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
if (get_bits1(&s->gb) != 0) { if (get_bits1(&s->gb) != 0) {
@@ -1002,7 +1002,7 @@ int h263_decode_picture_header(MpegEncContext *s)
if (format == 6) { if (format == 6) {
/* Custom Picture Format (CPFMT) */ /* Custom Picture Format (CPFMT) */
s->aspect_ratio_info = get_bits(&s->gb, 4); s->aspect_ratio_info = get_bits(&s->gb, 4);
dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
/* aspect ratios: /* aspect ratios:
0 - forbidden 0 - forbidden
1 - 1:1 1 - 1:1
@@ -1015,7 +1015,7 @@ int h263_decode_picture_header(MpegEncContext *s)
width = (get_bits(&s->gb, 9) + 1) * 4; width = (get_bits(&s->gb, 9) + 1) * 4;
skip_bits1(&s->gb); skip_bits1(&s->gb);
height = get_bits(&s->gb, 9) * 4; height = get_bits(&s->gb, 9) * 4;
dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
/* aspected dimensions */ /* aspected dimensions */
s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);


+ 1
- 1
libavcodec/mjpegdec.c View File

@@ -1255,7 +1255,7 @@ static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
} }
val = -1; val = -1;
found: found:
dprintf(NULL, "find_marker skipped %d bytes\n", skipped);
av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
*pbuf_ptr = buf_ptr; *pbuf_ptr = buf_ptr;
return val; return val;
} }


+ 20
- 20
libavcodec/mpeg12.c View File

@@ -213,7 +213,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
int i, j, k, cbp, val, mb_type, motion_type; int i, j, k, cbp, val, mb_type, motion_type;
const int mb_block_count = 4 + (1<< s->chroma_format); const int mb_block_count = 4 + (1<< s->chroma_format);


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


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


@@ -272,7 +272,7 @@ static int mpeg_decode_mb(MpegEncContext *s,
mb_type = btype2mb_type[ mb_type ]; mb_type = btype2mb_type[ mb_type ];
break; break;
} }
dprintf(s->avctx, "mb_type=%x\n", mb_type);
av_dlog(s->avctx, "mb_type=%x\n", mb_type);
// motion_type = 0; /* avoid warning */ // motion_type = 0; /* avoid warning */
if (IS_INTRA(mb_type)) { if (IS_INTRA(mb_type)) {
s->dsp.clear_blocks(s->block[0]); s->dsp.clear_blocks(s->block[0]);
@@ -370,7 +370,7 @@ static int mpeg_decode_mb(MpegEncContext *s,


/* motion vectors */ /* motion vectors */
s->mv_dir= (mb_type>>13)&3; s->mv_dir= (mb_type>>13)&3;
dprintf(s->avctx, "motion_type=%d\n", motion_type);
av_dlog(s->avctx, "motion_type=%d\n", motion_type);
switch(motion_type) { switch(motion_type) {
case MT_FRAME: /* or MT_16X8 */ case MT_FRAME: /* or MT_16X8 */
if (s->picture_structure == PICT_FRAME) { if (s->picture_structure == PICT_FRAME) {
@@ -421,12 +421,12 @@ static int mpeg_decode_mb(MpegEncContext *s,
s->last_mv[i][j][0]); s->last_mv[i][j][0]);
s->last_mv[i][j][0] = val; s->last_mv[i][j][0] = val;
s->mv[i][j][0] = val; s->mv[i][j][0] = val;
dprintf(s->avctx, "fmx=%d\n", val);
av_dlog(s->avctx, "fmx=%d\n", val);
val = mpeg_decode_motion(s, s->mpeg_f_code[i][1], val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
s->last_mv[i][j][1] >> 1); s->last_mv[i][j][1] >> 1);
s->last_mv[i][j][1] = val << 1; s->last_mv[i][j][1] = val << 1;
s->mv[i][j][1] = val; s->mv[i][j][1] = val;
dprintf(s->avctx, "fmy=%d\n", val);
av_dlog(s->avctx, "fmy=%d\n", val);
} }
} }
} }
@@ -632,7 +632,7 @@ static inline int mpeg1_decode_block_intra(MpegEncContext *s,
dc += diff; dc += diff;
s->last_dc[component] = dc; s->last_dc[component] = dc;
block[0] = dc*quant_matrix[0]; block[0] = dc*quant_matrix[0];
dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
av_dlog(s->avctx, "dc=%d diff=%d\n", dc, diff);
i = 0; i = 0;
{ {
OPEN_READER(re, &s->gb); OPEN_READER(re, &s->gb);
@@ -1012,7 +1012,7 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
dc += diff; dc += diff;
s->last_dc[component] = dc; s->last_dc[component] = dc;
block[0] = dc << (3 - s->intra_dc_precision); block[0] = dc << (3 - s->intra_dc_precision);
dprintf(s->avctx, "dc=%d\n", block[0]);
av_dlog(s->avctx, "dc=%d\n", block[0]);
mismatch = block[0] ^ 1; mismatch = block[0] ^ 1;
i = 0; i = 0;
if (s->intra_vlc_format) if (s->intra_vlc_format)
@@ -1386,7 +1386,7 @@ static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1; s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1; s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;


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


@@ -1477,7 +1477,7 @@ static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1


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


if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1); if(get_bits1(&s->gb)) load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0); if(get_bits1(&s->gb)) load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
@@ -1551,15 +1551,15 @@ static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
} }


/* composite display not parsed */ /* composite display not parsed */
dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
av_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
av_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
av_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
av_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
av_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
av_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
av_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
av_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
av_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
} }


static void exchange_uv(MpegEncContext *s){ static void exchange_uv(MpegEncContext *s){
@@ -2200,7 +2200,7 @@ static int mpeg_decode_frame(AVCodecContext *avctx,
Mpeg1Context *s = avctx->priv_data; Mpeg1Context *s = avctx->priv_data;
AVFrame *picture = data; AVFrame *picture = data;
MpegEncContext *s2 = &s->mpeg_enc_ctx; MpegEncContext *s2 = &s->mpeg_enc_ctx;
dprintf(avctx, "fill_buffer\n");
av_dlog(avctx, "fill_buffer\n");


if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) { if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
/* special case for last picture */ /* special case for last picture */
@@ -2524,7 +2524,7 @@ static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) ) if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
return -1; return -1;
if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){ if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
av_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
} }
mpeg_decode_init(avctx); mpeg_decode_init(avctx);




+ 1
- 1
libavcodec/mpeg12enc.c View File

@@ -890,7 +890,7 @@ static void mpeg1_encode_block(MpegEncContext *s,
next_coef: next_coef:
#if 0 #if 0
if (level != 0) if (level != 0)
dprintf(s->avctx, "level[%d]=%d\n", i, level);
av_dlog(s->avctx, "level[%d]=%d\n", i, level);
#endif #endif
/* encode using VLC */ /* encode using VLC */
if (level != 0) { if (level != 0) {


+ 11
- 11
libavcodec/mpegaudiodec.c View File

@@ -352,7 +352,7 @@ static av_cold int decode_init(AVCodecContext * avctx)
scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS); scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0 * 2.0), FRAC_BITS);
scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS); scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS); scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
dprintf(avctx, "%d: norm=%x s=%x %x %x\n",
av_dlog(avctx, "%d: norm=%x s=%x %x %x\n",
i, norm, i, norm,
scale_factor_mult[i][0], scale_factor_mult[i][0],
scale_factor_mult[i][1], scale_factor_mult[i][1],
@@ -457,7 +457,7 @@ static av_cold int decode_init(AVCodecContext * avctx)
k = i & 1; k = i & 1;
is_table_lsf[j][k ^ 1][i] = FIXR(f); is_table_lsf[j][k ^ 1][i] = FIXR(f);
is_table_lsf[j][k][i] = FIXR(1.0); is_table_lsf[j][k][i] = FIXR(1.0);
dprintf(avctx, "is_table_lsf %d %d: %x %x\n",
av_dlog(avctx, "is_table_lsf %d %d: %x %x\n",
i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]); i, j, is_table_lsf[j][0][i], is_table_lsf[j][1][i]);
} }
} }
@@ -986,7 +986,7 @@ static int mp_decode_layer2(MPADecodeContext *s)
else else
bound = sblimit; bound = sblimit;


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


/* sanity check */ /* sanity check */
if( bound > sblimit ) bound = sblimit; if( bound > sblimit ) bound = sblimit;
@@ -1309,7 +1309,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,


exponent= exponents[s_index]; exponent= exponents[s_index];


dprintf(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
av_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
i, g->region_size[i] - j, x, y, exponent); i, g->region_size[i] - j, x, y, exponent);
if(y&16){ if(y&16){
x = y >> 5; x = y >> 5;
@@ -1377,7 +1377,7 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
last_pos= pos; last_pos= pos;


code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1); code = get_vlc2(&s->gb, vlc->table, vlc->bits, 1);
dprintf(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
av_dlog(s->avctx, "t=%d code=%d\n", g->count1table_select, code);
g->sb_hybrid[s_index+0]= g->sb_hybrid[s_index+0]=
g->sb_hybrid[s_index+1]= g->sb_hybrid[s_index+1]=
g->sb_hybrid[s_index+2]= g->sb_hybrid[s_index+2]=
@@ -1735,7 +1735,7 @@ static int mp_decode_layer3(MPADecodeContext *s)


for(gr=0;gr<nb_granules;gr++) { for(gr=0;gr<nb_granules;gr++) {
for(ch=0;ch<s->nb_channels;ch++) { for(ch=0;ch<s->nb_channels;ch++) {
dprintf(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
av_dlog(s->avctx, "gr=%d ch=%d: side_info\n", gr, ch);
g = &s->granules[ch][gr]; g = &s->granules[ch][gr];
g->part2_3_length = get_bits(&s->gb, 12); g->part2_3_length = get_bits(&s->gb, 12);
g->big_values = get_bits(&s->gb, 9); g->big_values = get_bits(&s->gb, 9);
@@ -1776,7 +1776,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
/* compute huffman coded region sizes */ /* compute huffman coded region sizes */
region_address1 = get_bits(&s->gb, 4); region_address1 = get_bits(&s->gb, 4);
region_address2 = get_bits(&s->gb, 3); region_address2 = get_bits(&s->gb, 3);
dprintf(s->avctx, "region1=%d region2=%d\n",
av_dlog(s->avctx, "region1=%d region2=%d\n",
region_address1, region_address2); region_address1, region_address2);
ff_init_long_region(s, g, region_address1, region_address2); ff_init_long_region(s, g, region_address1, region_address2);
} }
@@ -1788,7 +1788,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
g->preflag = get_bits1(&s->gb); g->preflag = get_bits1(&s->gb);
g->scalefac_scale = get_bits1(&s->gb); g->scalefac_scale = get_bits1(&s->gb);
g->count1table_select = get_bits1(&s->gb); g->count1table_select = get_bits1(&s->gb);
dprintf(s->avctx, "block_type=%d switch_point=%d\n",
av_dlog(s->avctx, "block_type=%d switch_point=%d\n",
g->block_type, g->switch_point); g->block_type, g->switch_point);
} }
} }
@@ -1797,7 +1797,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3); const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
assert((get_bits_count(&s->gb) & 7) == 0); assert((get_bits_count(&s->gb) & 7) == 0);
/* now we get bits from the main_data_begin offset */ /* now we get bits from the main_data_begin offset */
dprintf(s->avctx, "seekback: %d\n", main_data_begin);
av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
//av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size); //av_log(NULL, AV_LOG_ERROR, "backstep:%d, lastbuf:%d\n", main_data_begin, s->last_buf_size);


memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES); memcpy(s->last_buf + s->last_buf_size, ptr, EXTRABYTES);
@@ -1831,7 +1831,7 @@ static int mp_decode_layer3(MPADecodeContext *s)
/* MPEG1 scale factors */ /* MPEG1 scale factors */
slen1 = slen_table[0][g->scalefac_compress]; slen1 = slen_table[0][g->scalefac_compress];
slen2 = slen_table[1][g->scalefac_compress]; slen2 = slen_table[1][g->scalefac_compress];
dprintf(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
av_dlog(s->avctx, "slen1=%d slen2=%d\n", slen1, slen2);
if (g->block_type == 2) { if (g->block_type == 2) {
n = g->switch_point ? 17 : 18; n = g->switch_point ? 17 : 18;
j = 0; j = 0;
@@ -1964,7 +1964,7 @@ static int mp_decode_frame(MPADecodeContext *s,
if (s->error_protection) if (s->error_protection)
skip_bits(&s->gb, 16); skip_bits(&s->gb, 16);


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


+ 6
- 6
libavcodec/mpegaudiodecheader.c View File

@@ -91,20 +91,20 @@ int ff_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
} }


#if defined(DEBUG) #if defined(DEBUG)
dprintf(NULL, "layer%d, %d Hz, %d kbits/s, ",
av_dlog(NULL, "layer%d, %d Hz, %d kbits/s, ",
s->layer, s->sample_rate, s->bit_rate); s->layer, s->sample_rate, s->bit_rate);
if (s->nb_channels == 2) { if (s->nb_channels == 2) {
if (s->layer == 3) { if (s->layer == 3) {
if (s->mode_ext & MODE_EXT_MS_STEREO) if (s->mode_ext & MODE_EXT_MS_STEREO)
dprintf(NULL, "ms-");
av_dlog(NULL, "ms-");
if (s->mode_ext & MODE_EXT_I_STEREO) if (s->mode_ext & MODE_EXT_I_STEREO)
dprintf(NULL, "i-");
av_dlog(NULL, "i-");
} }
dprintf(NULL, "stereo");
av_dlog(NULL, "stereo");
} else { } else {
dprintf(NULL, "mono");
av_dlog(NULL, "mono");
} }
dprintf(NULL, "\n");
av_dlog(NULL, "\n");
#endif #endif
return 0; return 0;
} }

+ 1
- 1
libavcodec/mpegaudioenc.c View File

@@ -122,7 +122,7 @@ static av_cold int MPA_encode_init(AVCodecContext *avctx)
s->sblimit = ff_mpa_sblimit_table[table]; s->sblimit = ff_mpa_sblimit_table[table];
s->alloc_table = ff_mpa_alloc_tables[table]; s->alloc_table = ff_mpa_alloc_tables[table];


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


for(i=0;i<s->nb_channels;i++) for(i=0;i<s->nb_channels;i++)


+ 3
- 3
libavcodec/pcm-mpeg.c View File

@@ -64,7 +64,7 @@ static int pcm_bluray_parse_header(AVCodecContext *avctx,
uint8_t channel_layout = header[2] >> 4; uint8_t channel_layout = header[2] >> 4;


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


/* get the sample depth and derive the sample format from it */ /* get the sample depth and derive the sample format from it */
@@ -112,7 +112,7 @@ static int pcm_bluray_parse_header(AVCodecContext *avctx,
avctx->bits_per_coded_sample; avctx->bits_per_coded_sample;


if (avctx->debug & FF_DEBUG_PICT_INFO) if (avctx->debug & FF_DEBUG_PICT_INFO)
dprintf(avctx,
av_dlog(avctx,
"pcm_bluray_parse_header: %d channels, %d bits per sample, %d kHz, %d kbit\n", "pcm_bluray_parse_header: %d channels, %d bits per sample, %d kHz, %d kbit\n",
avctx->channels, avctx->bits_per_coded_sample, avctx->channels, avctx->bits_per_coded_sample,
avctx->sample_rate, avctx->bit_rate); avctx->sample_rate, avctx->bit_rate);
@@ -291,7 +291,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx,


retval = src - avpkt->data; retval = src - avpkt->data;
if (avctx->debug & FF_DEBUG_BITSTREAM) if (avctx->debug & FF_DEBUG_BITSTREAM)
dprintf(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
av_dlog(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
retval, *data_size); retval, *data_size);
return retval; return retval;
} }


+ 5
- 5
libavcodec/pgssubdec.c View File

@@ -141,7 +141,7 @@ static int decode_rle(AVCodecContext *avctx, AVSubtitle *sub,
return -1; return -1;
} }


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


return 0; return 0;
} }
@@ -253,7 +253,7 @@ static void parse_palette_segment(AVCodecContext *avctx,
YUV_TO_RGB1(cb, cr); YUV_TO_RGB1(cb, cr);
YUV_TO_RGB2(r, g, b, y); YUV_TO_RGB2(r, g, b, y);


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


/* Store color in palette */ /* Store color in palette */
ctx->clut[color_id] = RGBA(r,g,b,alpha); ctx->clut[color_id] = RGBA(r,g,b,alpha);
@@ -282,7 +282,7 @@ static void parse_presentation_segment(AVCodecContext *avctx,
int w = bytestream_get_be16(&buf); int w = bytestream_get_be16(&buf);
int h = bytestream_get_be16(&buf); int h = bytestream_get_be16(&buf);


dprintf(avctx, "Video Dimensions %dx%d\n",
av_dlog(avctx, "Video Dimensions %dx%d\n",
w, h); w, h);
if (av_image_check_size(w, h, 0, avctx) >= 0) if (av_image_check_size(w, h, 0, avctx) >= 0)
avcodec_set_dimensions(avctx, w, h); avcodec_set_dimensions(avctx, w, h);
@@ -317,7 +317,7 @@ static void parse_presentation_segment(AVCodecContext *avctx,


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


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


if (x > avctx->width || y > avctx->height) { if (x > avctx->width || y > avctx->height) {
av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n", av_log(avctx, AV_LOG_ERROR, "Subtitle out of video bounds. x = %d, y = %d, video width = %d, video height = %d.\n",
@@ -433,7 +433,7 @@ static int decode(AVCodecContext *avctx, void *data, int *data_size,
segment_type = bytestream_get_byte(&buf); segment_type = bytestream_get_byte(&buf);
segment_length = bytestream_get_be16(&buf); segment_length = bytestream_get_be16(&buf);


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


if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf) if (segment_type != DISPLAY_SEGMENT && segment_length > buf_end - buf)
break; break;


+ 3
- 3
libavcodec/pngdec.c View File

@@ -431,7 +431,7 @@ static int decode_frame(AVCodecContext *avctx,
goto fail; goto fail;
tag32 = bytestream_get_be32(&s->bytestream); tag32 = bytestream_get_be32(&s->bytestream);
tag = av_bswap32(tag32); tag = av_bswap32(tag32);
dprintf(avctx, "png: tag=%c%c%c%c length=%u\n",
av_dlog(avctx, "png: tag=%c%c%c%c length=%u\n",
(tag & 0xff), (tag & 0xff),
((tag >> 8) & 0xff), ((tag >> 8) & 0xff),
((tag >> 16) & 0xff), ((tag >> 16) & 0xff),
@@ -453,7 +453,7 @@ static int decode_frame(AVCodecContext *avctx,
s->interlace_type = *s->bytestream++; s->interlace_type = *s->bytestream++;
crc = bytestream_get_be32(&s->bytestream); crc = bytestream_get_be32(&s->bytestream);
s->state |= PNG_IHDR; s->state |= PNG_IHDR;
dprintf(avctx, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
av_dlog(avctx, "width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",
s->width, s->height, s->bit_depth, s->color_type, s->width, s->height, s->bit_depth, s->color_type,
s->compression_type, s->filter_type, s->interlace_type); s->compression_type, s->filter_type, s->interlace_type);
break; break;
@@ -517,7 +517,7 @@ static int decode_frame(AVCodecContext *avctx,
s->width); s->width);
s->crow_size = s->pass_row_size + 1; s->crow_size = s->pass_row_size + 1;
} }
dprintf(avctx, "row_size=%d crow_size =%d\n",
av_dlog(avctx, "row_size=%d crow_size =%d\n",
s->row_size, s->crow_size); s->row_size, s->crow_size);
s->image_buf = p->data[0]; s->image_buf = p->data[0];
s->image_linesize = p->linesize[0]; s->image_linesize = p->linesize[0];


+ 5
- 5
libavcodec/rv10.c View File

@@ -246,7 +246,7 @@ static int rv10_decode_picture_header(MpegEncContext *s)
if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n"); if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
pb_frame = get_bits1(&s->gb); pb_frame = get_bits1(&s->gb);


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


if (pb_frame){ if (pb_frame){
av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n"); av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
@@ -265,7 +265,7 @@ static int rv10_decode_picture_header(MpegEncContext *s)
s->last_dc[0] = get_bits(&s->gb, 8); s->last_dc[0] = get_bits(&s->gb, 8);
s->last_dc[1] = get_bits(&s->gb, 8); s->last_dc[1] = get_bits(&s->gb, 8);
s->last_dc[2] = get_bits(&s->gb, 8); s->last_dc[2] = get_bits(&s->gb, 8);
dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
s->last_dc[1], s->last_dc[2]); s->last_dc[1], s->last_dc[2]);
} }
} }
@@ -561,7 +561,7 @@ static int rv10_decode_packet(AVCodecContext *avctx,
ff_er_frame_start(s); ff_er_frame_start(s);
} }


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


/* default quantization values */ /* default quantization values */
if(s->codec_id== CODEC_ID_RV10){ if(s->codec_id== CODEC_ID_RV10){
@@ -600,7 +600,7 @@ static int rv10_decode_packet(AVCodecContext *avctx,
for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) { for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
int ret; int ret;
ff_update_block_index(s); ff_update_block_index(s);
dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);


s->mv_dir = MV_DIR_FORWARD; s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16; s->mv_type = MV_TYPE_16X16;
@@ -655,7 +655,7 @@ static int rv10_decode_frame(AVCodecContext *avctx,
int slice_count; int slice_count;
const uint8_t *slices_hdr = NULL; const uint8_t *slices_hdr = NULL;


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


/* no supplementary picture */ /* no supplementary picture */
if (buf_size == 0) { if (buf_size == 0) {


+ 1
- 1
libavcodec/shorten.c View File

@@ -305,7 +305,7 @@ static int shorten_decode_frame(AVCodecContext *avctx,
s->bitstream_size= buf_size; s->bitstream_size= buf_size;


if(buf_size < s->max_framesize){ if(buf_size < s->max_framesize){
//dprintf(avctx, "wanna more data ... %d\n", buf_size);
//av_dlog(avctx, "wanna more data ... %d\n", buf_size);
*data_size = 0; *data_size = 0;
return input_buf_size; return input_buf_size;
} }


+ 1
- 1
libavcodec/vaapi.c View File

@@ -180,7 +180,7 @@ int ff_vaapi_common_end_frame(MpegEncContext *s)
struct vaapi_context * const vactx = s->avctx->hwaccel_context; struct vaapi_context * const vactx = s->avctx->hwaccel_context;
int ret = -1; int ret = -1;


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


if (commit_slices(vactx) < 0) if (commit_slices(vactx) < 0)
goto done; goto done;


+ 3
- 3
libavcodec/vaapi_h264.c View File

@@ -227,7 +227,7 @@ static int start_frame(AVCodecContext *avctx,
VAPictureParameterBufferH264 *pic_param; VAPictureParameterBufferH264 *pic_param;
VAIQMatrixBufferH264 *iq_matrix; VAIQMatrixBufferH264 *iq_matrix;


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


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


@@ -289,7 +289,7 @@ static int end_frame(AVCodecContext *avctx)
{ {
H264Context * const h = avctx->priv_data; H264Context * const h = avctx->priv_data;


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


@@ -302,7 +302,7 @@ static int decode_slice(AVCodecContext *avctx,
MpegEncContext * const s = &h->s; MpegEncContext * const s = &h->s;
VASliceParameterBufferH264 *slice_param; VASliceParameterBufferH264 *slice_param;


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


/* Fill in VASliceParameterBufferH264. */ /* Fill in VASliceParameterBufferH264. */
slice_param = (VASliceParameterBufferH264 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size); slice_param = (VASliceParameterBufferH264 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);


+ 2
- 2
libavcodec/vaapi_mpeg2.c View File

@@ -44,7 +44,7 @@ static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_
VAIQMatrixBufferMPEG2 *iq_matrix; VAIQMatrixBufferMPEG2 *iq_matrix;
int i; int i;


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


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


@@ -111,7 +111,7 @@ static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
GetBitContext gb; GetBitContext gb;
uint32_t start_code, quantiser_scale_code, intra_slice_flag, macroblock_offset; uint32_t start_code, quantiser_scale_code, intra_slice_flag, macroblock_offset;


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


/* Determine macroblock_offset */ /* Determine macroblock_offset */
init_get_bits(&gb, buffer, 8 * size); init_get_bits(&gb, buffer, 8 * size);


+ 2
- 2
libavcodec/vaapi_mpeg4.c View File

@@ -47,7 +47,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_
VAIQMatrixBufferMPEG4 *iq_matrix; VAIQMatrixBufferMPEG4 *iq_matrix;
int i; int i;


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


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


@@ -125,7 +125,7 @@ static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
MpegEncContext * const s = avctx->priv_data; MpegEncContext * const s = avctx->priv_data;
VASliceParameterBufferMPEG4 *slice_param; VASliceParameterBufferMPEG4 *slice_param;


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


/* video_plane_with_short_video_header() contains all GOBs /* video_plane_with_short_video_header() contains all GOBs
* in-order, and this is what VA API (Intel backend) expects: only * in-order, and this is what VA API (Intel backend) expects: only


+ 2
- 2
libavcodec/vaapi_vc1.c View File

@@ -138,7 +138,7 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t
struct vaapi_context * const vactx = avctx->hwaccel_context; struct vaapi_context * const vactx = avctx->hwaccel_context;
VAPictureParameterBufferVC1 *pic_param; VAPictureParameterBufferVC1 *pic_param;


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


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


@@ -308,7 +308,7 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
MpegEncContext * const s = &v->s; MpegEncContext * const s = &v->s;
VASliceParameterBufferVC1 *slice_param; VASliceParameterBufferVC1 *slice_param;


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


/* Current bit buffer is beyond any marker for VC-1, so skip it */ /* Current bit buffer is beyond any marker for VC-1, so skip it */
if (avctx->codec_id == CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) { if (avctx->codec_id == CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {


+ 4
- 4
libavcodec/wma.c View File

@@ -217,13 +217,13 @@ int ff_wma_init(AVCodecContext *avctx, int flags2)
high_freq = high_freq * 0.5; high_freq = high_freq * 0.5;
} }
} }
dprintf(s->avctx, "flags2=0x%x\n", flags2);
dprintf(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
av_dlog(s->avctx, "flags2=0x%x\n", flags2);
av_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
s->version, s->nb_channels, s->sample_rate, s->bit_rate, s->version, s->nb_channels, s->sample_rate, s->bit_rate,
s->block_align); s->block_align);
dprintf(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
av_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
bps, bps1, high_freq, s->byte_offset_bits); bps, bps1, high_freq, s->byte_offset_bits);
dprintf(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
av_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes); s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);


/* compute the scale factor band sizes for each MDCT block size */ /* compute the scale factor band sizes for each MDCT block size */


+ 16
- 16
libavcodec/wmaprodec.c View File

@@ -288,8 +288,8 @@ static av_cold int decode_init(AVCodecContext *avctx)
s->bits_per_sample = AV_RL16(edata_ptr); s->bits_per_sample = AV_RL16(edata_ptr);
/** dump the extradata */ /** dump the extradata */
for (i = 0; i < avctx->extradata_size; i++) for (i = 0; i < avctx->extradata_size; i++)
dprintf(avctx, "[%x] ", avctx->extradata[i]);
dprintf(avctx, "\n");
av_dlog(avctx, "[%x] ", avctx->extradata[i]);
av_dlog(avctx, "\n");


} else { } else {
av_log_ask_for_sample(avctx, "Unknown extradata size\n"); av_log_ask_for_sample(avctx, "Unknown extradata size\n");
@@ -582,7 +582,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
int i; int i;
int offset = 0; int offset = 0;
for (i = 0; i < s->channel[c].num_subframes; i++) { for (i = 0; i < s->channel[c].num_subframes; i++) {
dprintf(s->avctx, "frame[%i] channel[%i] subframe[%i]"
av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
" len %i\n", s->frame_num, c, i, " len %i\n", s->frame_num, c, i,
s->channel[c].subframe_len[i]); s->channel[c].subframe_len[i]);
s->channel[c].subframe_offset[i] = offset; s->channel[c].subframe_offset[i] = offset;
@@ -781,7 +781,7 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c)
const uint16_t* run; const uint16_t* run;
const float* level; const float* level;


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


vlctable = get_bits1(&s->gb); vlctable = get_bits1(&s->gb);
vlc = &coef_vlc[vlctable]; vlc = &coef_vlc[vlctable];
@@ -1066,7 +1066,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
} }
} }


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


/** get a list of all channels that contain the estimated block */ /** get a list of all channels that contain the estimated block */
@@ -1093,7 +1093,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
s->parsed_all_subframes = 1; s->parsed_all_subframes = 1;




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


/** calculate number of scale factor bands and their offsets */ /** calculate number of scale factor bands and their offsets */
@@ -1204,7 +1204,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }


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


/** parse coefficients */ /** parse coefficients */
@@ -1218,7 +1218,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
sizeof(*s->channel[c].coeffs) * subframe_len); sizeof(*s->channel[c].coeffs) * subframe_len);
} }


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


if (transmit_coeffs) { if (transmit_coeffs) {
@@ -1294,7 +1294,7 @@ static int decode_frame(WMAProDecodeCtx *s)
if (s->len_prefix) if (s->len_prefix)
len = get_bits(gb, s->log2_frame_size); len = get_bits(gb, s->log2_frame_size);


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


/** decode tile information */ /** decode tile information */
if (decode_tilehdr(s)) { if (decode_tilehdr(s)) {
@@ -1313,7 +1313,7 @@ static int decode_frame(WMAProDecodeCtx *s)
/** read drc info */ /** read drc info */
if (s->dynamic_range_compression) { if (s->dynamic_range_compression) {
s->drc_gain = get_bits(gb, 8); s->drc_gain = get_bits(gb, 8);
dprintf(s->avctx, "drc_gain %i\n", s->drc_gain);
av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
} }


/** no idea what these are for, might be the number of samples /** no idea what these are for, might be the number of samples
@@ -1324,18 +1324,18 @@ static int decode_frame(WMAProDecodeCtx *s)
/** usually true for the first frame */ /** usually true for the first frame */
if (get_bits1(gb)) { if (get_bits1(gb)) {
skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
dprintf(s->avctx, "start skip: %i\n", skip);
av_dlog(s->avctx, "start skip: %i\n", skip);
} }


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


} }


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


/** reset subframe states */ /** reset subframe states */
@@ -1505,7 +1505,7 @@ static int decode_packet(AVCodecContext *avctx,


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


/** check for packet loss */ /** check for packet loss */
@@ -1527,14 +1527,14 @@ static int decode_packet(AVCodecContext *avctx,
/** append the previous frame data to the remaining data from the /** append the previous frame data to the remaining data from the
previous packet to create a full frame */ previous packet to create a full frame */
save_bits(s, gb, num_bits_prev_frame, 1); save_bits(s, gb, num_bits_prev_frame, 1);
dprintf(avctx, "accumulated %x bits of frame data\n",
av_dlog(avctx, "accumulated %x bits of frame data\n",
s->num_saved_bits - s->frame_offset); s->num_saved_bits - s->frame_offset);


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




+ 15
- 15
libavfilter/avfilter.c View File

@@ -217,24 +217,24 @@ static char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)
return buf; return buf;
} }


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


if (ref->video) { if (ref->video) {
dprintf(ctx, " a:%d/%d s:%dx%d i:%c",
av_dlog(ctx, " a:%d/%d s:%dx%d i:%c",
ref->video->pixel_aspect.num, ref->video->pixel_aspect.den, ref->video->pixel_aspect.num, ref->video->pixel_aspect.den,
ref->video->w, ref->video->h, ref->video->w, ref->video->h,
!ref->video->interlaced ? 'P' : /* Progressive */ !ref->video->interlaced ? 'P' : /* Progressive */
ref->video->top_field_first ? 'T' : 'B'); /* Top / Bottom */ ref->video->top_field_first ? 'T' : 'B'); /* Top / Bottom */
} }
if (ref->audio) { if (ref->audio) {
dprintf(ctx, " cl:%"PRId64"d sn:%d s:%d sr:%d p:%d",
av_dlog(ctx, " cl:%"PRId64"d sn:%d s:%d sr:%d p:%d",
ref->audio->channel_layout, ref->audio->channel_layout,
ref->audio->nb_samples, ref->audio->nb_samples,
ref->audio->size, ref->audio->size,
@@ -242,13 +242,13 @@ static void ff_dprintf_ref(void *ctx, AVFilterBufferRef *ref, int end)
ref->audio->planar); ref->audio->planar);
} }


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


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


dprintf(ctx,
av_dlog(ctx,
"link[%p r:%"PRId64" cl:%s fmt:%-16s %-16s->%-16s]%s", "link[%p r:%"PRId64" cl:%s fmt:%-16s %-16s->%-16s]%s",
link, link->sample_rate, buf, link, link->sample_rate, buf,
av_get_sample_fmt_name(link->format), av_get_sample_fmt_name(link->format),
@@ -269,15 +269,15 @@ static void ff_dprintf_link(void *ctx, AVFilterLink *link, int end)
} }
} }


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


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


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


if (link->dstpad->get_video_buffer) if (link->dstpad->get_video_buffer)
ret = link->dstpad->get_video_buffer(link, perms, w, h); ret = link->dstpad->get_video_buffer(link, perms, w, h);
@@ -288,7 +288,7 @@ AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int
if (ret) if (ret)
ret->type = AVMEDIA_TYPE_VIDEO; ret->type = AVMEDIA_TYPE_VIDEO;


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


return ret; return ret;
} }
@@ -353,7 +353,7 @@ AVFilterBufferRef *avfilter_get_audio_buffer(AVFilterLink *link, int perms,


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


if (link->srcpad->request_frame) if (link->srcpad->request_frame)
return link->srcpad->request_frame(link); return link->srcpad->request_frame(link);
@@ -388,7 +388,7 @@ void avfilter_start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
AVFilterPad *dst = link->dstpad; AVFilterPad *dst = link->dstpad;
int perms = picref->perms; int perms = picref->perms;


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


if (!(start_frame = dst->start_frame)) if (!(start_frame = dst->start_frame))
start_frame = avfilter_default_start_frame; start_frame = avfilter_default_start_frame;
@@ -435,7 +435,7 @@ void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
int i, j, vsub; int i, j, vsub;
void (*draw_slice)(AVFilterLink *, int, int, int); void (*draw_slice)(AVFilterLink *, int, int, int);


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);
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);


/* copy the slice if needed for permission reasons */ /* copy the slice if needed for permission reasons */
if (link->src_buf) { if (link->src_buf) {


+ 7
- 7
libavformat/asfdec.c View File

@@ -57,7 +57,7 @@ int ff_guidcmp(const void *g1, const void *g2)
#ifdef DEBUG #ifdef DEBUG
#define PRINT_IF_GUID(g,cmp) \ #define PRINT_IF_GUID(g,cmp) \
if (!ff_guidcmp(g, &cmp)) \ if (!ff_guidcmp(g, &cmp)) \
dprintf(NULL, "(GUID: %s) ", #cmp)
av_dlog(NULL, "(GUID: %s) ", #cmp)


static void print_guid(const ff_asf_guid *g) static void print_guid(const ff_asf_guid *g)
{ {
@@ -87,10 +87,10 @@ static void print_guid(const ff_asf_guid *g)
else PRINT_IF_GUID(g, stream_bitrate_guid); else PRINT_IF_GUID(g, stream_bitrate_guid);
else PRINT_IF_GUID(g, ff_asf_language_guid); else PRINT_IF_GUID(g, ff_asf_language_guid);
else else
dprintf(NULL, "(GUID: unknown) ");
av_dlog(NULL, "(GUID: unknown) ");
for(i=0;i<16;i++) for(i=0;i<16;i++)
dprintf(NULL, " 0x%02x,", (*g)[i]);
dprintf(NULL, "}\n");
av_dlog(NULL, " 0x%02x,", (*g)[i]);
av_dlog(NULL, "}\n");
} }
#undef PRINT_IF_GUID #undef PRINT_IF_GUID
#else #else
@@ -177,9 +177,9 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
int ret; int ret;
ff_get_guid(pb, &g); ff_get_guid(pb, &g);
gsize = get_le64(pb); gsize = get_le64(pb);
dprintf(s, "%08"PRIx64": ", gpos);
av_dlog(s, "%08"PRIx64": ", gpos);
print_guid(&g); print_guid(&g);
dprintf(s, " size=0x%"PRIx64"\n", gsize);
av_dlog(s, " size=0x%"PRIx64"\n", gsize);
if (!ff_guidcmp(&g, &ff_asf_data_header)) { if (!ff_guidcmp(&g, &ff_asf_data_header)) {
asf->data_object_offset = url_ftell(pb); asf->data_object_offset = url_ftell(pb);
// if not streaming, gsize is not unlimited (how?), and there is enough space in the file.. // if not streaming, gsize is not unlimited (how?), and there is enough space in the file..
@@ -704,7 +704,7 @@ static int ff_asf_get_packet(AVFormatContext *s, ByteIOContext *pb)
if (packet_length < asf->hdr.min_pktsize) if (packet_length < asf->hdr.min_pktsize)
padsize += asf->hdr.min_pktsize - packet_length; padsize += asf->hdr.min_pktsize - packet_length;
asf->packet_padsize = padsize; asf->packet_padsize = padsize;
dprintf(s, "packet: size=%d padsize=%d left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
av_dlog(s, "packet: size=%d padsize=%d left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
return 0; return 0;
} }




+ 2
- 2
libavformat/avidec.c View File

@@ -85,7 +85,7 @@ static int avi_load_index(AVFormatContext *s);
static int guess_ni_flag(AVFormatContext *s); static int guess_ni_flag(AVFormatContext *s);


#define print_tag(str, tag, size) \ #define print_tag(str, tag, size) \
dprintf(NULL, "%s: tag=%c%c%c%c size=0x%x\n", \
av_dlog(NULL, "%s: tag=%c%c%c%c size=0x%x\n", \
str, tag & 0xff, \ str, tag & 0xff, \
(tag >> 8) & 0xff, \ (tag >> 8) & 0xff, \
(tag >> 16) & 0xff, \ (tag >> 16) & 0xff, \
@@ -380,7 +380,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
avi->movi_list = url_ftell(pb) - 4; avi->movi_list = url_ftell(pb) - 4;
if(size) avi->movi_end = avi->movi_list + size + (size & 1); if(size) avi->movi_end = avi->movi_list + size + (size & 1);
else avi->movi_end = url_fsize(pb); else avi->movi_end = url_fsize(pb);
dprintf(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
goto end_of_header; goto end_of_header;
} }
else if (tag1 == MKTAG('I', 'N', 'F', 'O')) else if (tag1 == MKTAG('I', 'N', 'F', 'O'))


+ 1
- 1
libavformat/ffmdec.c View File

@@ -408,7 +408,7 @@ static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)
if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0) if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
return ret; return ret;


dprintf(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
url_ftell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size); url_ftell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);
if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) != if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
FRAME_HEADER_SIZE) FRAME_HEADER_SIZE)


+ 1
- 1
libavformat/flvdec.c View File

@@ -424,7 +424,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
st->codec->sample_rate = cfg.ext_sample_rate; st->codec->sample_rate = cfg.ext_sample_rate;
else else
st->codec->sample_rate = cfg.sample_rate; st->codec->sample_rate = cfg.sample_rate;
dprintf(s, "mp4a config channels %d sample rate %d\n",
av_dlog(s, "mp4a config channels %d sample rate %d\n",
st->codec->channels, st->codec->sample_rate); st->codec->channels, st->codec->sample_rate);
} }




+ 3
- 3
libavformat/http.c View File

@@ -225,7 +225,7 @@ static int process_line(URLContext *h, char *line, int line_count,
p++; p++;
s->http_code = strtol(p, &end, 10); s->http_code = strtol(p, &end, 10);


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


/* error codes are 4xx and 5xx, but regard 401 as a success, so we /* error codes are 4xx and 5xx, but regard 401 as a success, so we
* don't abort until all headers have been parsed. */ * don't abort until all headers have been parsed. */
@@ -356,7 +356,7 @@ static int http_connect(URLContext *h, const char *path, const char *hoststr,
if (http_get_line(s, line, sizeof(line)) < 0) if (http_get_line(s, line, sizeof(line)) < 0)
return AVERROR(EIO); return AVERROR(EIO);


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


err = process_line(h, line, s->line_count, new_location); err = process_line(h, line, s->line_count, new_location);
if (err < 0) if (err < 0)
@@ -387,7 +387,7 @@ static int http_read(URLContext *h, uint8_t *buf, int size)


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


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


if (!s->chunksize) if (!s->chunksize)
return 0; return 0;


+ 4
- 4
libavformat/isom.c View File

@@ -350,7 +350,7 @@ int ff_mp4_read_descr(AVFormatContext *fc, ByteIOContext *pb, int *tag)
int len; int len;
*tag = get_byte(pb); *tag = get_byte(pb);
len = ff_mp4_read_descr_len(pb); len = ff_mp4_read_descr_len(pb);
dprintf(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
av_dlog(fc, "MPEG4 description: tag=0x%02x len=%d\n", *tag, len);
return len; return len;
} }


@@ -373,10 +373,10 @@ int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, ByteIOContex
get_be32(pb); /* avg bitrate */ get_be32(pb); /* avg bitrate */


st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id); st->codec->codec_id= ff_codec_get_id(ff_mp4_obj_type, object_type_id);
dprintf(fc, "esds object type id 0x%02x\n", object_type_id);
av_dlog(fc, "esds object type id 0x%02x\n", object_type_id);
len = ff_mp4_read_descr(fc, pb, &tag); len = ff_mp4_read_descr(fc, pb, &tag);
if (tag == MP4DecSpecificDescrTag) { if (tag == MP4DecSpecificDescrTag) {
dprintf(fc, "Specific MPEG4 header len=%d\n", len);
av_dlog(fc, "Specific MPEG4 header len=%d\n", len);
if((uint64_t)len > (1<<30)) if((uint64_t)len > (1<<30))
return -1; return -1;
av_free(st->codec->extradata); av_free(st->codec->extradata);
@@ -396,7 +396,7 @@ int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, ByteIOContex
st->codec->sample_rate = cfg.ext_sample_rate; st->codec->sample_rate = cfg.ext_sample_rate;
else else
st->codec->sample_rate = cfg.sample_rate; st->codec->sample_rate = cfg.sample_rate;
dprintf(fc, "mp4a config channels %d obj %d ext obj %d "
av_dlog(fc, "mp4a config channels %d obj %d ext obj %d "
"sample rate %d ext sample rate %d\n", st->codec->channels, "sample rate %d ext sample rate %d\n", st->codec->channels,
cfg.object_type, cfg.ext_object_type, cfg.object_type, cfg.ext_object_type,
cfg.sample_rate, cfg.ext_sample_rate); cfg.sample_rate, cfg.ext_sample_rate);


+ 6
- 6
libavformat/mmsh.c View File

@@ -122,7 +122,7 @@ static int read_data_packet(MMSHContext *mmsh, const int len)
return AVERROR(EIO); return AVERROR(EIO);
} }
res = url_read_complete(mms->mms_hd, mms->in_buffer, len); res = url_read_complete(mms->mms_hd, mms->in_buffer, len);
dprintf(NULL, "Data packet len = %d\n", len);
av_dlog(NULL, "Data packet len = %d\n", len);
if (res != len) { if (res != len) {
av_log(NULL, AV_LOG_ERROR, "Read data packet failed!\n"); av_log(NULL, AV_LOG_ERROR, "Read data packet failed!\n");
return AVERROR(EIO); return AVERROR(EIO);
@@ -156,7 +156,7 @@ static int get_http_header_data(MMSHContext *mmsh)
if (mms->asf_header) { if (mms->asf_header) {
if (len != mms->asf_header_size) { if (len != mms->asf_header_size) {
mms->asf_header_size = len; mms->asf_header_size = len;
dprintf(NULL, "Header len changed from %d to %d\n",
av_dlog(NULL, "Header len changed from %d to %d\n",
mms->asf_header_size, len); mms->asf_header_size, len);
av_freep(&mms->asf_header); av_freep(&mms->asf_header);
} }
@@ -201,7 +201,7 @@ static int get_http_header_data(MMSHContext *mmsh)
av_log(NULL, AV_LOG_ERROR, "Read other chunk type data failed!\n"); av_log(NULL, AV_LOG_ERROR, "Read other chunk type data failed!\n");
return AVERROR(EIO); return AVERROR(EIO);
} else { } else {
dprintf(NULL, "Skip chunk type %d \n", chunk_type);
av_dlog(NULL, "Skip chunk type %d \n", chunk_type);
continue; continue;
} }
} }
@@ -290,7 +290,7 @@ static int mmsh_open(URLContext *h, const char *uri, int flags)
av_log(NULL, AV_LOG_ERROR, "Build play request failed!\n"); av_log(NULL, AV_LOG_ERROR, "Build play request failed!\n");
goto fail; goto fail;
} }
dprintf(NULL, "out_buffer is %s", headers);
av_dlog(NULL, "out_buffer is %s", headers);
ff_http_set_headers(mms->mms_hd, headers); ff_http_set_headers(mms->mms_hd, headers);


err = url_connect(mms->mms_hd); err = url_connect(mms->mms_hd);
@@ -304,12 +304,12 @@ static int mmsh_open(URLContext *h, const char *uri, int flags)
goto fail; goto fail;
} }


dprintf(NULL, "Connection successfully open\n");
av_dlog(NULL, "Connection successfully open\n");
return 0; return 0;
fail: fail:
av_freep(&stream_selection); av_freep(&stream_selection);
mmsh_close(h); mmsh_close(h);
dprintf(NULL, "Connection failed with error %d\n", err);
av_dlog(NULL, "Connection failed with error %d\n", err);
return err; return err;
} }




+ 10
- 10
libavformat/mmst.c View File

@@ -206,11 +206,11 @@ static int send_media_file_request(MMSTContext *mmst)
static void handle_packet_stream_changing_type(MMSTContext *mmst) static void handle_packet_stream_changing_type(MMSTContext *mmst)
{ {
MMSContext *mms = &mmst->mms; MMSContext *mms = &mmst->mms;
dprintf(NULL, "Stream changing!\n");
av_dlog(NULL, "Stream changing!\n");


// 40 is the packet header size, 7 is the prefix size. // 40 is the packet header size, 7 is the prefix size.
mmst->header_packet_id= AV_RL32(mms->in_buffer + 40 + 7); mmst->header_packet_id= AV_RL32(mms->in_buffer + 40 + 7);
dprintf(NULL, "Changed header prefix to 0x%x", mmst->header_packet_id);
av_dlog(NULL, "Changed header prefix to 0x%x", mmst->header_packet_id);
} }


static int send_keepalive_packet(MMSTContext *mmst) static int send_keepalive_packet(MMSTContext *mmst)
@@ -270,7 +270,7 @@ static MMSSCPacketType get_tcp_server_response(MMSTContext *mmst)
} }


length_remaining= AV_RL32(mms->in_buffer+8) + 4; length_remaining= AV_RL32(mms->in_buffer+8) + 4;
dprintf(NULL, "Length remaining is %d\n", length_remaining);
av_dlog(NULL, "Length remaining is %d\n", length_remaining);
// read the rest of the packet. // read the rest of the packet.
if (length_remaining < 0 if (length_remaining < 0
|| length_remaining > sizeof(mms->in_buffer) - 12) { || length_remaining > sizeof(mms->in_buffer) - 12) {
@@ -350,7 +350,7 @@ static MMSSCPacketType get_tcp_server_response(MMSTContext *mmst)
} else if(packet_id_type == mmst->packet_id) { } else if(packet_id_type == mmst->packet_id) {
packet_type = SC_PKT_ASF_MEDIA; packet_type = SC_PKT_ASF_MEDIA;
} else { } else {
dprintf(NULL, "packet id type %d is old.", packet_id_type);
av_dlog(NULL, "packet id type %d is old.", packet_id_type);
continue; continue;
} }
} }
@@ -376,7 +376,7 @@ static int mms_safe_send_recv(MMSTContext *mmst,
if(send_fun) { if(send_fun) {
int ret = send_fun(mmst); int ret = send_fun(mmst);
if (ret < 0) { if (ret < 0) {
dprintf(NULL, "Send Packet error before expecting recv packet %d\n", expect_type);
av_dlog(NULL, "Send Packet error before expecting recv packet %d\n", expect_type);
return ret; return ret;
} }
} }
@@ -554,7 +554,7 @@ static int mms_open(URLContext *h, const char *uri, int flags)
} }
err = ff_mms_asf_header_parser(mms); err = ff_mms_asf_header_parser(mms);
if (err) { if (err) {
dprintf(NULL, "asf header parsed failed!\n");
av_dlog(NULL, "asf header parsed failed!\n");
goto fail; goto fail;
} }
mms->header_parsed = 1; mms->header_parsed = 1;
@@ -571,11 +571,11 @@ static int mms_open(URLContext *h, const char *uri, int flags)
if (err) { if (err) {
goto fail; goto fail;
} }
dprintf(NULL, "Leaving open (success)\n");
av_dlog(NULL, "Leaving open (success)\n");
return 0; return 0;
fail: fail:
mms_close(h); mms_close(h);
dprintf(NULL, "Leaving open (failure: %d)\n", err);
av_dlog(NULL, "Leaving open (failure: %d)\n", err);
return err; return err;
} }


@@ -608,12 +608,12 @@ static int mms_read(URLContext *h, uint8_t *buf, int size)
// copy the data to the packet buffer. // copy the data to the packet buffer.
result = ff_mms_read_data(mms, buf, size); result = ff_mms_read_data(mms, buf, size);
if (result == 0) { if (result == 0) {
dprintf(NULL, "read asf media paket size is zero!\n");
av_dlog(NULL, "read asf media paket size is zero!\n");
break; break;
} }
} }
} else { } else {
dprintf(NULL, "read packet error!\n");
av_dlog(NULL, "read packet error!\n");
break; break;
} }
} }


+ 36
- 36
libavformat/mov.c View File

@@ -266,7 +266,7 @@ static int mov_read_default(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
a.size = get_be32(pb); a.size = get_be32(pb);
a.type = get_le32(pb); a.type = get_le32(pb);
} }
dprintf(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size); a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
total_size += 8; total_size += 8;
if (a.size == 1) { /* 64 bit extended size */ if (a.size == 1) { /* 64 bit extended size */
@@ -349,7 +349,7 @@ static int mov_read_dref(MOVContext *c, ByteIOContext *pb, MOVAtom atom)


dref->type = get_le32(pb); dref->type = get_le32(pb);
get_be32(pb); // version + flags get_be32(pb); // version + flags
dprintf(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);


if (dref->type == MKTAG('a','l','i','s') && size > 150) { if (dref->type == MKTAG('a','l','i','s') && size > 150) {
/* macintosh alias record */ /* macintosh alias record */
@@ -441,8 +441,8 @@ static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
ctype = get_le32(pb); ctype = get_le32(pb);
type = get_le32(pb); /* component subtype */ type = get_le32(pb); /* component subtype */


dprintf(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
dprintf(c->fc, "stype= %.4s\n", (char*)&type);
av_dlog(c->fc, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
av_dlog(c->fc, "stype= %.4s\n", (char*)&type);


if (type == MKTAG('v','i','d','e')) if (type == MKTAG('v','i','d','e'))
st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
@@ -583,7 +583,7 @@ static int mov_read_moov(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
static int mov_read_moof(MOVContext *c, ByteIOContext *pb, MOVAtom atom) static int mov_read_moof(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{ {
c->fragment.moof_offset = url_ftell(pb) - 8; c->fragment.moof_offset = url_ftell(pb) - 8;
dprintf(c->fc, "moof offset %llx\n", c->fragment.moof_offset);
av_dlog(c->fc, "moof offset %llx\n", c->fragment.moof_offset);
return mov_read_default(c, pb, atom); return mov_read_default(c, pb, atom);
} }


@@ -655,7 +655,7 @@ static int mov_read_mvhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
mov_metadata_creation_time(&c->fc->metadata, creation_time); mov_metadata_creation_time(&c->fc->metadata, creation_time);
c->time_scale = get_be32(pb); /* time scale */ c->time_scale = get_be32(pb); /* time scale */


dprintf(c->fc, "time scale = %i\n", c->time_scale);
av_dlog(c->fc, "time scale = %i\n", c->time_scale);


c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */ c->duration = (version == 1) ? get_be64(pb) : get_be32(pb); /* duration */
get_be32(pb); /* preferred scale */ get_be32(pb); /* preferred scale */
@@ -697,7 +697,7 @@ static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
st->codec->extradata_size = 0x5a + atom.size; st->codec->extradata_size = 0x5a + atom.size;
memcpy(st->codec->extradata, "SVQ3", 4); // fake memcpy(st->codec->extradata, "SVQ3", 4); // fake
get_buffer(pb, st->codec->extradata + 0x5a, atom.size); get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
dprintf(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);
av_dlog(c->fc, "Reading SMI %"PRId64" %s\n", atom.size, st->codec->extradata + 0x5a);
return 0; return 0;
} }


@@ -711,7 +711,7 @@ static int mov_read_enda(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
st = c->fc->streams[c->fc->nb_streams-1]; st = c->fc->streams[c->fc->nb_streams-1];


little_endian = get_be16(pb); little_endian = get_be16(pb);
dprintf(c->fc, "enda %d\n", little_endian);
av_dlog(c->fc, "enda %d\n", little_endian);
if (little_endian == 1) { if (little_endian == 1) {
switch (st->codec->codec_id) { switch (st->codec->codec_id) {
case CODEC_ID_PCM_S24BE: case CODEC_ID_PCM_S24BE:
@@ -974,7 +974,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, ByteIOContext *pb, int entries)
} }
} }


dprintf(c->fc, "size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
av_dlog(c->fc, "size=%d 4CC= %c%c%c%c codec_type=%d\n", size,
(format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff, (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
(format >> 24) & 0xff, st->codec->codec_type); (format >> 24) & 0xff, st->codec->codec_type);


@@ -1009,7 +1009,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, ByteIOContext *pb, int entries)


st->codec->bits_per_coded_sample = get_be16(pb); /* depth */ st->codec->bits_per_coded_sample = get_be16(pb); /* depth */
st->codec->color_table_id = get_be16(pb); /* colortable id */ st->codec->color_table_id = get_be16(pb); /* colortable id */
dprintf(c->fc, "depth %d, ctab id %d\n",
av_dlog(c->fc, "depth %d, ctab id %d\n",
st->codec->bits_per_coded_sample, st->codec->color_table_id); st->codec->bits_per_coded_sample, st->codec->color_table_id);
/* figure out the palette situation */ /* figure out the palette situation */
color_depth = st->codec->bits_per_coded_sample & 0x1F; color_depth = st->codec->bits_per_coded_sample & 0x1F;
@@ -1091,7 +1091,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, ByteIOContext *pb, int entries)
get_be32(pb); /* vendor */ get_be32(pb); /* vendor */


st->codec->channels = get_be16(pb); /* channel count */ st->codec->channels = get_be16(pb); /* channel count */
dprintf(c->fc, "audio channels %d\n", st->codec->channels);
av_dlog(c->fc, "audio channels %d\n", st->codec->channels);
st->codec->bits_per_coded_sample = get_be16(pb); /* sample size */ st->codec->bits_per_coded_sample = get_be16(pb); /* sample size */


sc->audio_cid = get_be16(pb); sc->audio_cid = get_be16(pb);
@@ -1100,7 +1100,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, ByteIOContext *pb, int entries)
st->codec->sample_rate = ((get_be32(pb) >> 16)); st->codec->sample_rate = ((get_be32(pb) >> 16));


//Read QT version 1 fields. In version 0 these do not exist. //Read QT version 1 fields. In version 0 these do not exist.
dprintf(c->fc, "version =%d, isom =%d\n",version,c->isom);
av_dlog(c->fc, "version =%d, isom =%d\n",version,c->isom);
if(!c->isom) { if(!c->isom) {
if(version==1) { if(version==1) {
sc->samples_per_frame = get_be32(pb); sc->samples_per_frame = get_be32(pb);
@@ -1271,7 +1271,7 @@ static int mov_read_stsc(MOVContext *c, ByteIOContext *pb, MOVAtom atom)


entries = get_be32(pb); entries = get_be32(pb);


dprintf(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
av_dlog(c->fc, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);


if(entries >= UINT_MAX / sizeof(*sc->stsc_data)) if(entries >= UINT_MAX / sizeof(*sc->stsc_data))
return -1; return -1;
@@ -1311,7 +1311,7 @@ static int mov_read_stps(MOVContext *c, ByteIOContext *pb, MOVAtom atom)


for (i = 0; i < entries; i++) { for (i = 0; i < entries; i++) {
sc->stps_data[i] = get_be32(pb); sc->stps_data[i] = get_be32(pb);
//dprintf(c->fc, "stps %d\n", sc->stps_data[i]);
//av_dlog(c->fc, "stps %d\n", sc->stps_data[i]);
} }


return 0; return 0;
@@ -1333,7 +1333,7 @@ static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOVAtom atom)


entries = get_be32(pb); entries = get_be32(pb);


dprintf(c->fc, "keyframe_count = %d\n", entries);
av_dlog(c->fc, "keyframe_count = %d\n", entries);


if(entries >= UINT_MAX / sizeof(int)) if(entries >= UINT_MAX / sizeof(int))
return -1; return -1;
@@ -1344,7 +1344,7 @@ static int mov_read_stss(MOVContext *c, ByteIOContext *pb, MOVAtom atom)


for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
sc->keyframes[i] = get_be32(pb); sc->keyframes[i] = get_be32(pb);
//dprintf(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
//av_dlog(c->fc, "keyframes[]=%d\n", sc->keyframes[i]);
} }
return 0; return 0;
} }
@@ -1377,7 +1377,7 @@ static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
} }
entries = get_be32(pb); entries = get_be32(pb);


dprintf(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
av_dlog(c->fc, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);


sc->sample_count = entries; sc->sample_count = entries;
if (sample_size) if (sample_size)
@@ -1434,7 +1434,7 @@ static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
get_be24(pb); /* flags */ get_be24(pb); /* flags */
entries = get_be32(pb); entries = get_be32(pb);


dprintf(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);
av_dlog(c->fc, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1, entries);


if(entries >= UINT_MAX / sizeof(*sc->stts_data)) if(entries >= UINT_MAX / sizeof(*sc->stts_data))
return -1; return -1;
@@ -1452,7 +1452,7 @@ static int mov_read_stts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
sc->stts_data[i].count= sample_count; sc->stts_data[i].count= sample_count;
sc->stts_data[i].duration= sample_duration; sc->stts_data[i].duration= sample_duration;


dprintf(c->fc, "sample_count=%d, sample_duration=%d\n",sample_count,sample_duration);
av_dlog(c->fc, "sample_count=%d, sample_duration=%d\n",sample_count,sample_duration);


duration+=(int64_t)sample_duration*sample_count; duration+=(int64_t)sample_duration*sample_count;
total_sample_count+=sample_count; total_sample_count+=sample_count;
@@ -1479,7 +1479,7 @@ static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
get_be24(pb); /* flags */ get_be24(pb); /* flags */
entries = get_be32(pb); entries = get_be32(pb);


dprintf(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
av_dlog(c->fc, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);


if(entries >= UINT_MAX / sizeof(*sc->ctts_data)) if(entries >= UINT_MAX / sizeof(*sc->ctts_data))
return -1; return -1;
@@ -1498,7 +1498,7 @@ static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
sc->dts_shift = FFMAX(sc->dts_shift, -duration); sc->dts_shift = FFMAX(sc->dts_shift, -duration);
} }


dprintf(c->fc, "dts shift %d\n", sc->dts_shift);
av_dlog(c->fc, "dts shift %d\n", sc->dts_shift);


return 0; return 0;
} }
@@ -1578,7 +1578,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
e->size = sample_size; e->size = sample_size;
e->min_distance = distance; e->min_distance = distance;
e->flags = keyframe ? AVINDEX_KEYFRAME : 0; e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
dprintf(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
av_dlog(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
"size %d, distance %d, keyframe %d\n", st->index, current_sample, "size %d, distance %d, keyframe %d\n", st->index, current_sample,
current_offset, current_dts, sample_size, distance, keyframe); current_offset, current_dts, sample_size, distance, keyframe);
} }
@@ -1626,7 +1626,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
total += chunk_count * count; total += chunk_count * count;
} }


dprintf(mov->fc, "chunk count %d\n", total);
av_dlog(mov->fc, "chunk count %d\n", total);
if (total >= UINT_MAX / sizeof(*st->index_entries)) if (total >= UINT_MAX / sizeof(*st->index_entries))
return; return;
st->index_entries = av_malloc(total*sizeof(*st->index_entries)); st->index_entries = av_malloc(total*sizeof(*st->index_entries));
@@ -1670,7 +1670,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
e->size = size; e->size = size;
e->min_distance = 0; e->min_distance = 0;
e->flags = AVINDEX_KEYFRAME; e->flags = AVINDEX_KEYFRAME;
dprintf(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
av_dlog(mov->fc, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
"size %d, duration %d\n", st->index, i, current_offset, current_dts, "size %d, duration %d\n", st->index, i, current_offset, current_dts,
size, samples); size, samples);


@@ -1764,7 +1764,7 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
!st->codec->frame_size && sc->stts_count == 1) { !st->codec->frame_size && sc->stts_count == 1) {
st->codec->frame_size = av_rescale(sc->stts_data[0].duration, st->codec->frame_size = av_rescale(sc->stts_data[0].duration,
st->codec->sample_rate, sc->time_scale); st->codec->sample_rate, sc->time_scale);
dprintf(c->fc, "frame size %d\n", st->codec->frame_size);
av_dlog(c->fc, "frame size %d\n", st->codec->frame_size);
} }


mov_build_index(c, st); mov_build_index(c, st);
@@ -1961,7 +1961,7 @@ static int mov_read_tfhd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration; frag->duration = flags & 0x08 ? get_be32(pb) : trex->duration;
frag->size = flags & 0x10 ? get_be32(pb) : trex->size; frag->size = flags & 0x10 ? get_be32(pb) : trex->size;
frag->flags = flags & 0x20 ? get_be32(pb) : trex->flags; frag->flags = flags & 0x20 ? get_be32(pb) : trex->flags;
dprintf(c->fc, "frag flags 0x%x\n", frag->flags);
av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
return 0; return 0;
} }


@@ -2019,7 +2019,7 @@ static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
get_byte(pb); /* version */ get_byte(pb); /* version */
flags = get_be24(pb); flags = get_be24(pb);
entries = get_be32(pb); entries = get_be32(pb);
dprintf(c->fc, "flags 0x%x entries %d\n", flags, entries);
av_dlog(c->fc, "flags 0x%x entries %d\n", flags, entries);
if (flags & 0x001) data_offset = get_be32(pb); if (flags & 0x001) data_offset = get_be32(pb);
if (flags & 0x004) first_sample_flags = get_be32(pb); if (flags & 0x004) first_sample_flags = get_be32(pb);
if (flags & 0x800) { if (flags & 0x800) {
@@ -2035,7 +2035,7 @@ static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
dts = st->duration; dts = st->duration;
offset = frag->base_data_offset + data_offset; offset = frag->base_data_offset + data_offset;
distance = 0; distance = 0;
dprintf(c->fc, "first sample flags 0x%x\n", first_sample_flags);
av_dlog(c->fc, "first sample flags 0x%x\n", first_sample_flags);
for (i = 0; i < entries; i++) { for (i = 0; i < entries; i++) {
unsigned sample_size = frag->size; unsigned sample_size = frag->size;
int sample_flags = i ? frag->flags : first_sample_flags; int sample_flags = i ? frag->flags : first_sample_flags;
@@ -2055,7 +2055,7 @@ static int mov_read_trun(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
distance = 0; distance = 0;
av_add_index_entry(st, offset, dts, sample_size, distance, av_add_index_entry(st, offset, dts, sample_size, distance,
keyframe ? AVINDEX_KEYFRAME : 0); keyframe ? AVINDEX_KEYFRAME : 0);
dprintf(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
av_dlog(c->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
"size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i, "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
offset, dts, sample_size, distance, keyframe); offset, dts, sample_size, distance, keyframe);
distance++; distance++;
@@ -2172,7 +2172,7 @@ static int mov_read_elst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, " av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
"a/v desync might occur, patch welcome\n"); "a/v desync might occur, patch welcome\n");


dprintf(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
return 0; return 0;
} }


@@ -2363,7 +2363,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
av_log(s, AV_LOG_ERROR, "moov atom not found\n"); av_log(s, AV_LOG_ERROR, "moov atom not found\n");
return -1; return -1;
} }
dprintf(mov->fc, "on_parse_exit_offset=%lld\n", url_ftell(pb));
av_dlog(mov->fc, "on_parse_exit_offset=%lld\n", url_ftell(pb));


if (!url_is_streamed(pb) && mov->chapter_track > 0) if (!url_is_streamed(pb) && mov->chapter_track > 0)
mov_read_chapters(s); mov_read_chapters(s);
@@ -2382,7 +2382,7 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
if (msc->pb && msc->current_sample < avst->nb_index_entries) { if (msc->pb && msc->current_sample < avst->nb_index_entries) {
AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample]; AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale); int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
dprintf(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
av_dlog(s, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) || if (!sample || (url_is_streamed(s->pb) && current_sample->pos < sample->pos) ||
(!url_is_streamed(s->pb) && (!url_is_streamed(s->pb) &&
((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
@@ -2412,7 +2412,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 || mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
url_feof(s->pb)) url_feof(s->pb))
return AVERROR_EOF; return AVERROR_EOF;
dprintf(s, "read fragments, offset 0x%llx\n", url_ftell(s->pb));
av_dlog(s, "read fragments, offset 0x%llx\n", url_ftell(s->pb));
goto retry; goto retry;
} }
sc = st->priv_data; sc = st->priv_data;
@@ -2463,7 +2463,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
goto retry; goto retry;
pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0; pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
pkt->pos = sample->pos; pkt->pos = sample->pos;
dprintf(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
av_dlog(s, "stream %d, pts %"PRId64", dts %"PRId64", pos 0x%"PRIx64", duration %d\n",
pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration); pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration);
return 0; return 0;
} }
@@ -2475,13 +2475,13 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
int i; int i;


sample = av_index_search_timestamp(st, timestamp, flags); sample = av_index_search_timestamp(st, timestamp, flags);
dprintf(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
av_dlog(s, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp) if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
sample = 0; sample = 0;
if (sample < 0) /* not sure what to do */ if (sample < 0) /* not sure what to do */
return -1; return -1;
sc->current_sample = sample; sc->current_sample = sample;
dprintf(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
av_dlog(s, "stream %d, found sample %d\n", st->index, sc->current_sample);
/* adjust ctts index */ /* adjust ctts index */
if (sc->ctts_data) { if (sc->ctts_data) {
time_sample = 0; time_sample = 0;


+ 15
- 15
libavformat/mpegts.c View File

@@ -289,7 +289,7 @@ static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int
MpegTSFilter *filter; MpegTSFilter *filter;
MpegTSSectionFilter *sec; MpegTSSectionFilter *sec;


dprintf(ts->stream, "Filter: pid=0x%x\n", pid);
av_dlog(ts->stream, "Filter: pid=0x%x\n", pid);


if (pid >= NB_PID_MAX || ts->pids[pid]) if (pid >= NB_PID_MAX || ts->pids[pid])
return NULL; return NULL;
@@ -678,7 +678,7 @@ static int mpegts_push_data(MpegTSFilter *filter,
pes->header[2] == 0x01) { pes->header[2] == 0x01) {
/* it must be an mpeg2 PES stream */ /* it must be an mpeg2 PES stream */
code = pes->header[3] | 0x100; code = pes->header[3] | 0x100;
dprintf(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code);
av_dlog(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code);


if ((pes->st && pes->st->discard == AVDISCARD_ALL) || if ((pes->st && pes->st->discard == AVDISCARD_ALL) ||
code == 0x1be) /* padding_stream */ code == 0x1be) /* padding_stream */
@@ -714,7 +714,7 @@ static int mpegts_push_data(MpegTSFilter *filter,
code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */ code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
pes->state = MPEGTS_PESHEADER; pes->state = MPEGTS_PESHEADER;
if (pes->st->codec->codec_id == CODEC_ID_NONE) { if (pes->st->codec->codec_id == CODEC_ID_NONE) {
dprintf(pes->stream, "pid=%x stream_type=%x probing\n",
av_dlog(pes->stream, "pid=%x stream_type=%x probing\n",
pes->pid, pes->stream_type); pes->pid, pes->stream_type);
pes->st->codec->codec_id = CODEC_ID_PROBE; pes->st->codec->codec_id = CODEC_ID_PROBE;
} }
@@ -878,7 +878,7 @@ static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
len = ff_mp4_read_descr(s, &pb, &tag); len = ff_mp4_read_descr(s, &pb, &tag);
if (tag == MP4ESDescrTag) { if (tag == MP4ESDescrTag) {
*es_id = get_be16(&pb); /* ES_ID */ *es_id = get_be16(&pb); /* ES_ID */
dprintf(s, "ES_ID %#x\n", *es_id);
av_dlog(s, "ES_ID %#x\n", *es_id);
get_byte(&pb); /* priority */ get_byte(&pb); /* priority */
len = ff_mp4_read_descr(s, &pb, &tag); len = ff_mp4_read_descr(s, &pb, &tag);
if (tag == MP4DecConfigDescrTag) { if (tag == MP4DecConfigDescrTag) {
@@ -912,7 +912,7 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type
if (desc_end > desc_list_end) if (desc_end > desc_list_end)
return -1; return -1;


dprintf(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
av_dlog(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);


if (st->codec->codec_id == CODEC_ID_NONE && if (st->codec->codec_id == CODEC_ID_NONE &&
stream_type == STREAM_TYPE_PRIVATE_DATA) stream_type == STREAM_TYPE_PRIVATE_DATA)
@@ -967,7 +967,7 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type
break; break;
case 0x05: /* registration descriptor */ case 0x05: /* registration descriptor */
st->codec->codec_tag = bytestream_get_le32(pp); st->codec->codec_tag = bytestream_get_le32(pp);
dprintf(fc, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
av_dlog(fc, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
if (st->codec->codec_id == CODEC_ID_NONE && if (st->codec->codec_id == CODEC_ID_NONE &&
stream_type == STREAM_TYPE_PRIVATE_DATA) stream_type == STREAM_TYPE_PRIVATE_DATA)
mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types); mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
@@ -994,7 +994,7 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
int mp4_es_id = 0; int mp4_es_id = 0;


#ifdef DEBUG #ifdef DEBUG
dprintf(ts->stream, "PMT: len %i\n", section_len);
av_dlog(ts->stream, "PMT: len %i\n", section_len);
av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
#endif #endif


@@ -1003,7 +1003,7 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
if (parse_section_header(h, &p, p_end) < 0) if (parse_section_header(h, &p, p_end) < 0)
return; return;


dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n",
av_dlog(ts->stream, "sid=0x%x sec_num=%d/%d\n",
h->id, h->sec_num, h->last_sec_num); h->id, h->sec_num, h->last_sec_num);


if (h->tid != PMT_TID) if (h->tid != PMT_TID)
@@ -1015,7 +1015,7 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
return; return;
add_pid_to_pmt(ts, h->id, pcr_pid); add_pid_to_pmt(ts, h->id, pcr_pid);


dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid);
av_dlog(ts->stream, "pcr_pid=0x%x\n", pcr_pid);


program_info_length = get16(&p, p_end) & 0xfff; program_info_length = get16(&p, p_end) & 0xfff;
if (program_info_length < 0) if (program_info_length < 0)
@@ -1025,7 +1025,7 @@ static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
tag = get8(&p, p_end); tag = get8(&p, p_end);
len = get8(&p, p_end); len = get8(&p, p_end);


dprintf(ts->stream, "program tag: 0x%02x len=%d\n", tag, len);
av_dlog(ts->stream, "program tag: 0x%02x len=%d\n", tag, len);


if(len > program_info_length - 2) if(len > program_info_length - 2)
//something else is broken, exit the program_descriptors_loop //something else is broken, exit the program_descriptors_loop
@@ -1114,7 +1114,7 @@ static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
int sid, pmt_pid; int sid, pmt_pid;


#ifdef DEBUG #ifdef DEBUG
dprintf(ts->stream, "PAT:\n");
av_dlog(ts->stream, "PAT:\n");
av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
#endif #endif
p_end = section + section_len - 4; p_end = section + section_len - 4;
@@ -1133,7 +1133,7 @@ static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
if (pmt_pid < 0) if (pmt_pid < 0)
break; break;


dprintf(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
av_dlog(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);


if (sid == 0x0000) { if (sid == 0x0000) {
/* NIT info */ /* NIT info */
@@ -1158,7 +1158,7 @@ static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
char *name, *provider_name; char *name, *provider_name;


#ifdef DEBUG #ifdef DEBUG
dprintf(ts->stream, "SDT:\n");
av_dlog(ts->stream, "SDT:\n");
av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
#endif #endif


@@ -1196,7 +1196,7 @@ static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len
if (desc_end > desc_list_end) if (desc_end > desc_list_end)
break; break;


dprintf(ts->stream, "tag: 0x%02x len=%d\n",
av_dlog(ts->stream, "tag: 0x%02x len=%d\n",
desc_tag, desc_len); desc_tag, desc_len);


switch(desc_tag) { switch(desc_tag) {
@@ -1484,7 +1484,7 @@ static int mpegts_read_header(AVFormatContext *s,


ts->auto_guess = 1; ts->auto_guess = 1;


dprintf(ts->stream, "tuning done\n");
av_dlog(ts->stream, "tuning done\n");


s->ctx_flags |= AVFMTCTX_NOHEADER; s->ctx_flags |= AVFMTCTX_NOHEADER;
} else { } else {


+ 1
- 1
libavformat/mxf.h View File

@@ -63,7 +63,7 @@ extern const MXFCodecUL ff_mxf_codec_uls[];


int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum PixelFormat *pix_fmt); int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum PixelFormat *pix_fmt);


#define PRINT_KEY(pc, s, x) dprintf(pc, "%s %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", s, \
#define PRINT_KEY(pc, s, x) av_dlog(pc, "%s %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", s, \
(x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5], (x)[6], (x)[7], (x)[8], (x)[9], (x)[10], (x)[11], (x)[12], (x)[13], (x)[14], (x)[15]) (x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5], (x)[6], (x)[7], (x)[8], (x)[9], (x)[10], (x)[11], (x)[12], (x)[13], (x)[14], (x)[15])


#endif /* AVFORMAT_MXF_H */ #endif /* AVFORMAT_MXF_H */

+ 12
- 12
libavformat/mxfdec.c View File

@@ -309,7 +309,7 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
if (klv_read_packet(&klv, s->pb) < 0) if (klv_read_packet(&klv, s->pb) < 0)
return -1; return -1;
PRINT_KEY(s, "read packet", klv.key); PRINT_KEY(s, "read packet", klv.key);
dprintf(s, "size %lld offset %#llx\n", klv.length, klv.offset);
av_dlog(s, "size %lld offset %#llx\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) { if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
int res = mxf_decrypt_triplet(s, pkt, &klv); int res = mxf_decrypt_triplet(s, pkt, &klv);
if (res < 0) { if (res < 0) {
@@ -518,12 +518,12 @@ static int mxf_read_source_package(void *arg, ByteIOContext *pb, int tag, int si
static int mxf_read_index_table_segment(void *arg, ByteIOContext *pb, int tag, int size, UID uid) static int mxf_read_index_table_segment(void *arg, ByteIOContext *pb, int tag, int size, UID uid)
{ {
switch(tag) { switch(tag) {
case 0x3F05: dprintf(NULL, "EditUnitByteCount %d\n", get_be32(pb)); break;
case 0x3F06: dprintf(NULL, "IndexSID %d\n", get_be32(pb)); break;
case 0x3F07: dprintf(NULL, "BodySID %d\n", get_be32(pb)); break;
case 0x3F0B: dprintf(NULL, "IndexEditRate %d/%d\n", get_be32(pb), get_be32(pb)); break;
case 0x3F0C: dprintf(NULL, "IndexStartPosition %lld\n", get_be64(pb)); break;
case 0x3F0D: dprintf(NULL, "IndexDuration %lld\n", get_be64(pb)); break;
case 0x3F05: av_dlog(NULL, "EditUnitByteCount %d\n", get_be32(pb)); break;
case 0x3F06: av_dlog(NULL, "IndexSID %d\n", get_be32(pb)); break;
case 0x3F07: av_dlog(NULL, "BodySID %d\n", get_be32(pb)); break;
case 0x3F0B: av_dlog(NULL, "IndexEditRate %d/%d\n", get_be32(pb), get_be32(pb)); break;
case 0x3F0C: av_dlog(NULL, "IndexStartPosition %lld\n", get_be64(pb)); break;
case 0x3F0D: av_dlog(NULL, "IndexDuration %lld\n", get_be64(pb)); break;
} }
return 0; return 0;
} }
@@ -536,7 +536,7 @@ static void mxf_read_pixel_layout(ByteIOContext *pb, MXFDescriptor *descriptor)
do { do {
code = get_byte(pb); code = get_byte(pb);
value = get_byte(pb); value = get_byte(pb);
dprintf(NULL, "pixel layout: code %#x\n", code);
av_dlog(NULL, "pixel layout: code %#x\n", code);


if (ofs < 16) { if (ofs < 16) {
layout[ofs++] = code; layout[ofs++] = code;
@@ -666,7 +666,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
MXFPackage *temp_package = NULL; MXFPackage *temp_package = NULL;
int i, j, k; int i, j, k;


dprintf(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
/* TODO: handle multiple material packages (OP3x) */ /* TODO: handle multiple material packages (OP3x) */
for (i = 0; i < mxf->packages_count; i++) { for (i = 0; i < mxf->packages_count; i++) {
material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage); material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
@@ -876,7 +876,7 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
uint64_t next = url_ftell(pb) + size; uint64_t next = url_ftell(pb) + size;
UID uid = {0}; UID uid = {0};


dprintf(mxf->fc, "local tag %#04x size %d\n", tag, size);
av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */ if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag); av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
continue; continue;
@@ -887,7 +887,7 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF
int local_tag = AV_RB16(mxf->local_tags+i*18); int local_tag = AV_RB16(mxf->local_tags+i*18);
if (local_tag == tag) { if (local_tag == tag) {
memcpy(uid, mxf->local_tags+i*18+2, 16); memcpy(uid, mxf->local_tags+i*18+2, 16);
dprintf(mxf->fc, "local tag %#04x\n", local_tag);
av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
PRINT_KEY(mxf->fc, "uid", uid); PRINT_KEY(mxf->fc, "uid", uid);
} }
} }
@@ -920,7 +920,7 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (klv_read_packet(&klv, s->pb) < 0) if (klv_read_packet(&klv, s->pb) < 0)
return -1; return -1;
PRINT_KEY(s, "read header", klv.key); PRINT_KEY(s, "read header", klv.key);
dprintf(s, "size %lld offset %#llx\n", klv.length, klv.offset);
av_dlog(s, "size %lld offset %#llx\n", klv.length, klv.offset);
if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) || if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
IS_KLV_KEY(klv.key, mxf_essence_element_key)) { IS_KLV_KEY(klv.key, mxf_essence_element_key)) {
/* FIXME avoid seek */ /* FIXME avoid seek */


+ 30
- 30
libavformat/r3d.c View File

@@ -43,7 +43,7 @@ static int read_atom(AVFormatContext *s, Atom *atom)
if (atom->size < 8) if (atom->size < 8)
return -1; return -1;
atom->tag = get_le32(s->pb); atom->tag = get_le32(s->pb);
dprintf(s, "atom %d %.4s offset %#llx\n",
av_dlog(s, "atom %d %.4s offset %#llx\n",
atom->size, (char*)&atom->tag, atom->offset); atom->size, (char*)&atom->tag, atom->offset);
return atom->size; return atom->size;
} }
@@ -61,16 +61,16 @@ static int r3d_read_red1(AVFormatContext *s)


tmp = get_byte(s->pb); // major version tmp = get_byte(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = get_byte(s->pb); // minor version
dprintf(s, "version %d.%d\n", tmp, tmp2);
av_dlog(s, "version %d.%d\n", tmp, tmp2);


tmp = get_be16(s->pb); // unknown tmp = get_be16(s->pb); // unknown
dprintf(s, "unknown1 %d\n", tmp);
av_dlog(s, "unknown1 %d\n", tmp);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
av_set_pts_info(st, 32, 1, tmp); av_set_pts_info(st, 32, 1, tmp);


tmp = get_be32(s->pb); // filenum tmp = get_be32(s->pb); // filenum
dprintf(s, "filenum %d\n", tmp);
av_dlog(s, "filenum %d\n", tmp);


url_fskip(s->pb, 32); // unknown url_fskip(s->pb, 32); // unknown


@@ -78,13 +78,13 @@ static int r3d_read_red1(AVFormatContext *s)
st->codec->height = get_be32(s->pb); st->codec->height = get_be32(s->pb);


tmp = get_be16(s->pb); // unknown tmp = get_be16(s->pb); // unknown
dprintf(s, "unknown2 %d\n", tmp);
av_dlog(s, "unknown2 %d\n", tmp);


st->codec->time_base.den = get_be16(s->pb); st->codec->time_base.den = get_be16(s->pb);
st->codec->time_base.num = get_be16(s->pb); st->codec->time_base.num = get_be16(s->pb);


tmp = get_byte(s->pb); // audio channels tmp = get_byte(s->pb); // audio channels
dprintf(s, "audio channels %d\n", tmp);
av_dlog(s, "audio channels %d\n", tmp);
if (tmp > 0) { if (tmp > 0) {
AVStream *ast = av_new_stream(s, 1); AVStream *ast = av_new_stream(s, 1);
if (!ast) if (!ast)
@@ -99,10 +99,10 @@ static int r3d_read_red1(AVFormatContext *s)
filename[sizeof(filename)-1] = 0; filename[sizeof(filename)-1] = 0;
av_metadata_set2(&st->metadata, "filename", filename, 0); av_metadata_set2(&st->metadata, "filename", filename, 0);


dprintf(s, "filename %s\n", filename);
dprintf(s, "resolution %dx%d\n", st->codec->width, st->codec->height);
dprintf(s, "timescale %d\n", st->time_base.den);
dprintf(s, "frame rate %d/%d\n",
av_dlog(s, "filename %s\n", filename);
av_dlog(s, "resolution %dx%d\n", st->codec->width, st->codec->height);
av_dlog(s, "timescale %d\n", st->time_base.den);
av_dlog(s, "frame rate %d/%d\n",
st->codec->time_base.num, st->codec->time_base.den); st->codec->time_base.num, st->codec->time_base.den);


return 0; return 0;
@@ -125,13 +125,13 @@ static int r3d_read_rdvo(AVFormatContext *s, Atom *atom)
r3d->video_offsets_count = i; r3d->video_offsets_count = i;
break; break;
} }
dprintf(s, "video offset %d: %#x\n", i, r3d->video_offsets[i]);
av_dlog(s, "video offset %d: %#x\n", i, r3d->video_offsets[i]);
} }


if (st->codec->time_base.den) if (st->codec->time_base.den)
st->duration = (uint64_t)r3d->video_offsets_count* st->duration = (uint64_t)r3d->video_offsets_count*
st->time_base.den*st->codec->time_base.num/st->codec->time_base.den; st->time_base.den*st->codec->time_base.num/st->codec->time_base.den;
dprintf(s, "duration %lld\n", st->duration);
av_dlog(s, "duration %lld\n", st->duration);


return 0; return 0;
} }
@@ -147,10 +147,10 @@ static void r3d_read_reos(AVFormatContext *s)
get_be32(s->pb); // rdas offset get_be32(s->pb); // rdas offset


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "num video chunks %d\n", tmp);
av_dlog(s, "num video chunks %d\n", tmp);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "num audio chunks %d\n", tmp);
av_dlog(s, "num audio chunks %d\n", tmp);


url_fskip(s->pb, 6*4); url_fskip(s->pb, 6*4);
} }
@@ -176,7 +176,7 @@ static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap)
} }


s->data_offset = url_ftell(s->pb); s->data_offset = url_ftell(s->pb);
dprintf(s, "data offset %#llx\n", s->data_offset);
av_dlog(s, "data offset %#llx\n", s->data_offset);
if (url_is_streamed(s->pb)) if (url_is_streamed(s->pb))
return 0; return 0;
// find REOB/REOF/REOS to load index // find REOB/REOF/REOS to load index
@@ -217,29 +217,29 @@ static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)
dts = get_be32(s->pb); dts = get_be32(s->pb);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "frame num %d\n", tmp);
av_dlog(s, "frame num %d\n", tmp);


tmp = get_byte(s->pb); // major version tmp = get_byte(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = get_byte(s->pb); // minor version
dprintf(s, "version %d.%d\n", tmp, tmp2);
av_dlog(s, "version %d.%d\n", tmp, tmp2);


tmp = get_be16(s->pb); // unknown tmp = get_be16(s->pb); // unknown
dprintf(s, "unknown %d\n", tmp);
av_dlog(s, "unknown %d\n", tmp);


if (tmp > 4) { if (tmp > 4) {
tmp = get_be16(s->pb); // unknown tmp = get_be16(s->pb); // unknown
dprintf(s, "unknown %d\n", tmp);
av_dlog(s, "unknown %d\n", tmp);


tmp = get_be16(s->pb); // unknown tmp = get_be16(s->pb); // unknown
dprintf(s, "unknown %d\n", tmp);
av_dlog(s, "unknown %d\n", tmp);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "width %d\n", tmp);
av_dlog(s, "width %d\n", tmp);
tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "height %d\n", tmp);
av_dlog(s, "height %d\n", tmp);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "metadata len %d\n", tmp);
av_dlog(s, "metadata len %d\n", tmp);
} }
tmp = atom->size - 8 - (url_ftell(s->pb) - pos); tmp = atom->size - 8 - (url_ftell(s->pb) - pos);
if (tmp < 0) if (tmp < 0)
@@ -255,7 +255,7 @@ static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)
if (st->codec->time_base.den) if (st->codec->time_base.den)
pkt->duration = (uint64_t)st->time_base.den* pkt->duration = (uint64_t)st->time_base.den*
st->codec->time_base.num/st->codec->time_base.den; st->codec->time_base.num/st->codec->time_base.den;
dprintf(s, "pkt dts %lld duration %d\n", pkt->dts, pkt->duration);
av_dlog(s, "pkt dts %lld duration %d\n", pkt->dts, pkt->duration);


return 0; return 0;
} }
@@ -275,17 +275,17 @@ static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)
samples = get_be32(s->pb); samples = get_be32(s->pb);


tmp = get_be32(s->pb); tmp = get_be32(s->pb);
dprintf(s, "packet num %d\n", tmp);
av_dlog(s, "packet num %d\n", tmp);


tmp = get_be16(s->pb); // unkown tmp = get_be16(s->pb); // unkown
dprintf(s, "unknown %d\n", tmp);
av_dlog(s, "unknown %d\n", tmp);


tmp = get_byte(s->pb); // major version tmp = get_byte(s->pb); // major version
tmp2 = get_byte(s->pb); // minor version tmp2 = get_byte(s->pb); // minor version
dprintf(s, "version %d.%d\n", tmp, tmp2);
av_dlog(s, "version %d.%d\n", tmp, tmp2);


tmp = get_be32(s->pb); // unknown tmp = get_be32(s->pb); // unknown
dprintf(s, "unknown %d\n", tmp);
av_dlog(s, "unknown %d\n", tmp);


size = atom->size - 8 - (url_ftell(s->pb) - pos); size = atom->size - 8 - (url_ftell(s->pb) - pos);
if (size < 0) if (size < 0)
@@ -299,7 +299,7 @@ static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)
pkt->stream_index = 1; pkt->stream_index = 1;
pkt->dts = dts; pkt->dts = dts;
pkt->duration = av_rescale(samples, st->time_base.den, st->codec->sample_rate); pkt->duration = av_rescale(samples, st->time_base.den, st->codec->sample_rate);
dprintf(s, "pkt dts %lld duration %d samples %d sample rate %d\n",
av_dlog(s, "pkt dts %lld duration %d samples %d sample rate %d\n",
pkt->dts, pkt->duration, samples, st->codec->sample_rate); pkt->dts, pkt->duration, samples, st->codec->sample_rate);


return 0; return 0;
@@ -356,7 +356,7 @@ static int r3d_seek(AVFormatContext *s, int stream_index, int64_t sample_time, i


frame_num = sample_time*st->codec->time_base.den/ frame_num = sample_time*st->codec->time_base.den/
((int64_t)st->codec->time_base.num*st->time_base.den); ((int64_t)st->codec->time_base.num*st->time_base.den);
dprintf(s, "seek frame num %d timestamp %lld\n", frame_num, sample_time);
av_dlog(s, "seek frame num %d timestamp %lld\n", frame_num, sample_time);


if (frame_num < r3d->video_offsets_count) { if (frame_num < r3d->video_offsets_count) {
url_fseek(s->pb, r3d->video_offsets_count, SEEK_SET); url_fseek(s->pb, r3d->video_offsets_count, SEEK_SET);


+ 2
- 2
libavformat/rtpdec.c View File

@@ -324,9 +324,9 @@ int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
len = url_close_dyn_buf(pb, &buf); len = url_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) { if ((len > 0) && buf) {
int result; int result;
dprintf(s->ic, "sending %d bytes of RR\n", len);
av_dlog(s->ic, "sending %d bytes of RR\n", len);
result= url_write(s->rtp_ctx, buf, len); result= url_write(s->rtp_ctx, buf, len);
dprintf(s->ic, "result from url_write: %d\n", result);
av_dlog(s->ic, "result from url_write: %d\n", result);
av_free(buf); av_free(buf);
} }
return 0; return 0;


+ 3
- 3
libavformat/rtpenc.c View File

@@ -192,7 +192,7 @@ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
RTPMuxContext *s = s1->priv_data; RTPMuxContext *s = s1->priv_data;
uint32_t rtp_ts; uint32_t rtp_ts;


dprintf(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
av_dlog(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);


s->last_rtcp_ntp_time = ntp_time; s->last_rtcp_ntp_time = ntp_time;
rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
@@ -215,7 +215,7 @@ void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
{ {
RTPMuxContext *s = s1->priv_data; RTPMuxContext *s = s1->priv_data;


dprintf(s1, "rtp_send_data size=%d\n", len);
av_dlog(s1, "rtp_send_data size=%d\n", len);


/* build the RTP header */ /* build the RTP header */
put_byte(s1->pb, (RTP_VERSION << 6)); put_byte(s1->pb, (RTP_VERSION << 6));
@@ -364,7 +364,7 @@ static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
int rtcp_bytes; int rtcp_bytes;
int size= pkt->size; int size= pkt->size;


dprintf(s1, "%d: write len=%d\n", pkt->stream_index, size);
av_dlog(s1, "%d: write len=%d\n", pkt->stream_index, size);


rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
RTCP_TX_RATIO_DEN; RTCP_TX_RATIO_DEN;


+ 5
- 5
libavformat/rtsp.c View File

@@ -247,7 +247,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
struct sockaddr_storage sdp_ip; struct sockaddr_storage sdp_ip;
int ttl; int ttl;


dprintf(s, "sdp: %c='%s'\n", letter, buf);
av_dlog(s, "sdp: %c='%s'\n", letter, buf);


p = buf; p = buf;
if (s1->skip_media && letter != 'm') if (s1->skip_media && letter != 'm')
@@ -826,7 +826,7 @@ void ff_rtsp_skip_packet(AVFormatContext *s)
return; return;
len = AV_RB16(buf + 1); len = AV_RB16(buf + 1);


dprintf(s, "skipping RTP packet len=%d\n", len);
av_dlog(s, "skipping RTP packet len=%d\n", len);


/* skip payload */ /* skip payload */
while (len > 0) { while (len > 0) {
@@ -860,7 +860,7 @@ int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
for (;;) { for (;;) {
ret = url_read_complete(rt->rtsp_hd, &ch, 1); ret = url_read_complete(rt->rtsp_hd, &ch, 1);
#ifdef DEBUG_RTP_TCP #ifdef DEBUG_RTP_TCP
dprintf(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
av_dlog(s, "ret=%d c=%02x [%c]\n", ret, ch, ch);
#endif #endif
if (ret != 1) if (ret != 1)
return AVERROR_EOF; return AVERROR_EOF;
@@ -879,7 +879,7 @@ int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
} }
*q = '\0'; *q = '\0';


dprintf(s, "line='%s'\n", buf);
av_dlog(s, "line='%s'\n", buf);


/* test if last line */ /* test if last line */
if (buf[0] == '\0') if (buf[0] == '\0')
@@ -984,7 +984,7 @@ static int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
out_buf = base64buf; out_buf = base64buf;
} }


dprintf(s, "Sending:\n%s--\n", buf);
av_dlog(s, "Sending:\n%s--\n", buf);


url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf)); url_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
if (send_content_length > 0 && send_content) { if (send_content_length > 0 && send_content) {


+ 2
- 2
libavformat/rtspdec.c View File

@@ -184,7 +184,7 @@ int ff_rtsp_tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
RTSPStream *rtsp_st; RTSPStream *rtsp_st;


#ifdef DEBUG_RTP_TCP #ifdef DEBUG_RTP_TCP
dprintf(s, "tcp_read_packet:\n");
av_dlog(s, "tcp_read_packet:\n");
#endif #endif
redo: redo:
for (;;) { for (;;) {
@@ -205,7 +205,7 @@ redo:
id = buf[0]; id = buf[0];
len = AV_RB16(buf + 1); len = AV_RB16(buf + 1);
#ifdef DEBUG_RTP_TCP #ifdef DEBUG_RTP_TCP
dprintf(s, "id=%d len=%d\n", id, len);
av_dlog(s, "id=%d len=%d\n", id, len);
#endif #endif
if (len > buf_size || len < 12) if (len > buf_size || len < 12)
goto redo; goto redo;


+ 0
- 7
libavutil/internal.h View File

@@ -114,13 +114,6 @@


/* debug stuff */ /* debug stuff */


/* dprintf macros */
#ifdef DEBUG
# define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
#else
# define dprintf(pctx, ...)
#endif

#define av_abort() do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0) #define av_abort() do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)


/* math */ /* math */


+ 11
- 0
libavutil/log.h View File

@@ -135,6 +135,17 @@ void av_log_set_callback(void (*)(void*, int, const char*, va_list));
void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl); void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl);
const char* av_default_item_name(void* ctx); const char* av_default_item_name(void* ctx);


/**
* av_dlog macros
* Useful to print debug messages that shouldn't get compiled in normally.
*/

#ifdef DEBUG
# define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
#else
# define av_dlog(pctx, ...)
#endif

/** /**
* Skip repeated messages, this requires the user app to use av_log() instead of * Skip repeated messages, this requires the user app to use av_log() instead of
* (f)printf as the 2 would otherwise interfere and lead to * (f)printf as the 2 would otherwise interfere and lead to


Write Preview
Loading…
Cancel
Save