image.c

此code含H.264解码需要的 lib和 src

//          if (active_pps->redundant_pic_cnt_present_flag)
//            redundant_pic_cnt_b = ue_v("NALU: DP_B redudant_pic_cnt", currStream);
//          else
//            redundant_pic_cnt_b = 0;
//
//          // we're finished with DP_B, so let's continue with next DP
//          ftell_position = ftell(bits);
//          if (input->FileFormat == PAR_OF_ANNEXB)
//            ret=GetAnnexbNALU (nalu);
//          else
//            ret=GetRTPNALU (nalu);
//
//          CheckZeroByteNonVCL(nalu, &ret);
//          NALUtoRBSP(nalu);
//
//          if (ret < 0)
//            printf ("Error while getting the NALU in file format %s, exit\n", input->FileFormat==PAR_OF_ANNEXB?"Annex B":"RTP");
//          if (ret == 0)
//          {
//            FreeNALU(nalu);
//            return current_header;
//          }
//        }
//
//        // check if we got DP_C
//        if ( NALU_TYPE_DPC == nalu->nal_unit_type)
//        {
//          currStream             = currSlice->partArr[2].bitstream;
//          currStream->ei_flag    = 0;
//          currStream->frame_bitoffset = currStream->read_len = 0;
//
//          memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
//          currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
//
//          slice_id_c  = ue_v("NALU: DP_C slice_id", currStream);
//          if (slice_id_c != slice_id_a)
//          {
//            printf ("got a data partition C which does not match DP_A\n");
//            // KS: needs error handling !!!
//          }
//
//          if (active_pps->redundant_pic_cnt_present_flag)
//            redundant_pic_cnt_c = ue_v("NALU:SLICE_C redudand_pic_cnt", currStream);
//          else
//            redundant_pic_cnt_c = 0;
//        }
//
//        // check if we read anything else than the expected partitions
//        if ((nalu->nal_unit_type != NALU_TYPE_DPB) && (nalu->nal_unit_type != NALU_TYPE_DPC))
//        {
//          // reset bitstream position and read again in next call
//          fseek(bits, ftell_position, SEEK_SET);
//        }
//
//        FreeNALU(nalu);
//        return current_header;
//
//        break;
//      case NALU_TYPE_DPB:
//        printf ("found data partition B without matching DP A, discarding\n");
//        break;
//      case NALU_TYPE_DPC:
//        printf ("found data partition C without matching DP A, discarding\n");
//        break;
//      case NALU_TYPE_SEI:
//		fprintf(img->fpinfo, "SEI:\n");
//		
//        printf ("read_new_slice: Found NALU_TYPE_SEI, len %d\n", nalu->len);
//        InterpretSEIMessage(nalu->buf,nalu->len,img);
//        break;
//      case NALU_TYPE_PPS:
//        ProcessPPS(nalu);
//        break;
//      case NALU_TYPE_SPS:
//        ProcessSPS(nalu);
//        break;
//      case NALU_TYPE_AUD:
////        printf ("read_new_slice: Found 'Access Unit Delimiter' NAL unit, len %d, ignored\n", nalu->len);
//        break;
//      case NALU_TYPE_EOSEQ:
////        printf ("read_new_slice: Found 'End of Sequence' NAL unit, len %d, ignored\n", nalu->len);
//        break;
//      case NALU_TYPE_EOSTREAM:
////        printf ("read_new_slice: Found 'End of Stream' NAL unit, len %d, ignored\n", nalu->len);
//        break;
//      case NALU_TYPE_FILL:
//        printf ("read_new_slice: Found NALU_TYPE_FILL, len %d\n", nalu->len);
//        printf ("Skipping these filling bits, proceeding w/ next NALU\n");
//        break;
//      default:
//        printf ("Found NALU type %d, len %d undefined, ignore NALU, moving on\n", nalu->nal_unit_type, nalu->len);
//    }
//  }
//  FreeNALU(nalu);
//
//  return  current_header;
//}
//

extern FILE *fpic_mem;

/*!
 ************************************************************************
 * \brief
 *    Initializes the parameters for a new picture
 ************************************************************************
 */
void init_picture(struct img_par *img, struct inp_par *inp)
{
//  int i,k,l;
  Slice *currSlice = img->currentSlice;
  unsigned int i;

  if (dec_picture)
  {
    // this may only happen on slice loss
    exit_picture();
  }
  if (img->recovery_point)
    img->recovery_frame_num = (img->frame_num + img->recovery_frame_cnt) % img->MaxFrameNum;

  if (img->idr_flag)
    img->recovery_frame_num = img->frame_num;

  if (img->recovery_point == 0 &&
      img->frame_num != img->pre_frame_num &&
      img->frame_num != (img->pre_frame_num + 1) % img->MaxFrameNum)
  {
    if (active_sps->gaps_in_frame_num_value_allowed_flag == 0)
    {
      // picture error concealment
//      if(inp->conceal_mode !=0)
//      {
//        if((img->frame_num) < ((img->pre_frame_num + 1) % img->MaxFrameNum))
//        {
//          /* Conceal lost IDR frames and any frames immediately
//             following the IDR. Use frame copy for these since
//             lists cannot be formed correctly for motion copy*/
//          img->conceal_mode = 1;
//          img->IDR_concealment_flag = 1;
//          conceal_lost_frames(img);
//          //reset to original concealment mode for future drops
//          img->conceal_mode = inp->conceal_mode;
//        }
//        else
//        {
//          //reset to original concealment mode for future drops
//          img->conceal_mode = inp->conceal_mode;
//
//          img->IDR_concealment_flag = 0;
//          conceal_lost_frames(img);
//        }
//      }
//      else

      {   /* Advanced Error Concealment would be called here to combat unintentional loss of pictures. */
        error("An unintentional loss of pictures occurs! Exit\n", 100);
      }
    }
//    if(img->conceal_mode == 0)
      fill_frame_num_gap(img);
  }

  if(img->nal_reference_idc)
  {
    img->pre_frame_num = img->frame_num;
  }

  //img->num_dec_mb = 0;

  //calculate POC
  decode_poc(img);

  if (img->recovery_frame_num == img->frame_num &&
      img->recovery_poc == 0x7fffffff)
    img->recovery_poc = img->framepoc;

  if(img->nal_reference_idc)
    img->last_ref_pic_poc = img->framepoc;

  //  dumppoc (img);

//  if (img->structure==FRAME ||img->structure==TOP_FIELD)
//  {
//#ifdef WIN32
//    _ftime (&(img->tstruct_start));             // start time ms
//#else
//    ftime (&(img->tstruct_start));              // start time ms
//#endif
//    time( &(img->ltime_start));                // start time s
//  }

  //fprintf(fpic_mem, "#\n");
  //fprintf(fpic_mem, "used memory:\n");
  for(i=0; i<2*(dpb.size+1); i++)
  {
	  //fprintf(fpic_mem, "mem[%d] = %d, poc = %d\n", i, dpb.memory_used[i], dpb.memory_used_poc[i]);
  }
  //fprintf(fpic_mem, "\n");

  dec_picture = alloc_storable_picture ((PictureStructure) img->structure, img->width, img->height, img->width_cr, img->height_cr);
  dec_picture->pic_mem_idx = take_idle_mem(dec_picture->structure);

  //fprintf(fpic_mem, "\n");
  
  dec_picture->top_poc=img->toppoc;
  dec_picture->bottom_poc=img->bottompoc;
  dec_picture->frame_poc=img->framepoc;
  dec_picture->qp=img->qp;
  dec_picture->slice_qp_delta=currSlice->slice_qp_delta;
  dec_picture->chroma_qp_offset[0] = active_pps->chroma_qp_index_offset;
  dec_picture->chroma_qp_offset[1] = active_pps->second_chroma_qp_index_offset;

  // reset all variables of the error concealment instance before decoding of every frame.
  // here the third parameter should, if perfectly, be equal to the number of slices per frame.
  // using little value is ok, the code will allocate more memory if the slice number is larger
//  ercReset(erc_errorVar, img->PicSizeInMbs, img->PicSizeInMbs, dec_picture->size_x);
//  erc_mvperMB = 0;

  switch (img->structure )
  {
  case TOP_FIELD:
    {
      dec_picture->poc=img->toppoc;
//      img->number *= 2;
      break;
    }
  case BOTTOM_FIELD:
    {
      dec_picture->poc=img->bottompoc;
//      img->number = img->number * 2 + 1;
      break;
    }
  case FRAME:
    {
      dec_picture->poc=img->framepoc;
      break;
    }
  default:
    error("img->structure not initialized", 235);
  }

//  img->current_slice_nr=0;

//  if (img->type > SI_SLICE)
//  {
//    set_ec_flag(SE_PTYPE);
//    img->type = P_SLICE;  // concealed element
//  }


  // CAVLC init
//  for (i=0;i < (int)img->PicSizeInMbs; i++)
//    for (k=0;k<4;k++)
//      for (l=0;l<(4 + img->num_blk8x8_uv);l++)
//        img->nz_coeff[i][k][l]=-1;  // CAVLC

//  if(active_pps->constrained_intra_pred_flag)
//  {
//    for (i=0; i<(int)img->PicSizeInMbs; i++)
//    {
//      img->intra_block[i] = 1;
//    }
//  }


  // Set the slice_nr member of each MB to -1, to ensure correct when packet loss occurs
  // TO set Macroblock Map (mark all MBs as 'have to be concealed')
//  for(i=0; i<(int)img->PicSizeInMbs; i++)
//  {
//    img->mb_data[i].slice_nr = -1;
//    img->mb_data[i].ei_flag = 1;
//  }

  img->mb_y = img->mb_x = 0;
  img->block_y_aff = img->block_y = img->pix_y = img->pix_c_y = 0; // define vertical positions
  img->block_x = img->pix_x = img->pix_c_x = 0; // define horizontal positions

  dec_picture->slice_type = img->type;
  dec_picture->used_for_reference = (img->nal_reference_idc != 0);
  dec_picture->idr_flag = img->idr_flag;
  dec_picture->no_output_of_prior_pics_flag = img->no_output_of_prior_pics_flag;
  dec_picture->long_term_reference_flag = img->long_term_reference_flag;
  dec_picture->adaptive_ref_pic_buffering_flag = img->adaptive_ref_pic_buffering_flag;

  dec_picture->dec_ref_pic_marking_buffer = img->dec_ref_pic_marking_buffer;
  img->dec_ref_pic_marking_buffer = NULL;

  dec_picture->MbaffFrameFlag = img->MbaffFrameFlag;
  dec_picture->PicWidthInMbs = img->PicWidthInMbs;

//  get_mb_block_pos = dec_picture->MbaffFrameFlag ? get_mb_block_pos_mbaff : get_mb_block_pos_normal;
//  getNeighbour = dec_picture->MbaffFrameFlag ? getAffNeighbour : getNonAffNeighbour;



  dec_picture->pic_num = img->frame_num;
  dec_picture->frame_num = img->frame_num;

  dec_picture->recovery_frame = (img->frame_num == img->recovery_frame_num);

  dec_picture->coded_frame = (img->structure==FRAME);

  dec_picture->chroma_format_idc = active_sps->chroma_format_idc;

  dec_picture->frame_mbs_only_flag = active_sps->frame_mbs_only_flag;
  dec_picture->frame_cropping_flag = active_sps->frame_cropping_flag;

  if (dec_picture->frame_cropping_flag)
  {
    dec_picture->frame_cropping_rect_left_offset   = active_sps->frame_cropping_rect_left_offset;
    dec_picture->frame_cropping_rect_right_offset  = active_sps->frame_cropping_rect_right_offset;
    dec_picture->frame_cropping_rect_top_offset    = active_sps->frame_cropping_rect_top_offset;
    dec_picture->frame_cropping_rect_bottom_offset = active_sps->frame_cropping_rect_bottom_offset;
  }

#ifdef ENABLE_OUTPUT_TONEMAPPING
  // store the necessary tone mapping sei into StorablePicture structure
  dec_picture->seiHasTone_mapping = 0;
  if (seiToneMapping.seiHasTone_mapping)
  {
    dec_picture->seiHasTone_mapping    = 1;
    dec_picture->tone_mapping_model_id = seiToneMapping.model_id;
    dec_picture->tonemapped_bit_depth  = seiToneMapping.sei_bit_depth;
    dec_picture->tone_mapping_lut      = malloc(sizeof(int)*(1<<seiToneMapping.coded_data_bit_depth));
    if (NULL == dec_picture->tone_mapping_lut)
    {
      no_mem_exit("init_picture: tone_mapping_lut");
    }
    memcpy(dec_picture->tone_mapping_lut, seiToneMapping.lut, sizeof(imgpel)*(1<<seiToneMapping.coded_data_bit_depth));
    update_tone_mapping_sei();
  }
#endif
}

/*!
 ************************************************************************
 * \brief
 *    finish decoding of a picture, conceal errors and store it
 *    into the DPB
 ************************************************************************
 */
void exit_picture()
{
  char yuv_types[4][6]= {"4:0:0","4:2:0","4:2:2","4:4:4"};
//  int ercStartMB;
//  int ercSegment;
//  frame recfr;
//  unsigned int i;
  int structure, frame_poc, slice_type, refpic, qp, pic_num, chroma_format_idc;

//  time_t tmp_time;                   // time used by decoding the last frame
//  char   yuvFormat[10];

  // return if the last picture has already been finished
  if (dec_picture==NULL)
  {
    return;
  }

  //deblocking for frame or field
//  DeblockPicture( img, dec_picture );

//  if (dec_picture->MbaffFrameFlag)
//    MbAffPostProc();

//  recfr.yptr = &dec_picture->imgY[0][0];
//  if (dec_picture->chroma_format_idc != YUV400)
//  {
//    recfr.uptr = &dec_picture->imgUV[0][0][0];
//    recfr.vptr = &dec_picture->imgUV[1][0][0];
//  }

  //! this is always true at the beginning of a picture
//  ercStartMB = 0;
//  ercSegment = 0;

  //! mark the start of the first segment
//  if (!dec_picture->MbaffFrameFlag)
//  {
//    ercStartSegment(0, ercSegment, 0 , erc_errorVar);
//