libavcodec.hg: h264.c comparison

comparison h264.c @ 1598:932d306bf1dc libavcodec

av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)

author	michael
date	Mon, 03 Nov 2003 13:26:22 +0000
parents	dd544554ed42
children	d9d98cdcfcde

comparison

equal deleted inserted replaced

-:4c9165372ab3
+:932d306bf1dc
 if(!(h->top_samples_available&0x8000)){
 for(i=0; i<4; i++){
 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
 if(status<0){
-fprintf(stderr, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
 return -1;
 } else if(status){
 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
 }
 }
 if(!(h->left_samples_available&0x8000)){
 for(i=0; i<4; i++){
 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
 if(status<0){
-fprintf(stderr, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
 return -1;
 } else if(status){
 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
 }
 }
 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
 if(!(h->top_samples_available&0x8000)){
 mode= top[ mode ];
 if(mode<0){
-fprintf(stderr, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
 return -1;
 }
 }
 if(!(h->left_samples_available&0x8000)){
 mode= left[ mode ];
 if(mode<0){
-fprintf(stderr, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
 return -1;
 }
 }
 return mode;
 int pic_id;
 int i;
 if(index >= h->ref_count[list]){
-fprintf(stderr, "reference count overflow\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
 return -1;
 }
 if(reordering_of_pic_nums_idc<3){
 if(reordering_of_pic_nums_idc<2){
 const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
 if(abs_diff_pic_num >= h->max_pic_num){
-fprintf(stderr, "abs_diff_pic_num overflow\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
 return -1;
 }
 if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
 else                                pred+= abs_diff_pic_num;
 break;
 }
 }
 if(i < index){
-fprintf(stderr, "reference picture missing during reorder\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
 memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
 }else if(i > index){
 Picture tmp= h->ref_list[list][i];
 for(; i>index; i--){
 h->ref_list[list][i]= h->ref_list[list][i-1];
 h->ref_list[list][index]= tmp;
 }
 }else if(reordering_of_pic_nums_idc==3)
 break;
 else{
-fprintf(stderr, "illegal reordering_of_pic_nums_idc\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
 return -1;
 }
 }
 }
 static Picture * remove_short(H264Context *h, int frame_num){
 MpegEncContext * const s = &h->s;
 int i;
 if(s->avctx->debug&FF_DEBUG_MMCO)
-printf("remove short %d count %d\n", frame_num, h->short_ref_count);
+av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
 for(i=0; i<h->short_ref_count; i++){
 Picture *pic= h->short_ref[i];
 if(s->avctx->debug&FF_DEBUG_MMCO)
-printf("%d %d %p\n", i, pic->frame_num, pic);
+av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
 if(pic->frame_num == frame_num){
 h->short_ref[i]= NULL;
 memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
 h->short_ref_count--;
 return pic;
 int i;
 int current_is_long=0;
 Picture *pic;
 if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
-printf("no mmco here\n");
+av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
 for(i=0; i<mmco_count; i++){
 if(s->avctx->debug&FF_DEBUG_MMCO)
-printf("mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);
+av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);
 switch(mmco[i].opcode){
 case MMCO_SHORT2UNUSED:
 pic= remove_short(h, mmco[i].short_frame_num);
 if(pic==NULL) return -1;
 if(!current_is_long){
 pic= remove_short(h, s->current_picture_ptr->frame_num);
 if(pic){
 pic->reference=0;
-fprintf(stderr, "illegal short term buffer state detected\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
 }
 if(h->short_ref_count)
 memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
 }*/
 }
 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
 h->mmco[i].long_index= get_ue_golomb(&s->gb);
 if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){
-fprintf(stderr, "illegal long ref in memory management control operation %d\n", opcode);
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
 return -1;
 }
 }
 if(opcode > MMCO_LONG){
-fprintf(stderr, "illegal memory management control operation %d\n", opcode);
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
 return -1;
 }
 }
 h->mmco_index= i;
 }else{
 first_mb_in_slice= get_ue_golomb(&s->gb);
 h->slice_type= get_ue_golomb(&s->gb);
 if(h->slice_type > 9){
-fprintf(stderr, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
 }
 if(h->slice_type > 4){
 h->slice_type -= 5;
 h->slice_type_fixed=1;
 }else
 s->pict_type= h->slice_type; // to make a few old func happy, its wrong though
 pps_id= get_ue_golomb(&s->gb);
 if(pps_id>255){
-fprintf(stderr, "pps_id out of range\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
 return -1;
 }
 h->pps= h->pps_buffer[pps_id];
 if(h->pps.slice_group_count == 0){
-fprintf(stderr, "non existing PPS referenced\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
 return -1;
 }
 h->sps= h->sps_buffer[ h->pps.sps_id ];
 if(h->sps.log2_max_frame_num == 0){
-fprintf(stderr, "non existing SPS referenced\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
 return -1;
 }
 s->mb_width= h->sps.mb_width;
 s->mb_height= h->sps.mb_height;
 h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
 if(h->slice_type==B_TYPE)
 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
 if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
-fprintf(stderr, "reference overflow\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
 return -1;
 }
 }
 }
 if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
 slice_group_change_cycle= get_bits(&s->gb, ?);
 #endif
 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-printf("mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d\n",
+av_log(h->s.avctx, AV_LOG_DEBUG, "mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d\n",
 first_mb_in_slice,
 av_get_pict_type_char(h->slice_type),
 pps_id, h->frame_num,
 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
 h->ref_count[0], h->ref_count[1],
 level_code= prefix + get_bits(gb, 4); //part
 }else if(prefix==15){
 level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
 if(suffix_length==0) level_code+=15; //FIXME doesnt make (much)sense
 }else{
-fprintf(stderr, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
 return -1;
 }
 if(i==trailing_ones && i<3) level_code+= 2; //FIXME split first iteration
 }
 zeros_left -= run[i];
 }
 if(zeros_left<0){
-fprintf(stderr, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
 return -1;
 }
 for(; i<total_coeff-1; i++){
 run[i]= 0;
 }
 }else{
 assert(h->slice_type == I_TYPE);
 decode_intra_mb:
 if(mb_type > 25){
-fprintf(stderr, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
 return -1;
 }
 partition_count=0;
 cbp= i_mb_type_info[mb_type].cbp;
 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
 if(h->slice_type == B_TYPE){
 for(i=0; i<4; i++){
 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
 if(h->sub_mb_type[i] >=13){
-fprintf(stderr, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
 return -1;
 }
 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
 }
 }else{
 assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
 for(i=0; i<4; i++){
 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
 if(h->sub_mb_type[i] >=4){
-fprintf(stderr, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
 return -1;
 }
 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
 }
 write_back_motion(h, mb_type);
 if(!IS_INTRA16x16(mb_type)){
 cbp= get_ue_golomb(&s->gb);
 if(cbp > 47){
-fprintf(stderr, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
 return -1;
 }
 if(IS_INTRA4x4(mb_type))
 cbp= golomb_to_intra4x4_cbp[cbp];
 }
 dquant= get_se_golomb(&s->gb);
 if( dquant > 25 || dquant < -26 ){
-fprintf(stderr, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
 return -1;
 }
 s->qscale += dquant;
 if(((unsigned)s->qscale) > 51){
 hl_decode_mb(h);
 s->mb_y--;
 }
 if(ret<0){
-fprintf(stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
+av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
 return -1;
 }
 sps->sar.num= get_bits(&s->gb, 16);
 sps->sar.den= get_bits(&s->gb, 16);
 }else if(aspect_ratio_idc < 16){
 sps->sar=  pixel_aspect[aspect_ratio_idc];
 }else{
-fprintf(stderr, "illegal aspect ratio\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
 return -1;
 }
 }else{
 sps->sar.num=
 sps->sar.den= 0;
 for(i=0; i<sps->poc_cycle_length; i++)
 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
 }
 if(sps->poc_type > 2){
-fprintf(stderr, "illegal POC type %d\n", sps->poc_type);
+av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
 return -1;
 }
 sps->ref_frame_count= get_ue_golomb(&s->gb);
 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
 sps->crop_left  = get_ue_golomb(&s->gb);
 sps->crop_right = get_ue_golomb(&s->gb);
 sps->crop_top   = get_ue_golomb(&s->gb);
 sps->crop_bottom= get_ue_golomb(&s->gb);
 if(sps->crop_left || sps->crop_top){
-fprintf(stderr, "insane croping not completly supported, this could look slightly wrong ...\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completly supported, this could look slightly wrong ...\n");
 }
 }else{
 sps->crop_left  =
 sps->crop_right =
 sps->crop_top   =
 sps->vui_parameters_present_flag= get_bits1(&s->gb);
 if( sps->vui_parameters_present_flag )
 decode_vui_parameters(h, sps);
 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-printf("sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n",
+av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n",
 sps_id, sps->profile_idc, sps->level_idc,
 sps->poc_type,
 sps->ref_frame_count,
 sps->mb_width, sps->mb_height,
 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 pps->cabac= get_bits1(&s->gb);
 pps->pic_order_present= get_bits1(&s->gb);
 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
 if(pps->slice_group_count > 1 ){
 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
-fprintf(stderr, "FMO not supported\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
 switch(pps->mb_slice_group_map_type){
 case 0:
 #if 0
 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
 |    run_length[ i ]                                |1  |ue(v)   |
 }
 }
 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
 if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){
-fprintf(stderr, "reference overflow (pps)\n");
+av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 return -1;
 }
 pps->weighted_pred= get_bits1(&s->gb);
 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
 pps->constrained_intra_pred= get_bits1(&s->gb);
 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-printf("pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s\n",
+av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s\n",
 pps_id, pps->sps_id,
 pps->cabac ? "CABAC" : "CAVLC",
 pps->slice_group_count,
 pps->ref_count[0], pps->ref_count[1],
 pps->weighted_pred ? "weighted" : "",
 ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, buf_size - buf_index);
 if(ptr[dst_length - 1] == 0) dst_length--;
 bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
 if(s->avctx->debug&FF_DEBUG_STARTCODE){
-printf("NAL %d at %d length %d\n", h->nal_unit_type, buf_index, dst_length);
+av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d length %d\n", h->nal_unit_type, buf_index, dst_length);
 }
 buf_index += consumed;
 if(h->nal_ref_idc < s->hurry_up)
 } else {
 *pict= *(AVFrame*)&s->last_picture;
 }
 #endif
 if(!s->current_picture_ptr){
-fprintf(stderr, "error, NO frame\n");
+av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");
 return -1;
 }
 *pict= *(AVFrame*)&s->current_picture; //FIXME
 ff_print_debug_info(s, s->current_picture_ptr);

Mercurial > libavcodec.hg

comparison h264.c @ 1598:932d306bf1dc libavcodec