umc_mpeg2_enc_put.cpp

audio-video-codecs.rar语音编解码器

  Ipp32s *block_offset;
  Ipp32s *block_offset_ref;
  Ipp32s intra_dc_shift = 3 - intra_dc_precision;
  Ipp32s half_intra_dc = (1 << intra_dc_shift) >> 1;

  if (picture_coding_type == I_PICTURE) {
    PUT_BITS_TH(1, 1);
  } else {
    PUT_BITS_TH(3, 5);
  }
  if (!curr_frame_dct) {
    PUT_BITS_TH(pMBInfo[k].dct_type, 1);
  }

  if (pMBInfo[k].dct_type == DCT_FRAME) {
    block_offset = block_offset_frm;
    block_offset_ref = block_offset_frm/*_ref*/;
    stride[0] = YFrameHSize;
    stride[1] = UVFrameHSize;
    stride[2] = UVFrameHSize;
  } else {
    block_offset = block_offset_fld;
    block_offset_ref = block_offset_fld/*_ref*/;
    stride[0] = 2*YFrameHSize;
    stride[1] = UVFrameHSize << chroma_fld_flag;
    stride[2] = UVFrameHSize << chroma_fld_flag;
  }

  //Ipp32s cbp = 0;

  for (Ipp32s blk = 0; blk < block_count; blk++) {
    Ipp32s cc = color_index[blk];
    ippiDCT8x8Fwd_8u16s_C1R(BlockSrc[cc] + block_offset[blk], stride[cc], pMBlock);
    if (pMBlock[0] < 0) {
      pMBlock[0] = (Ipp16s)(-((-pMBlock[0] + half_intra_dc) >> intra_dc_shift));
    } else {
      pMBlock[0] = (Ipp16s)((pMBlock[0] + half_intra_dc) >> intra_dc_shift);
    }
    ippiQuantIntra_MPEG2_16s_C1I(pMBlock, quantiser_scale_value, InvIntraQMatrix, &Count[blk]);
    PutIntraBlock(pMBlock, &dc_dct_pred[cc], DC_Tbl[cc], Count[blk], numTh);
    if (picture_coding_type != B_PICTURE && !onlyIFrames) {
      pMBlock[0] <<= intra_dc_shift;

      if(Count[blk]) {
        ippiQuantInvIntra_MPEG2_16s_C1I(pMBlock, quantiser_scale_value, IntraQMatrix);
        ippiDCT8x8Inv_16s8u_C1R (pMBlock, BlockRec[cc] + block_offset_ref[blk], stride[cc]);
      } else {
        ippiSet_8u_C1R((Ipp8u)(pMBlock[0]/8), BlockRec[cc] + block_offset_ref[blk], stride[cc], roi);
      }
    }
    pMBlock += 64;
  }
}

void MPEG2VideoEncoderBase::PutMV_FRAME(Ipp32s numTh, Ipp32s k, IppMotionVector2 *vector, Ipp32s motion_type)
{
  Ipp32s hor_f_code, ver_f_code;
  Ipp32s BW = 0;

  if (motion_type == MB_BACKWARD) {
    hor_f_code = mp_f_code[1][0];
    ver_f_code = mp_f_code[1][1];
    BW = 1;
  } else {
    hor_f_code = mp_f_code[0][0];
    ver_f_code = mp_f_code[0][1];
  }

  if (motion_type) {
    if (picture_structure != FRAME_PICTURE) {
      PUT_BITS_TH(pMBInfo[k].mv_field_sel[2][BW], 1);
    }
    PutMV(
      vector->x - threadSpec[numTh].PMV[0][BW].x,
      hor_f_code, numTh);
    PutMV(
      vector->y - threadSpec[numTh].PMV[0][BW].y,
      ver_f_code, numTh);
  }

  threadSpec[numTh].PMV[0][BW].x = threadSpec[numTh].PMV[1][BW].x = vector->x;
  threadSpec[numTh].PMV[0][BW].y = threadSpec[numTh].PMV[1][BW].y = vector->y;
}

void MPEG2VideoEncoderBase::PutMV_FIELD(Ipp32s numTh, Ipp32s k, IppMotionVector2 *vector, IppMotionVector2 *vector2, Ipp32s motion_type)
{
  Ipp32s hor_f_code, ver_f_code;
  Ipp32s BW = 0;
  Ipp32s mv_shift = (picture_structure == FRAME_PICTURE) ? 1 : 0;

  if (motion_type == MB_BACKWARD) {
    hor_f_code = mp_f_code[1][0];
    ver_f_code = mp_f_code[1][1];
    BW = 1;
  } else {
    hor_f_code = mp_f_code[0][0];
    ver_f_code = mp_f_code[0][1];
  }

  /*if (motion_type)*/ {
    PUT_BITS_TH(pMBInfo[k].mv_field_sel[0][BW],1);
    PutMV(
      vector->x - threadSpec[numTh].PMV[0][BW].x,
      hor_f_code, numTh);
    PutMV(
      vector->y - (threadSpec[numTh].PMV[0][BW].y >> mv_shift),
      ver_f_code, numTh);

    PUT_BITS_TH(pMBInfo[k].mv_field_sel[1][BW],1);
    PutMV(
      vector2->x - threadSpec[numTh].PMV[1][BW].x,
      hor_f_code, numTh);
    PutMV(
      vector2->y - (threadSpec[numTh].PMV[1][BW].y >> mv_shift),
      ver_f_code, numTh);
  }
  threadSpec[numTh].PMV[0][BW].x = vector->x;
  threadSpec[numTh].PMV[0][BW].y = vector->y << mv_shift;
  threadSpec[numTh].PMV[1][BW].x = vector2->x;
  threadSpec[numTh].PMV[1][BW].y = vector2->y << mv_shift;
}

void MPEG2VideoEncoderBase::PrepareBuffers()
{
  Ipp32s i;
  thread_buffer_size = (output_buffer_size/encodeInfo.numThreads) &~ 3;
  for (i = 0; i < encodeInfo.numThreads; i++) {
    SET_BUFFER(threadSpec[i].bBuf, out_pointer + i*thread_buffer_size, thread_buffer_size)
  }
}

Ipp32s MPEG2VideoEncoderBase::IntraMBSize(Ipp32s k, const Ipp8u *BlockSrc[3],
                                          Ipp32s *dc_dct_pred, Ipp32s increment,
                                          Ipp32s scantype, Ipp32s vlcFormat)
{
  Ipp16s coefs[64*8];
  Ipp16s *pMBlock = coefs;
  Ipp32s Count[12];
  Ipp32s stride[3];
  Ipp32s *block_offset;
  Ipp32s *block_offset_ref;
  Ipp32s intra_dc_shift = 3 - intra_dc_precision;
  Ipp32s half_intra_dc = (1 << intra_dc_shift) >> 1;
  Ipp32s sz; //intra type len + some

  sz = (picture_coding_type == I_PICTURE) ? 1 : 5;

  while( increment > 33 ) {
    sz += 11; // macroblock_escape
    increment -= 33;
  }
  sz += AddrIncrementTbl[increment].len;

  if (!curr_frame_dct) {
    sz++;
  }

  if (pMBInfo[k].dct_type == DCT_FRAME) {
    block_offset = block_offset_frm;
    block_offset_ref = block_offset_frm/*_ref*/;
    stride[0] = YFrameHSize;
    stride[1] = UVFrameHSize;
    stride[2] = UVFrameHSize;
  } else {
    block_offset = block_offset_fld;
    block_offset_ref = block_offset_fld/*_ref*/;
    stride[0] = 2*YFrameHSize;
    stride[1] = UVFrameHSize << chroma_fld_flag;
    stride[2] = UVFrameHSize << chroma_fld_flag;
  }

  for (Ipp32s blk = 0; blk < block_count; blk++) {
    Ipp32s cc = color_index[blk];
    ippiDCT8x8Fwd_8u16s_C1R(BlockSrc[cc] + block_offset[blk], stride[cc], pMBlock);
    if (pMBlock[0] < 0) {
      pMBlock[0] = (Ipp16s)(-((-pMBlock[0] + half_intra_dc) >> intra_dc_shift));
    } else {
      pMBlock[0] = (Ipp16s)((pMBlock[0] + half_intra_dc) >> intra_dc_shift);
    }
    // scale quantizer
    ippiQuantIntra_MPEG2_16s_C1I(pMBlock, quantiser_scale_value, InvIntraQMatrix, &Count[blk]);
    //PutIntraBlock(pMBlock, &dc_dct_pred[cc], DC_Tbl[cc], Count[blk], numTh);
    {
      Ipp32s EOBLen;
      IppVCHuffmanSpec_32s* AC_Tbl;
      Ipp32s *scan = scantype ? AlternateScan : ZigZagScan;

      if (vlcFormat) {
        EOBLen  = 4; // (Table B-15)
        AC_Tbl = vlcTableB15;
      } else {
        EOBLen  = 2; // (Table B-14)
        AC_Tbl = vlcTableB5c_e;
      }

      //mp2PutIntraBlock(&threadSpec[numTh].bBuf.current_pointer, &threadSpec[numTh].bBuf.bit_offset,
      //  pMBlock, dc_dct_pred, (IppVCHuffmanSpec_32u*)DC_Tbl, AC_Tbl, scan, EOBLen, EOBCode, count);
      {
        Ipp32s n, m, dct_diff, run, signed_level;
        Ipp32s absval, size1;

        dct_diff = pMBlock[0] - dc_dct_pred[cc];
        dc_dct_pred[cc] = pMBlock[0];

        /* generate variable length code for DC coefficient (7.2.1)*/
        if(dct_diff == 0) {
          sz += (DC_Tbl[cc])[0].len;
        } else {
          m = dct_diff >> 31;
          absval = (dct_diff + m) ^ m;
          for (size1=1; absval >>= 1; size1++);

          /* generate VLC for dct_dc_size (Table B-12 or B-13)*/
          /* append fixed length code (dc_dct_differential)*/
          absval = (((DC_Tbl[cc])[size1].code - m) << size1) + (dct_diff + m);
          n  = (DC_Tbl[cc])[size1].len + size1;
          sz += n;
        }

        run = 0;
        m = 0;

        for(n=1; m < Count[blk] ; n++)
        {
          signed_level = pMBlock[scan[n]];
          if( signed_level )
          {
            //mp2PutAC(pBitStream, pOffset, run, signed_level, AC_Tbl);
            {
              Ipp32s level, len;
              Ipp32s maxRun = AC_Tbl[0] >> 20;
              Ipp32s addr;
              Ipp32s * table;

              if(run > maxRun)
              {
                /* no VLC for this (run, level) combination: use escape coding (7.2.2.3)*/
                /* ISO/IEC 13818-2 uses a 12 bit code, Table B-16*/
                sz += 24;
              } else {
                level = (signed_level < 0) ? -signed_level : signed_level;

                addr = AC_Tbl[run + 1];
                table = (Ipp32s*)((Ipp8s*)AC_Tbl + addr);
                if(level <= table[0])
                {
                  len  = *(table + signed_level) & 0x1f;
                  sz += len;
                }
                else
                {
                  /* no VLC for this (run, level) combination: use escape coding (7.2.2.3)*/
                  /* ISO/IEC 13818-2 uses a 12 bit code, Table B-16*/
                  sz += 24;
                }
              }
            }
            m++;
            run = 0;
          }
          else
            run++;
        }
        sz += EOBLen;
      }

    }
    pMBlock += 64;
  }
  return sz;
}

#endif // UMC_ENABLE_MPEG2_VIDEO_ENCODER