block.c

h.264 影像壓縮 必須在 .net 的環境 下操作

    }
  }

  for (j = 0; j < BLOCK_SIZE; j++)
    for (i = 0; i < BLOCK_SIZE; i++)
      img->m7[yuv][joff+j][ioff+i] =  img->m7[yuv][joff+j][ioff+i] + (long)mpr[joff+j][ioff+i];

  return 0;
}

/*!
************************************************************************
* \brief
*    Inverse residual DPCM for Intra lossless coding
*
* \par Input:
*    ioff_x,joff_y: Block position inside a macro block (0,8).
************************************************************************
*/
//For residual DPCM
int Inv_Residual_trans_8x8(ColorPlane pl, struct img_par *img, int ioff,int joff)
{
  int i, j;
  int temp[8][8];
  imgpel (*mpr)[16] = img->mpr[pl];

  if(!pl)  //luma
  {
    if(ipmode_DPCM==VERT_PRED)
    {
      for(i=0; i<8; i++)
      {
        temp[1][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i];
        temp[2][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i];
        temp[3][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i];
        temp[4][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i];
        temp[5][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i];
        temp[6][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i]+img->m7[pl][joff+6][ioff+i];
        temp[7][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i]+img->m7[pl][joff+6][ioff+i]+img->m7[pl][joff+7][ioff+i];
      }
      for(i=0; i<8; i++)
      {
        img->m7[pl][joff+1][ioff+i]=temp[1][i];
        img->m7[pl][joff+2][ioff+i]=temp[2][i];
        img->m7[pl][joff+3][ioff+i]=temp[3][i];
        img->m7[pl][joff+4][ioff+i]=temp[4][i];
        img->m7[pl][joff+5][ioff+i]=temp[5][i];
        img->m7[pl][joff+6][ioff+i]=temp[6][i];
        img->m7[pl][joff+7][ioff+i]=temp[7][i];
      }
    }
    else if(ipmode_DPCM==HOR_PRED)//HOR_PRED
    {
      for(i=0; i<8; i++)
      {
        temp[i][1]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1];
        temp[i][2]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2];
        temp[i][3]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3];
        temp[i][4]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4];
        temp[i][5]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5];
        temp[i][6]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5]+img->m7[pl][joff+i][ioff+6];
        temp[i][7]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5]+img->m7[pl][joff+i][ioff+6]+img->m7[pl][joff+i][ioff+7];
      }
      for(i=0; i<8; i++)
      {
        img->m7[pl][joff+i][ioff+1]=temp[i][1];
        img->m7[pl][joff+i][ioff+2]=temp[i][2];
        img->m7[pl][joff+i][ioff+3]=temp[i][3];
        img->m7[pl][joff+i][ioff+4]=temp[i][4];
        img->m7[pl][joff+i][ioff+5]=temp[i][5];
        img->m7[pl][joff+i][ioff+6]=temp[i][6];
        img->m7[pl][joff+i][ioff+7]=temp[i][7];
      }
    }
    for (j = 0; j < BLOCK_SIZE*2; j++)
      for (i = 0; i < BLOCK_SIZE*2; i++)
        img->m7[pl][j+joff][i+ioff] =  img->m7[pl][j+joff][i+ioff] + (long)mpr[j+joff][i+ioff];
  }
  else  //chroma
  {
    if(ipmode_DPCM==VERT_PRED)
    {
      for(i=0; i<8; i++)
      {
        temp[1][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i];
        temp[2][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i];
        temp[3][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i];
        temp[4][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i];
        temp[5][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i];
        temp[6][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i]+img->m7[pl][joff+6][ioff+i];
        temp[7][i]=img->m7[pl][joff+0][ioff+i]+img->m7[pl][joff+1][ioff+i]+img->m7[pl][joff+2][ioff+i]+img->m7[pl][joff+3][ioff+i]+img->m7[pl][joff+4][ioff+i]+img->m7[pl][joff+5][ioff+i]+img->m7[pl][joff+6][ioff+i]+img->m7[pl][joff+7][ioff+i];
      }
      for(i=0; i<8; i++)
      {
        img->m7[pl][joff+1][ioff+i]=temp[1][i];
        img->m7[pl][joff+2][ioff+i]=temp[2][i];
        img->m7[pl][joff+3][ioff+i]=temp[3][i];
        img->m7[pl][joff+4][ioff+i]=temp[4][i];
        img->m7[pl][joff+5][ioff+i]=temp[5][i];
        img->m7[pl][joff+6][ioff+i]=temp[6][i];
        img->m7[pl][joff+7][ioff+i]=temp[7][i];
      }
    }
    else if(ipmode_DPCM==HOR_PRED)//HOR_PRED
    {
      for(i=0; i<8; i++)
      {
        temp[i][1]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1];
        temp[i][2]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2];
        temp[i][3]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3];
        temp[i][4]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4];
        temp[i][5]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5];
        temp[i][6]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5]+img->m7[pl][joff+i][ioff+6];
        temp[i][7]=img->m7[pl][joff+i][ioff+0]+img->m7[pl][joff+i][ioff+1]+img->m7[pl][joff+i][ioff+2]+img->m7[pl][joff+i][ioff+3]+img->m7[pl][joff+i][ioff+4]+img->m7[pl][joff+i][ioff+5]+img->m7[pl][joff+i][ioff+6]+img->m7[pl][joff+i][ioff+7];
      }
      for(i=0; i<8; i++)
      {
        img->m7[pl][joff+i][ioff+1]=temp[i][1];
        img->m7[pl][joff+i][ioff+2]=temp[i][2];
        img->m7[pl][joff+i][ioff+3]=temp[i][3];
        img->m7[pl][joff+i][ioff+4]=temp[i][4];
        img->m7[pl][joff+i][ioff+5]=temp[i][5];
        img->m7[pl][joff+i][ioff+6]=temp[i][6];
        img->m7[pl][joff+i][ioff+7]=temp[i][7];
      }
    }
    for (j = 0; j < BLOCK_SIZE*2; j++)
      for (i = 0; i < BLOCK_SIZE*2; i++)
        img->m7[pl][j+joff][i+ioff] =  img->m7[pl][j+joff][i+ioff] + (long)mpr[j+joff][i+ioff];
  }
  return 0;
}

/*!
 ************************************************************************
 * \brief
 *    For mapping the q-matrix to the active id and calculate quantisation values
 *
 * \param pps
 *    Picture parameter set
 * \param sps
 *    Sequence parameter set
 *
 ************************************************************************
 */
void AssignQuantParam(pic_parameter_set_rbsp_t* pps, seq_parameter_set_rbsp_t* sps)
{
  int i;
  int n_ScalingList;

  if(!pps->pic_scaling_matrix_present_flag && !sps->seq_scaling_matrix_present_flag)
  {
    for(i=0; i<12; i++)
      qmatrix[i] = (i<6) ? quant_org:quant8_org;
  }
  else
  {
    n_ScalingList = (sps->chroma_format_idc != YUV444) ? 8 : 12;
    if(sps->seq_scaling_matrix_present_flag) // check sps first
    {
      for(i=0; i<n_ScalingList; i++)
      {
        if(i<6)
        {
          if(!sps->seq_scaling_list_present_flag[i]) // fall-back rule A
          {
            if(i==0)
              qmatrix[i] = quant_intra_default;
            else if(i==3)
              qmatrix[i] = quant_inter_default;
            else
              qmatrix[i] = qmatrix[i-1];
          }
          else
          {
            if(sps->UseDefaultScalingMatrix4x4Flag[i])
              qmatrix[i] = (i<3) ? quant_intra_default:quant_inter_default;
            else
              qmatrix[i] = sps->ScalingList4x4[i];
          }
        }
        else
        {
          if(!sps->seq_scaling_list_present_flag[i]) // fall-back rule A
          {
            if(i==6)
              qmatrix[i] = quant8_intra_default;
            else if(i==7)
              qmatrix[i] = quant8_inter_default;
            else
              qmatrix[i] = qmatrix[i-2];
          }
          else
          {
            if(sps->UseDefaultScalingMatrix8x8Flag[i-6])
              qmatrix[i] = (i==6 || i==8 || i==10) ? quant8_intra_default:quant8_inter_default;
            else
              qmatrix[i] = sps->ScalingList8x8[i-6];
          }
        }
      }
    }

    if(pps->pic_scaling_matrix_present_flag) // then check pps
    {
      for(i=0; i<n_ScalingList; i++)
      {
        if(i<6)
        {
          if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
          {
            if (i==0)
            {
              if(!sps->seq_scaling_matrix_present_flag)
                qmatrix[i] = quant_intra_default;
            }
            else if (i==3)
            {
              if(!sps->seq_scaling_matrix_present_flag)
                qmatrix[i] = quant_inter_default;
            }
            else
              qmatrix[i] = qmatrix[i-1];
          }
          else
          {
            if(pps->UseDefaultScalingMatrix4x4Flag[i])
              qmatrix[i] = (i<3) ? quant_intra_default:quant_inter_default;
            else
              qmatrix[i] = pps->ScalingList4x4[i];
          }
        }
        else
        {
          if(!pps->pic_scaling_list_present_flag[i]) // fall-back rule B
          {
            if (i==6)
            {
              if(!sps->seq_scaling_matrix_present_flag)
                qmatrix[i] = quant8_intra_default;
            }
            else if(i==7)
            {
              if(!sps->seq_scaling_matrix_present_flag)
                qmatrix[i] = quant8_inter_default;
            }
            else  
              qmatrix[i] = qmatrix[i-2];
          }
          else
          {
            if(pps->UseDefaultScalingMatrix8x8Flag[i-6])
              qmatrix[i] = (i==6 || i==8 || i==10) ? quant8_intra_default:quant8_inter_default;
            else
              qmatrix[i] = pps->ScalingList8x8[i-6];
          }
        }
      }
    }
  }

  CalculateQuantParam();
  if(pps->transform_8x8_mode_flag)
    CalculateQuant8Param();
}

/*!
 ************************************************************************
 * \brief
 *    For calculating the quantisation values at frame level
 *
 ************************************************************************
 */
void CalculateQuantParam()
{
  int i, j, k, temp;

  for(k=0; k<6; k++)
    for(j=0; j<4; j++)
      for(i=0; i<4; i++)
      {
        temp = (i<<2)+j;
        InvLevelScale4x4Luma_Intra[k][i][j]      = dequant_coef[k][j][i]*qmatrix[0][temp];
        InvLevelScale4x4Chroma_Intra[0][k][i][j] = dequant_coef[k][j][i]*qmatrix[1][temp];
        InvLevelScale4x4Chroma_Intra[1][k][i][j] = dequant_coef[k][j][i]*qmatrix[2][temp];

        InvLevelScale4x4Luma_Inter[k][i][j]      = dequant_coef[k][j][i]*qmatrix[3][temp];
        InvLevelScale4x4Chroma_Inter[0][k][i][j] = dequant_coef[k][j][i]*qmatrix[4][temp];
        InvLevelScale4x4Chroma_Inter[1][k][i][j] = dequant_coef[k][j][i]*qmatrix[5][temp];
      }
}

/*!
 ***********************************************************************
 * \brief
 *    Luma DC inverse transform
 ***********************************************************************
 */ 
void itrans_2(ColorPlane pl, struct img_par *img) //!< image parameters
{
  static int invLevelScale;
  static int M4[4][4];
  int i,j;

  int qp, qp_c;
  int qp_per, qp_rem;

  if (pl)
  {
    int uv = pl - 1;
    qp = img->qp + dec_picture->chroma_qp_offset[uv];
    qp = iClip3(-(img->bitdepth_chroma_qp_scale), 51, qp); 
    qp_c   = (qp < 0)? qp : QP_SCALE_CR[qp-MIN_QP];
    qp_per = (qp_c + img->bitdepth_chroma_qp_scale)/6;
    qp_rem = (qp_c + img->bitdepth_chroma_qp_scale)%6;
    invLevelScale = InvLevelScale4x4Chroma_Intra[uv][qp_rem][0][0];
  }
  else
  {
    qp_per = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)/6;
    qp_rem = (img->qp + img->bitdepth_luma_qp_scale - MIN_QP)%6;
    invLevelScale = InvLevelScale4x4Luma_Intra[qp_rem][0][0];
  }

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

  ihadamard4x4(M4, M4);
  // vertical

  for (j=0; j < 4;j++) 
    for (i=0; i < 4;i++) 
  {
    img->cof[pl][j<<2][i<<2] = rshift_rnd((( M4[j][i]*invLevelScale) << qp_per), 6);
  }
}



void itrans_sp(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];
  int predicted_block[BLOCK_SIZE][BLOCK_SIZE],ilev;

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

  int qp_per_sp = (img->qpsp-MIN_QP)/6;
  int qp_rem_sp = (img->qpsp-MIN_QP)%6;
  int q_bits_sp = Q_BITS+qp_per_sp;
  int qp_const2 = (1<<q_bits_sp)/2;  //sp_pred
  imgpel (*mpr)[16] = img->mpr[LumaComp];
  int    (*m7) [16] = img->m7[LumaComp];

  if (img->type == SI_SLICE) //ES modified
  {
    qp_per = (img->qpsp-MIN_QP)/6;
    qp_rem = (img->qpsp-MIN_QP)%6;
    q_bits = Q_BITS+qp_per;
  }

  for (j=0; j< BLOCK_SIZE; j++)
  for (i=0; i< BLOCK_SIZE; i++)
      predicted_block[i][j]=mpr[j+joff][i+ioff];
  for (j=0; j < BLOCK_SIZE; j++)
  {
    for (i=0; i < 2; i++)
    {
      i1=3-i;
      m5[i]=predicted_block[i][j]+predicted_block[i1][j];
      m5[i1]=predicted_block[i][j]-predicted_block[i1][j];
    }
    predicted_block[0][j]=(m5[0]+m5[1]);
    predicted_block[2][j]=(m5[0]-m5[1]);
    predicted_block[1][j]=m5[3]*2+m5[2];
    predicted_block[3][j]=m5[3]-m5[2]*2;
  }

  //  Vertival transform

  for (i=0; i < BLOCK_SIZE; i++)
  {
    for (j=0; j < 2; j++)
    {
      j1=3-j;
      m5[j]=predicted_block[i][j]+predicted_block[i][j1];
      m5[j1]=predicted_block[i][j]-predicted_block[i][j1];
    }
    predicted_block[i][0]=(m5[0]+m5[1]);
    predicted_block[i][2]=(m5[0]-m5[1]);
    predicted_block[i][1]=m5[3]*2+m5[2];
    predicted_block[i][3]=m5[3]-m5[2]*2;
  }

  for (j=0;j<BLOCK_SIZE;j++)
  for (i=0;i<BLOCK_SIZE;i++)
  {
    // recovering coefficient since they are already dequantized earlier
    img->cof[0][(j0<<2) + j][(i0<<2) + i]=(img->cof[0][(j0<<2) + j][(i0<<2) + i] >> qp_per) / dequant_coef[qp_rem][i][j];
    if(img->sp_switch || img->type==SI_SLICE)  //M.W. patched for SI
    {
      ilev=(iabs(predicted_block[i][j]) * quant_coef[qp_rem_sp][i][j] + qp_const2) >> q_bits_sp; //ES added
      ilev= isignab(ilev,predicted_block[i][j])+ img->cof[0][(j0<<2) + j][(i0<<2) + i];                           //ES added
      img->cof[0][(j0<<2) + j][(i0<<2) + i] = isignab(iabs(ilev) * dequant_coef[qp_rem_sp][i][j] << qp_per_sp ,ilev) ; //ES added      
    }                                                                                             //ES added
    else
    {                                                                                          //ES added
      ilev=((img->cof[0][(j0<<2) + j][(i0<<2) + i]*dequant_coef[qp_rem][i][j]*A[i][j]<< qp_per) >>6)+predicted_block[i][j] ;
      img->cof[0][(j0<<2) + j][(i0<<2) + i]=isignab((iabs(ilev) * quant_coef[qp_rem_sp][i][j] + qp_const2) >> q_bits_sp, ilev) * dequant_coef[qp_rem_sp][i][j] << qp_per_sp;
    }
  }
  // horizontal
  for (j=0;j<BLOCK_SIZE;j++)
  {
    for (i=0;i<BLOCK_SIZE;i++)
    {
      m5[i]=img->cof[0][(j0<<2) + j][(i0<<2) + i];
    }
    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;