block.cpp

264的播放器

  int ih,iv;
  int ib,ic,iaa;

  byte **imgY=dec_picture->imgY;

  int mb_nr=img->current_mb_nr;

  PixelPos up;          //!< pixel position p(0,-1)
  PixelPos left[17];    //!< pixel positions p(-1, -1..15)

  int up_avail, left_avail, left_up_avail;

  s1=s2=0;

  for (i=0;i<17;i++)
  {
    getLumaNeighbour(mb_nr, -1 ,  i-1 , &left[i]);
  }
  
  getLumaNeighbour(mb_nr, 0  ,  -1 , &up);

  if (!img->constrained_intra_pred_flag)
  {
    up_avail   = up.available;
    left_avail = left[1].available;
    left_up_avail = left[0].available;
  }
  else
  {
    up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
    for (i=1, left_avail=1; i<17;i++)
      left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  }

  switch (predmode)
  {
  case VERT_PRED_16:                       // vertical prediction from block above
    if (!up_avail)
      error ("invalid 16x16 intra pred Mode VERT_PRED_16",500);
    for(i=0;i<16;i++)
      for(j=0;j<16;j++)
        img->mpr[i][j]=imgY[up.pos_y][up.pos_x+i];// store predicted 16x16 block
    break;

  case HOR_PRED_16:                        // horisontal prediction from left block
    if (!left_avail)
      error ("invalid 16x16 intra pred Mode VERT_PRED_16",500);
    for(j=0;j<16;j++)
      for(i=0;i<16;i++)
        img->mpr[i][j]=imgY[left[j+1].pos_y][left[j+1].pos_x]; // store predicted 16x16 block
    break;

  case DC_PRED_16:                         // DC prediction
    s1=s2=0;
    for (i=0; i < 16; i++)
    {
      if (up_avail)
        s1 += imgY[up.pos_y][up.pos_x+i];    // sum hor pix
      if (left_avail)
        s2 += imgY[left[i+1].pos_y][left[i+1].pos_x];    // sum vert pix
    }
    if (up_avail && left_avail)
      s0=(s1+s2+16)>>5;       // no edge
    if (!up_avail && left_avail)
      s0=(s2+8)>>4;              // upper edge
    if (up_avail && !left_avail)
      s0=(s1+8)>>4;              // left edge
    if (!up_avail && !left_avail)
      s0=128;                            // top left corner, nothing to predict from
    for(i=0;i<16;i++)
      for(j=0;j<16;j+=4)
      {
        img->mpr[i][j]= img->mpr[i][j+1]= img->mpr[i][j+2]= img->mpr[i][j+3]=s0;
      }
    break;
  case PLANE_16:// 16 bit integer plan pred
    if (!up_avail || !left_up_avail  || !left_avail)
      error ("invalid 16x16 intra pred Mode PLANE_16",500);

    ih=0;
    iv=0;
	ih += (imgY[up.pos_y][up.pos_x+8] - imgY[up.pos_y][up.pos_x+6])
			+2*(imgY[up.pos_y][up.pos_x+9] - imgY[up.pos_y][up.pos_x+5])
			+3*(imgY[up.pos_y][up.pos_x+10] - imgY[up.pos_y][up.pos_x+4])
			+4*(imgY[up.pos_y][up.pos_x+11] - imgY[up.pos_y][up.pos_x+3])
			+5*(imgY[up.pos_y][up.pos_x+12] - imgY[up.pos_y][up.pos_x+2])
			+6*(imgY[up.pos_y][up.pos_x+13] - imgY[up.pos_y][up.pos_x+1])
			+7*(imgY[up.pos_y][up.pos_x+14] - imgY[up.pos_y][up.pos_x+0])
			+8*(imgY[up.pos_y][up.pos_x+15] - imgY[left[0].pos_y][left[0].pos_x]);

    iv += (imgY[left[9].pos_y][left[9].pos_x] - imgY[left[7].pos_y][left[7].pos_x])
		  +2*(imgY[left[10].pos_y][left[10].pos_x] - imgY[left[6].pos_y][left[6].pos_x])
		  +3*(imgY[left[11].pos_y][left[11].pos_x] - imgY[left[5].pos_y][left[5].pos_x])
		  +4*(imgY[left[12].pos_y][left[12].pos_x] - imgY[left[4].pos_y][left[4].pos_x])
		  +5*(imgY[left[13].pos_y][left[13].pos_x] - imgY[left[3].pos_y][left[3].pos_x])
		  +6*(imgY[left[14].pos_y][left[14].pos_x] - imgY[left[2].pos_y][left[2].pos_x])
		  +7*(imgY[left[15].pos_y][left[15].pos_x] - imgY[left[1].pos_y][left[1].pos_x])
		  +8*(imgY[left[16].pos_y][left[16].pos_x] - imgY[left[0].pos_y][left[0].pos_x]);

    ib=(5*ih+32)>>6;
    ic=(5*iv+32)>>6;

    iaa=16*(imgY[up.pos_y][up.pos_x+15]+imgY[left[16].pos_y][left[16].pos_x]);
    for (j=0;j< 16;j++)
    {
      for (i=0;i< 16;i++)
      {
        img->mpr[i][j]=Clip1((iaa+(i-7)*ib +(j-7)*ic + 16)>>5);
      }
    }// store plane prediction
    break;

  default:
    {                                    // indication of fault in bitstream,exit
      printf("illegal 16x16 intra prediction mode input: %d\n",predmode);
      return SEARCH_SYNC;
    }
  }

  return DECODING_OK;
}


void intrapred_chroma(struct img_par *img, int uv)
{
  int i,j, ii, jj, ioff, joff;

  byte ***imgUV = dec_picture->imgUV;
  
  int js0=0;
  int js1=0;
  int js2=0;
  int js3=0;

  int js[2][2];

  int pred;
  int ih, iv, ib, ic, iaa;

  int mb_nr=img->current_mb_nr;
  Macroblock *currMB = &img->mb_data[img->current_mb_nr];

  PixelPos up;       //!< pixel position p(0,-1)
  PixelPos left[9];  //!< pixel positions p(-1, -1..8)

  int up_avail, left_avail, left_up_avail;

  for (i=0;i<9;i++)
  {
    getChromaNeighbour(mb_nr, -1 ,  i-1 , &left[i]);
  }
  
  getChromaNeighbour(mb_nr, 0     ,  -1 , &up);

  if (!img->constrained_intra_pred_flag)
  {
    up_avail   = up.available;
    left_avail = left[1].available;
    left_up_avail = left[0].available;
  }
  else
  {
    up_avail      = up.available ? img->intra_block[up.mb_addr] : 0;
    for (i=1, left_avail=1; i<9;i++)
      left_avail  &= left[i].available ? img->intra_block[left[i].mb_addr]: 0;
    left_up_avail = left[0].available ? img->intra_block[left[0].mb_addr]: 0;
  }

  if (currMB->c_ipred_mode == DC_PRED_8)
  {
    for(i=0;i<4;i++)
    {
      if(up_avail)
      {
        js0=js0+imgUV[uv][up.pos_y][up.pos_x+i];
        js1=js1+imgUV[uv][up.pos_y][up.pos_x+i+4];
      }
      if(left_avail)
      {
        js2=js2+imgUV[uv][left[1+i].pos_y][left[1+i].pos_x];
        js3=js3+imgUV[uv][left[1+i+4].pos_y][left[1+i+4].pos_x];
      }
    }
    if(up_avail && left_avail)
    {
      js[0][0]=(js0+js2+4)>>3;
      js[1][0]=(js1+2)>>2;
      js[0][1]=(js3+2)>>2;
      js[1][1]=(js1+js3+4)>>3;
    }
    if(up_avail && !left_avail)
    {
      js[0][1]=js[0][0]=(js0+2)>>2;
      js[1][1]=js[1][0]=(js1+2)>>2;
    }
    if(left_avail && !up_avail)
    {
      js[1][0]=js[0][0]=(js2+2)>>2;
      js[1][1]=js[0][1]=(js3+2)>>2;
    }
    if(!up_avail && !left_avail)
    {
      js[0][0]=128;
      js[1][0]=128;
      js[0][1]=128;
      js[1][1]=128;
    }
  }
  
  for (j=0;j<2;j++)
  {
    joff=j*4;

    for(i=0;i<2;i++)
    {
      ioff=i*4;
      
      switch (currMB->c_ipred_mode)
      {
      case DC_PRED_8:
        for (ii=0; ii<4; ii++)
          for (jj=0; jj<4; jj++)
            img->mpr[ii+ioff][jj+joff]=js[i][j];
        break;
      case HOR_PRED_8:
        if (!left_avail)
          error("unexpected HOR_PRED_8 chroma intra prediction mode",-1);

        for (jj=0; jj<4; jj++)
        {
          pred = imgUV[uv][left[1+jj+joff].pos_y][left[1+jj+joff].pos_x];
          img->mpr[0+ioff][jj+joff]= img->mpr[1+ioff][jj+joff]= img->mpr[2+ioff][jj+joff]= img->mpr[3+ioff][jj+joff]= pred;
        }
        break;
      case VERT_PRED_8:
        if (!up_avail)
          error("unexpected VERT_PRED_8 chroma intra prediction mode",-1);

        for (ii=0; ii<4; ii++)
        {
          pred = imgUV[uv][up.pos_y][up.pos_x+ii+ioff];
          img->mpr[ii+ioff][0+joff]= img->mpr[ii+ioff][1+joff]= img->mpr[ii+ioff][2+joff]= img->mpr[ii+ioff][3+joff]=pred;
        }
        break;
      case PLANE_8:
        if (!left_up_avail || !left_avail || !up_avail)
          error("unexpected PLANE_8 chroma intra prediction mode",-1);

        ih=iv=0;

        ih += (imgUV[uv][up.pos_y][up.pos_x+4] - imgUV[uv][up.pos_y][up.pos_x+2])
				+2*(imgUV[uv][up.pos_y][up.pos_x+5] - imgUV[uv][up.pos_y][up.pos_x+1])
				+3*(imgUV[uv][up.pos_y][up.pos_x+6] - imgUV[uv][up.pos_y][up.pos_x+0])
				+4*(imgUV[uv][up.pos_y][up.pos_x+7] - imgUV[uv][left[0].pos_y][left[0].pos_x]);
		iv += (imgUV[uv][left[5].pos_y][left[5].pos_x] - imgUV[uv][left[3].pos_y][left[3].pos_x])
			+2*(imgUV[uv][left[6].pos_y][left[6].pos_x] - imgUV[uv][left[2].pos_y][left[2].pos_x])
			+3*(imgUV[uv][left[7].pos_y][left[7].pos_x] - imgUV[uv][left[1].pos_y][left[1].pos_x])
			+4*(imgUV[uv][left[8].pos_y][left[8].pos_x] - imgUV[uv][left[0].pos_y][left[0].pos_x]);

        ib=(17*ih+16)>>5;
        ic=(17*iv+16)>>5;
        iaa=16*(imgUV[uv][up.pos_y][up.pos_x+7]+imgUV[uv][left[8].pos_y][left[8].pos_x]);
        for (ii=0; ii<4; ii++)
          for (jj=0; jj<4; jj++)
            img->mpr[ii+ioff][jj+joff]=Clip1((iaa+(ii+ioff-3)*ib +(jj+joff-3)*ic + 16)>>5);
          break;
      default:
        error("illegal chroma intra prediction mode", 600);
        break;
      }
    }
  }
}


/*!
 ***********************************************************************
 * \brief
 *    Inverse 4x4 transformation, transforms cof to m7
 ***********************************************************************
 */
void itrans(struct img_par *img, //!< image parameters
            int ioff,            //!< index to 4x4 block
            int joff,            //!<
            int i0,              //!<
            int j0)              //!<
{
  int i,j,i1,j1;
  int m5[4];
  int m6[4];

  // horizontal
  for (j=0;j<4;j++)
  {
    for (i=0;i<4;i++)
    {
      m5[i]=img->cof[i0][j0][i][j];
    }
    m6[0]=(m5[0]+m5[2]);
    m6[1]=(m5[0]-m5[2]);
    m6[2]=(m5[1]>>1)-m5[3];
    m6[3]=m5[1]+(m5[3]>>1);

    for (i=0;i<2;i++)
    {
      i1=3-i;
      img->m7[i][j]=m6[i]+m6[i1];
      img->m7[i1][j]=m6[i]-m6[i1];
    }
  }
  // vertical
  for (i=0;i<4;i++)
  {
    for (j=0;j<4;j++)
      m5[j]=img->m7[i][j];

    m6[0]=(m5[0]+m5[2]);
    m6[1]=(m5[0]-m5[2]);
    m6[2]=(m5[1]>>1)-m5[3];
    m6[3]=m5[1]+(m5[3]>>1);

    for (j=0;j<2;j++)
    {
      j1=3-j;
      img->m7[i][j] =Clip1((m6[j]+m6[j1]+(img->mpr[i+ioff][j+joff] <<DQ_BITS)+DQ_ROUND)>>DQ_BITS);
      img->m7[i][j1]=Clip1((m6[j]-m6[j1]+(img->mpr[i+ioff][j1+joff]<<DQ_BITS)+DQ_ROUND)>>DQ_BITS);
    }
  }

}


/*!
 ***********************************************************************
 * \brief
 *    invers  transform
 ***********************************************************************
 */
void itrans_2(
   struct img_par *img) //!< image parameters
{
  int i,j,i1,j1;
  int M5[4];
  int M6[4];

  int qp_per = (img->qp-MIN_QP)/6;
  int qp_rem = (img->qp-MIN_QP)%6;

  // horizontal
  for (j=0;j<4;j++)
  {
    for (i=0;i<4;i++)
      M5[i]=img->cof[i][j][0][0];

    M6[0]=M5[0]+M5[2];
    M6[1]=M5[0]-M5[2];
    M6[2]=M5[1]-M5[3];
    M6[3]=M5[1]+M5[3];

    for (i=0;i<2;i++)
    {
      i1=3-i;
      img->cof[i ][j][0][0]= M6[i]+M6[i1];
      img->cof[i1][j][0][0]= M6[i]-M6[i1];
    }
  }

  // vertical
  for (i=0;i<4;i++)
  {
    for (j=0;j<4;j++)
      M5[j]=img->cof[i][j][0][0];

    M6[0]=M5[0]+M5[2];
    M6[1]=M5[0]-M5[2];
    M6[2]=M5[1]-M5[3];
    M6[3]=M5[1]+M5[3];

    for (j=0;j<2;j++)
    {
      j1=3-j;
      img->cof[i][j][0][0] = (((M6[j]+M6[j1])*dequant_coef[qp_rem][0][0]<<qp_per)+2)>>2;
      img->cof[i][j1][0][0]= (((M6[j]-M6[j1])*dequant_coef[qp_rem][0][0]<<qp_per)+2)>>2;
    }
  }
}