virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-03-17 20:17:55 +02:00
Code Issues Releases Activity

Change some dprintf to av_log

Browse Source 
Originally committed as revision 7964 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michel Bardiaux 2007-02-13 16:06:50 +00:00
parent 034ef0e8c3
commit bcdf0d2697
1 changed files with 44 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
libavcodec/mjpeg.c
View File

@ -1043,13 +1043,13 @@ static int mjpeg_decode_dqt(MJpegDecodeContext *s)
/* only 8 bit precision handled */ /* only 8 bit precision handled */
if (get_bits(&s->gb, 4) != 0) if (get_bits(&s->gb, 4) != 0)
{ {
dprintf("dqt: 16bit precision\n"); av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
return -1; return -1;
} }
index = get_bits(&s->gb, 4); index = get_bits(&s->gb, 4);
if (index >= 4) if (index >= 4)
return -1; return -1;
dprintf("index=%d\n", index); av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
/* read quant table */ /* read quant table */
for(i=0;i<64;i++) { for(i=0;i<64;i++) {
j = s->scantable.permutated[i]; j = s->scantable.permutated[i];
@ -1060,7 +1060,7 @@ static int mjpeg_decode_dqt(MJpegDecodeContext *s)
s->qscale[index]= FFMAX( s->qscale[index]= FFMAX(
s->quant_matrixes[index][s->scantable.permutated[1]], s->quant_matrixes[index][s->scantable.permutated[1]],
s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
dprintf("qscale[%d]: %d\n", index, s->qscale[index]); av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
len -= 65; len -= 65;
} }
@ -1105,7 +1105,7 @@ static int mjpeg_decode_dht(MJpegDecodeContext *s)
/* build VLC and flush previous vlc if present */ /* build VLC and flush previous vlc if present */
free_vlc(&s->vlcs[class][index]); free_vlc(&s->vlcs[class][index]);
dprintf("class=%d index=%d nb_codes=%d\n", av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
class, index, code_max + 1); class, index, code_max + 1);
if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){ if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
return -1; return -1;
@ -1133,7 +1133,7 @@ static int mjpeg_decode_sof(MJpegDecodeContext *s)
height = get_bits(&s->gb, 16); height = get_bits(&s->gb, 16);
width = get_bits(&s->gb, 16); width = get_bits(&s->gb, 16);
dprintf("sof0: picture: %dx%d\n", width, height); av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
if(avcodec_check_dimensions(s->avctx, width, height)) if(avcodec_check_dimensions(s->avctx, width, height))
return -1; return -1;
@ -1161,8 +1161,8 @@ static int mjpeg_decode_sof(MJpegDecodeContext *s)
s->quant_index[i] = get_bits(&s->gb, 8); s->quant_index[i] = get_bits(&s->gb, 8);
if (s->quant_index[i] >= 4) if (s->quant_index[i] >= 4)
return -1; return -1;
dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
s->v_count[i], s->component_id[i], s->quant_index[i]); s->v_count[i], s->component_id[i], s->quant_index[i]);
} }
if(s->ls && (s->h_max > 1 || s->v_max > 1)) { if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
@ -1204,7 +1204,7 @@ static int mjpeg_decode_sof(MJpegDecodeContext *s)
pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) | pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
(s->h_count[1] << 12) | (s->v_count[1] << 8) | (s->h_count[1] << 12) | (s->v_count[1] << 8) |
(s->h_count[2] << 4) | s->v_count[2]; (s->h_count[2] << 4) | s->v_count[2];
dprintf("pix fmt id %x\n", pix_fmt_id); av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
switch(pix_fmt_id){ switch(pix_fmt_id){
case 0x222222: case 0x222222:
case 0x111111: case 0x111111:
@ -1252,7 +1252,7 @@ static int mjpeg_decode_sof(MJpegDecodeContext *s)
if (len != (8+(3*nb_components))) if (len != (8+(3*nb_components)))
{ {
dprintf("decode_sof0: error, len(%d) mismatch\n", len); av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
} }
/* totally blank picture as progressive JPEG will only add details to it */ /* totally blank picture as progressive JPEG will only add details to it */
@ -1270,8 +1270,8 @@ static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
if (code < 0) if (code < 0)
{ {
dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
&s->vlcs[0][dc_index]); &s->vlcs[0][dc_index]);
return 0xffff; return 0xffff;
} }
@ -1290,7 +1290,7 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
/* DC coef */ /* DC coef */
val = mjpeg_decode_dc(s, dc_index); val = mjpeg_decode_dc(s, dc_index);
if (val == 0xffff) { if (val == 0xffff) {
dprintf("error dc\n"); av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return -1; return -1;
} }
val = val * quant_matrix[0] + s->last_dc[component]; val = val * quant_matrix[0] + s->last_dc[component];
@ -1326,7 +1326,7 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
block[j] = level * quant_matrix[j]; block[j] = level * quant_matrix[j];
break; break;
} }
dprintf("error count: %d\n", i); av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return -1; return -1;
} }
j = s->scantable.permutated[i]; j = s->scantable.permutated[i];
@ -1349,7 +1349,7 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
if(!ss){ if(!ss){
val = mjpeg_decode_dc(s, dc_index); val = mjpeg_decode_dc(s, dc_index);
if (val == 0xffff) { if (val == 0xffff) {
dprintf("error dc\n"); av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return -1; return -1;
} }
val = (val * quant_matrix[0] << Al) + s->last_dc[component]; val = (val * quant_matrix[0] << Al) + s->last_dc[component];
@ -1389,7 +1389,7 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
block[j] = level * quant_matrix[j] << Al; block[j] = level * quant_matrix[j] << Al;
break; break;
} }
dprintf("error count: %d\n", i); av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
return -1; return -1;
} }
j = s->scantable.permutated[i]; j = s->scantable.permutated[i];
@ -1590,16 +1590,16 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, i
if (!s->progressive && decode_block(s, s->block, i, if (!s->progressive && decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i], s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ]) < 0) { s->quant_matrixes[ s->quant_index[c] ]) < 0) {
dprintf("error y=%d x=%d\n", mb_y, mb_x); av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1; return -1;
} }
if (s->progressive && decode_block_progressive(s, s->block, i, if (s->progressive && decode_block_progressive(s, s->block, i,
s->dc_index[i], s->ac_index[i], s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) { s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
dprintf("error y=%d x=%d\n", mb_y, mb_x); av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1; return -1;
} }
// dprintf("mb: %d %d processed\n", mb_y, mb_x); // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
ptr = s->picture.data[c] + ptr = s->picture.data[c] +
(((s->linesize[c] * (v * mb_y + y) * 8) + (((s->linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8) >> s->avctx->lowres); (h * mb_x + x) * 8) >> s->avctx->lowres);
@ -1641,21 +1641,21 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
nb_components = get_bits(&s->gb, 8); nb_components = get_bits(&s->gb, 8);
if (len != 6+2*nb_components) if (len != 6+2*nb_components)
{ {
dprintf("decode_sos: invalid len (%d)\n", len); av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
return -1; return -1;
} }
vmax = 0; vmax = 0;
hmax = 0; hmax = 0;
for(i=0;i<nb_components;i++) { for(i=0;i<nb_components;i++) {
id = get_bits(&s->gb, 8) - 1; id = get_bits(&s->gb, 8) - 1;
dprintf("component: %d\n", id); av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
/* find component index */ /* find component index */
for(index=0;index<s->nb_components;index++) for(index=0;index<s->nb_components;index++)
if (id == s->component_id[index]) if (id == s->component_id[index])
break; break;
if (index == s->nb_components) if (index == s->nb_components)
{ {
dprintf("decode_sos: index(%d) out of components\n", index); av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
return -1; return -1;
} }
@ -1745,7 +1745,7 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
emms_c(); emms_c();
return 0; return 0;
out_of_range: out_of_range:
dprintf("decode_sos: ac/dc index out of range\n"); av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
return -1; return -1;
} }
@ -1755,7 +1755,7 @@ static int mjpeg_decode_dri(MJpegDecodeContext *s)
return -1; return -1;
s->restart_interval = get_bits(&s->gb, 16); s->restart_interval = get_bits(&s->gb, 16);
s->restart_count = 0; s->restart_count = 0;
dprintf("restart interval: %d\n", s->restart_interval); av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
return 0; return 0;
} }
@ -1989,7 +1989,7 @@ static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
val = -1; val = -1;
found: found:
#ifdef DEBUG #ifdef DEBUG
dprintf("find_marker skipped %d bytes\n", skipped); av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
#endif #endif
*pbuf_ptr = buf_ptr; *pbuf_ptr = buf_ptr;
return val; return val;
@ -2014,14 +2014,14 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
if (start_code < 0) { if (start_code < 0) {
goto the_end; goto the_end;
} else { } else {
dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr); av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
if ((buf_end - buf_ptr) > s->buffer_size) if ((buf_end - buf_ptr) > s->buffer_size)
{ {
av_free(s->buffer); av_free(s->buffer);
s->buffer_size = buf_end-buf_ptr; s->buffer_size = buf_end-buf_ptr;
s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
dprintf("buffer too small, expanding to %d bytes\n", av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
s->buffer_size); s->buffer_size);
} }
@ -2049,8 +2049,8 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
} }
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8); init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
dprintf("escaping removed %d bytes\n", av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
(buf_end - buf_ptr) - (dst - s->buffer)); (buf_end - buf_ptr) - (dst - s->buffer));
} }
else if(start_code == SOS && s->ls){ else if(start_code == SOS && s->ls){
uint8_t *src = buf_ptr; uint8_t *src = buf_ptr;
@ -2096,12 +2096,12 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
s->start_code = start_code; s->start_code = start_code;
if(s->avctx->debug & FF_DEBUG_STARTCODE){ if(s->avctx->debug & FF_DEBUG_STARTCODE){
av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
} }
/* process markers */ /* process markers */
if (start_code >= 0xd0 && start_code <= 0xd7) { if (start_code >= 0xd0 && start_code <= 0xd7) {
dprintf("restart marker: %d\n", start_code&0x0f); av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
/* APP fields */ /* APP fields */
} else if (start_code >= APP0 && start_code <= APP15) { } else if (start_code >= APP0 && start_code <= APP15) {
mjpeg_decode_app(s); mjpeg_decode_app(s);
@ -2122,7 +2122,7 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
break; break;
case DHT: case DHT:
if(mjpeg_decode_dht(s) < 0){ if(mjpeg_decode_dht(s) < 0){
av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n"); av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
return -1; return -1;
} }
break; break;
@ -2176,7 +2176,7 @@ eoi_parser:
picture->qscale_table= s->qscale_table; picture->qscale_table= s->qscale_table;
memset(picture->qscale_table, picture->quality, (s->width+15)/16); memset(picture->qscale_table, picture->quality, (s->width+15)/16);
if(avctx->debug & FF_DEBUG_QP) if(avctx->debug & FF_DEBUG_QP)
av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
picture->quality*= FF_QP2LAMBDA; picture->quality*= FF_QP2LAMBDA;
} }
@ -2204,7 +2204,7 @@ eoi_parser:
case SOF14: case SOF14:
case SOF15: case SOF15:
case JPG: case JPG:
av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
break; break;
// default: // default:
// printf("mjpeg: unsupported marker (%x)\n", start_code); // printf("mjpeg: unsupported marker (%x)\n", start_code);
@ -2214,13 +2214,13 @@ eoi_parser:
not_the_end: not_the_end:
/* eof process start code */ /* eof process start code */
buf_ptr += (get_bits_count(&s->gb)+7)/8; buf_ptr += (get_bits_count(&s->gb)+7)/8;
dprintf("marker parser used %d bytes (%d bits)\n", av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
} }
} }
} }
the_end: the_end:
dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr); av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
// return buf_end - buf_ptr; // return buf_end - buf_ptr;
return buf_ptr - buf; return buf_ptr - buf;
} }
@ -2251,20 +2251,20 @@ read_header:
if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g')) if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
{ {
dprintf("not mjpeg-b (bad fourcc)\n"); av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
return 0; return 0;
} }
field_size = get_bits_long(&hgb, 32); /* field size */ field_size = get_bits_long(&hgb, 32); /* field size */
dprintf("field size: 0x%x\n", field_size); av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
skip_bits(&hgb, 32); /* padded field size */ skip_bits(&hgb, 32); /* padded field size */
second_field_offs = get_bits_long(&hgb, 32); second_field_offs = get_bits_long(&hgb, 32);
dprintf("second field offs: 0x%x\n", second_field_offs); av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
if (second_field_offs) if (second_field_offs)
s->interlaced = 1; s->interlaced = 1;
dqt_offs = get_bits_long(&hgb, 32); dqt_offs = get_bits_long(&hgb, 32);
dprintf("dqt offs: 0x%x\n", dqt_offs); av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
if (dqt_offs) if (dqt_offs)
{ {
init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8); init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
@ -2273,7 +2273,7 @@ read_header:
} }
dht_offs = get_bits_long(&hgb, 32); dht_offs = get_bits_long(&hgb, 32);
dprintf("dht offs: 0x%x\n", dht_offs); av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
if (dht_offs) if (dht_offs)
{ {
init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8); init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
@ -2282,7 +2282,7 @@ read_header:
} }
sof_offs = get_bits_long(&hgb, 32); sof_offs = get_bits_long(&hgb, 32);
dprintf("sof offs: 0x%x\n", sof_offs); av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
if (sof_offs) if (sof_offs)
{ {
init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8); init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
@ -2292,9 +2292,9 @@ read_header:
} }
sos_offs = get_bits_long(&hgb, 32); sos_offs = get_bits_long(&hgb, 32);
dprintf("sos offs: 0x%x\n", sos_offs); av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
sod_offs = get_bits_long(&hgb, 32); sod_offs = get_bits_long(&hgb, 32);
dprintf("sod offs: 0x%x\n", sod_offs); av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
if (sos_offs) if (sos_offs)
{ {
// init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8); // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);