image.cpp

h264编解码.用C++实现了图像的编解码功能。

				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i-1)]*COEF[1]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i)]*COEF[2]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+1)]*COEF[3]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+2)]*COEF[4]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+3)]*COEF[5];
		  }
      }

      for (j = 0; j < 4; j++) {
        for (i = 0; i < 4; i++) {
			result = 0,
            result += tmp_res[i][j]*COEF[0]
				+tmp_res[i][j+1]*COEF[1]
				+tmp_res[i][j+2]*COEF[2]
				+tmp_res[i][j+3]*COEF[3]
				+tmp_res[i][j+4]*COEF[4]
				+tmp_res[i][j+5]*COEF[5];
          block[i][j] = Clip1((result+512)>>10);
        } 
      }
	  return;
  case 7:
	  for (j = -2; j < 4+3; j++) {
		  pres_idx = Clip3(0,maxold_y,y_pos+j);
		  for (i = 0; i < 4; i++){
			  tmp_res[i][j+2] = 0;
			  tmp_res[i][j+2] += list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i-2)]*COEF[0]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i-1)]*COEF[1]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i)]*COEF[2]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+1)]*COEF[3]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+2)]*COEF[4]
				  +list[ref_frame]->imgY[pres_idx][Clip3(0,maxold_x,x_pos+i+3)]*COEF[5];
		  }
      }

      for (j = 0; j < 4; j++) {
        for (i = 0; i < 4; i++) {
			result = 0,
            result += tmp_res[i][j]*COEF[0]
				+tmp_res[i][j+1]*COEF[1]
				+tmp_res[i][j+2]*COEF[2]
				+tmp_res[i][j+3]*COEF[3]
				+tmp_res[i][j+4]*COEF[4]
				+tmp_res[i][j+5]*COEF[5];
          block[i][j] = (Clip1((result+512)>>10) + Clip1((tmp_res[i][j+2+dy/2]+16)>>5) +1 )/2;
        } 
      }
 	  return;
  case 8:
	  for (i = -2; i < 4+3; i++) {
		  pres_idx = Clip3(0,maxold_x,x_pos+i);
		  for (j = 0; j < 4; j++){
			  tmp_res[j][i+2] = 0;
			  tmp_res[j][i+2] += list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j-2)][pres_idx]*COEF[0]
					+ list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j-1)][pres_idx]*COEF[1]
					+ list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j)][pres_idx]*COEF[2]
					+ list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+1)][pres_idx]*COEF[3]
					+ list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+2)][pres_idx]*COEF[4]
					+ list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+3)][pres_idx]*COEF[5];
		  }
      }

      for (j = 0; j < 4; j++) {
        for (i = 0; i < 4; i++) {
			result = 0;
            result += tmp_res[j][i]*COEF[0]
				+tmp_res[j][i+1]*COEF[1]
				+tmp_res[j][i+2]*COEF[2]
				+tmp_res[j][i+3]*COEF[3]
				+tmp_res[j][i+4]*COEF[4]
				+tmp_res[j][i+5]*COEF[5];
			block[i][j] = (Clip1((result+512)>>10) + Clip1((tmp_res[j][2+i+dx/2]+16)>>5)+1)/2;
        }
      }
	  return;
  default:
	  for (j = 0; j < 4; j++) {
        for (i = 0; i < 4; i++) {
          pres_y = dy == 1 ? y_pos+j : y_pos+j+1;
          pres_y = Clip3(0,maxold_y,pres_y);
		  result = 0;
		  result += list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i-2)]*COEF[0]
			  +list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i-1)]*COEF[1]
			  +list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i)]*COEF[2]
			  +list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i+1)]*COEF[3]
			  +list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i+2)]*COEF[4]
			  +list[ref_frame]->imgY[pres_y][Clip3(0,maxold_x,x_pos+i+3)]*COEF[5];
          block[i][j] = Clip1((result+16)>>5);

          pres_x = dx == 1 ? x_pos+i : x_pos+i+1;
          pres_x = Clip3(0,maxold_x,pres_x);
		  result = 0;
          result += list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j-2)][pres_x]*COEF[0]
			  +list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j-1)][pres_x]*COEF[1]
			  +list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j)][pres_x]*COEF[2]
			  +list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+1)][pres_x]*COEF[3]
			  +list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+2)][pres_x]*COEF[4]
			  +list[ref_frame]->imgY[Clip3(0,maxold_y,y_pos+j+3)][pres_x]*COEF[5];
          block[i][j] = (block[i][j] + Clip1((result+16)>>5) +1 ) / 2;
        }
      }
	return;
  }
}


static void reorder_lists(int currSliceType, Slice * currSlice)
{

  if (currSliceType != I_SLICE)
  {
    if (currSlice->ref_pic_list_reordering_flag_l0)
    {
      reorder_ref_pic_list(listX[0], &listXsize[0], 
                           img->num_ref_idx_l0_active - 1, 
                           currSlice->remapping_of_pic_nums_idc_l0, 
                           currSlice->abs_diff_pic_num_minus1_l0, 
                           currSlice->long_term_pic_idx_l0);
    }
    if (NULL == listX[0][img->num_ref_idx_l0_active-1])
    {
      error("number of entries in list 0 smaller than num_ref_idx_l0_active_minus1",500);
    }
    // that's a definition
    listXsize[0] = img->num_ref_idx_l0_active;
  }

  free_ref_pic_list_reordering_buffer(currSlice);
}

//add by niepeng 2007年10月25日
//从缓冲区读slice
int read_new_slice(char* buf,int size,int &current_position)
{
  NALU_t *nalu = AllocNALU(MAX_CODED_FRAME_SIZE);
  int current_header;
  int ret;
  int BitsUsedByHeader;
  Slice *currSlice = img->currentSlice;
  Bitstream *currStream;
  int newframe;

  int slice_id_a, slice_id_b, slice_id_c;
  int redundant_pic_cnt_b, redundant_pic_cnt_c;
  long ftell_position;

  //int current_size=size;
  while (1)
  {
    ftell_position = current_position;//ftell(bits);
//	buf=buf+current_position;
	
    if (FileFormat == PAR_OF_ANNEXB)
     // ret=GetAnnexbNALU (nalu);
	 ret=GetAnnexbNALU(nalu,buf,size,current_position);
    else
      ret=GetRTPNALU (nalu);

	//NALUtoRBSP(nalu);
   assert (nalu != NULL);
   //EBSPtoRBSP (nalu->buf, nalu->len) ; 
    
    if (ret < 0)
		exit (-1);
    else if (ret == 0)
    {
        return EOS;
    }

    switch (nalu->nal_unit_type)
    {
      case NALU_TYPE_SLICE:
      case NALU_TYPE_IDR:
        img->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
        img->nal_reference_idc = nalu->nal_reference_idc;
        img->disposable_flag = (nalu->nal_reference_idc == NALU_PRIORITY_DISPOSABLE);
        currSlice->dp_mode = PAR_DP_1;
        currSlice->max_part_nr = 1;
        currSlice->ei_flag = 0;
        currStream = currSlice->partArr[0].bitstream;
        currStream->ei_flag = 0;
        currStream->frame_bitoffset = 0;
        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

        // Some syntax of the Slice Header depends on the parameter set, which depends on
        // the parameter set ID of the SLice header.  Hence, read the pic_parameter_set_id
        // of the slice header first, then setup the active parameter sets, and then read
        // the rest of the slice header
        BitsUsedByHeader = FirstPartOfSliceHeader();
        UseParameterSet (currSlice->pic_parameter_set_id);
        BitsUsedByHeader+= RestOfSliceHeader ();

        FmoInit (active_pps, active_sps);

        init_lists(img->type);
        reorder_lists (img->type, img->currentSlice);

        // From here on, active_sps, active_pps and the slice header are valid
        img->current_mb_nr = currSlice->start_mb_nr;

        if (img->tr_old != img->ThisPOC)
        {
          newframe=1;
          img->tr_old = img->ThisPOC;
		  current_header = SOP;
        }
        else
		{
          newframe = 0;
		  current_header = SOS;
		}
		g_new_frame=0;

       FreeNALU(nalu);
        return current_header;
        break;
      case NALU_TYPE_DPA:
        //! The state machine here should follow the same ideas as the old readSliceRTP()
        //! basically:
        //! work on DPA (as above)
        //! read and process all following SEI/SPS/PPS/PD/Filler NALUs
        //! if next video NALU is dpB, 
        //!   then read and check whether it belongs to DPA, if yes, use it
        //! else
        //!   ;   // nothing
        //! read and process all following SEI/SPS/PPS/PD/Filler NALUs
        //! if next video NALU is dpC
        //!   then read and check whether it belongs to DPA (and DPB, if present), if yes, use it, done
        //! else
        //!   use the DPA (and the DPB if present)

        /* 
            LC: inserting the code related to DP processing, mainly copying some of the parts
            related to NALU_TYPE_SLICE, NALU_TYPE_IDR.
        */


        img->idr_flag          = (nalu->nal_unit_type == NALU_TYPE_IDR);
        img->nal_reference_idc = nalu->nal_reference_idc;
        img->disposable_flag   = (nalu->nal_reference_idc == NALU_PRIORITY_DISPOSABLE);
        currSlice->dp_mode     = PAR_DP_3;
        currSlice->max_part_nr = 3;
        currSlice->ei_flag     = 0;
        currStream             = currSlice->partArr[0].bitstream;
        currStream->ei_flag    = 0;
        currStream->frame_bitoffset = 0;
        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
        
        BitsUsedByHeader     = FirstPartOfSliceHeader();
        UseParameterSet (currSlice->pic_parameter_set_id);
        BitsUsedByHeader    += RestOfSliceHeader ();
        
        FmoInit (active_pps, active_sps);
        
        init_lists(img->type);
        reorder_lists (img->type, img->currentSlice);

        // From here on, active_sps, active_pps and the slice header are valid
        img->current_mb_nr = currSlice->start_mb_nr;

        if (img->tr_old != img->ThisPOC)
        {
          newframe=1;
          img->tr_old = img->ThisPOC;
		  current_header = SOP;
        }
        else
		{
          newframe = 0;
		  current_header = SOS;
		}
		g_new_frame=0;

        /* 
           LC:
              Now I need to read the slice ID, which depends on the value of 
              redundant_pic_cnt_present_flag (pag.49). 
        */

        slice_id_a  = ue_v("NALU:SLICE_A slice_idr", currStream);
        break;
      case NALU_TYPE_DPB:
        /* LC: inserting the code related to DP processing */

        currStream             = currSlice->partArr[1].bitstream;
        currStream->ei_flag    = 0;
        currStream->frame_bitoffset = 0;
        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);

        slice_id_b  = ue_v("NALU:SLICE_B slice_idr", currStream);
        if (active_pps->redundant_pic_cnt_present_flag)
          redundant_pic_cnt_b = ue_v("NALU:SLICE_B redudand_pic_cnt", currStream);
        else
          redundant_pic_cnt_b = 0;
        
        /* LC: resilience code to be inserted */
        /*         FreeNALU(nalu); */
        /*         return current_header; */

        break;
      case NALU_TYPE_DPC:
        /* LC: inserting the code related to DP processing */
        currStream             = currSlice->partArr[2].bitstream;
        currStream->ei_flag    = 0;
        currStream->frame_bitoffset = 0;
        memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
        currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
        
        slice_id_c  = ue_v("NALU:SLICE_C slice_idr", currStream);
        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;
        /* LC: resilience code to be inserted */

        FreeNALU(nalu);
        return current_header;

        break;
      case NALU_TYPE_SEI:
//        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_PD: