umc_mpeg2_enc_b.cpp

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

      }

      IF_GOOD_PRED(best->var, best->mean) {
        goodpred = 1;
        goto encodeMB;
      }

      if (!curr_frame_dct) {
        VARMEAN_FIELD_Y(curr->var, mean_fld, curr->var_sum);
        curr->var_sum = SCALE_VAR_INTRA(curr->var_sum);
        if(curr->var_sum < best->var_sum)
        {
          curr->mb_type = MB_INTRA;
          curr->dct_type = DCT_FIELD;
          SWAP_PTR(best, curr);
        }
      }

      if (!curr_frame_pred ) {
        ME_FIELD(dir0, curr->var_sum, curr->pDiff, curr->dct_type);
        curr->var_sum = SCALE_VAR(curr->var_sum, SC_VAR_2V);
        if(curr->var_sum < best->var_sum)
        {
          curr->mb_type = dir0 == 0 ? MB_FORWARD : MB_BACKWARD;
          curr->pred_type = MC_FIELD;
          SWAP_PTR(best, curr);
        }
      }

      // Backward vector search
      BOUNDS_H(dir1,i)
      ME_FRAME(dir1, curr->var_sum, curr->pDiff, curr->dct_type);
      curr->var_sum = SCALE_VAR(curr->var_sum, SC_VAR_1V);
      if(curr->var_sum < best->var_sum)
      {
        curr->mb_type = dir1 == 0 ? MB_FORWARD : MB_BACKWARD;
        curr->pred_type = MC_FRAME;
        SWAP_PTR(best, curr);

        IF_GOOD_PRED(best->var, best->mean) {
          goodpred = 1;
          goto encodeMB;
        }
      }

      if (!curr_frame_pred ) {
        ME_FIELD(dir1, curr->var_sum, curr->pDiff, curr->dct_type);
        curr->var_sum = SCALE_VAR(curr->var_sum, SC_VAR_2V);
        if(curr->var_sum < best->var_sum)
        {
          curr->mb_type = dir1 == 0 ? MB_FORWARD : MB_BACKWARD;
          curr->pred_type = MC_FIELD;
          SWAP_PTR(best, curr);
        }
      }

      // Bi-directional
      for (pred_ind = 0; pred_ind <= (curr_frame_pred ? 0 : 1); pred_ind++) {
        Ipp32s pred_type;
        Ipp32s scale_var;

        if (!pred_ind) {
          pred_type = MC_FRAME;
          GETDIFF_FRAME_FB(Y, Y, l, curr->pDiff);
          scale_var = SC_VAR_1VBI;
        } else {
          pred_type = MC_FIELD;
          GETDIFF_FIELD_FB(Y, Y, l, curr->pDiff);
          scale_var = SC_VAR_2VBI;
        }

        if (!curr_frame_dct) {
          Ipp32s var_fld = 0, var = 0;
          ippiFrameFieldSAD16x16_16s32s_C1R(curr->pDiff, BlkStride_l*2, &var, &var_fld);
          if (var_fld < var) {
            curr->dct_type = DCT_FIELD;
            VARMEAN_FIELD(curr->pDiff, curr->var, curr->mean, curr->var_sum);
          } else {
            curr->dct_type = DCT_FRAME;
            VARMEAN_FRAME(curr->pDiff, curr->var, curr->mean, curr->var_sum);
          }
        } else {
          curr->dct_type = DCT_FRAME;
          VARMEAN_FRAME(curr->pDiff, curr->var, curr->mean, curr->var_sum);
        }

        curr->var_sum = SCALE_VAR(curr->var_sum, scale_var);
        if(curr->var_sum < best->var_sum)
        {
          curr->mb_type = MB_FORWARD | MB_BACKWARD;
          curr->pred_type = pred_type;
          SWAP_PTR(best, curr);
        }

      }

encodeMB:
      pMBInfo[k].prediction_type = best->pred_type;
      pMBInfo[k].dct_type = best->dct_type;
      pMBInfo[k].mb_type = best->mb_type;

      if (pMBInfo[k].mb_type & MB_INTRA)
      {
        ippsZero_8u((Ipp8u*)threadSpec[numTh].PMV, sizeof(threadSpec[0].PMV));
        ippsZero_8u((Ipp8u*)pMBInfo[k].MV, sizeof(pMBInfo[k].MV));

        PutAddrIncrement(macroblock_address_increment, numTh);
        macroblock_address_increment = 1;

        if(slice_macroblock_address - slice_past_intra_address > 1)
          dc_dct_pred[0] = dc_dct_pred[1] = dc_dct_pred[2] = ResetTbl[intra_dc_precision];

        slice_past_intra_address = (i >> 4);

        const Ipp8u *BlockSrc[3] = {YBlock, UBlock, VBlock};
        PutIntraMacroBlock(numTh, k, BlockSrc, NULL, dc_dct_pred);
        if (!curr_frame_dct)
          threadSpec[numTh].fieldCount += (pMBInfo[k].dct_type == DCT_FIELD)? 1 : -1;

        k++;
        continue;
      } //Intra macroblock

      ippsZero_8u((Ipp8u*)Count, sizeof(Count));
      CodedBlockPattern  = 0;
      pDiff = best->pDiff;

      // Non-intra macroblock
      if(pMBInfo[k].prediction_type == MC_FRAME)
      {
        Ipp32s try_skip = (i != 0) && (i != MBcountH*16 - 16) &&
            (((pMBInfo[k].mb_type ^ pMBInfo[k-1].mb_type) & (MB_FORWARD | MB_BACKWARD)) == 0);
        if((pMBInfo[k].mb_type&MB_FORWARD)&&
          (pMBInfo[k].mb_type&MB_BACKWARD))
        {
          GETDIFF_FRAME_FB(U, UV, c, pDiff);
          GETDIFF_FRAME_FB(V, UV, c, pDiff);

          NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);
          if(CodedBlockPattern == 0 && try_skip &&
              vector[2][0].x == threadSpec[numTh].PMV[0][0].x &&
              vector[2][0].y == threadSpec[numTh].PMV[0][0].y &&
              vector[2][1].x == threadSpec[numTh].PMV[0][1].x &&
              vector[2][1].y == threadSpec[numTh].PMV[0][1].y &&
              pMBInfo[k].mv_field_sel[2][0] == curr_field &&
              pMBInfo[k].mv_field_sel[2][1] == curr_field) {
            goto skip_macroblock;
          }

          PutAddrIncrement(macroblock_address_increment, numTh);
          macroblock_address_increment = 1;

          PUT_MB_MODES(B_PICTURE, MB_FORWARD | MB_BACKWARD);
          PutMV_FRAME(numTh, k, &vector[2][0], MB_FORWARD);
          PutMV_FRAME(numTh, k, &vector[2][1], MB_BACKWARD);
        }
        else if(pMBInfo[k].mb_type&MB_FORWARD)
        {
          if (curr_frame_dct)
          {
            GETDIFF_FRAME(Y, Y, l, pDiff, 0);
          }
          GETDIFF_FRAME(U, UV, c, pDiff, 0);
          GETDIFF_FRAME(V, UV, c, pDiff, 0);

          NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);
          if(CodedBlockPattern == 0 && try_skip &&
              vector[2][0].x == threadSpec[numTh].PMV[0][0].x &&
              vector[2][0].y == threadSpec[numTh].PMV[0][0].y &&
              pMBInfo[k].mv_field_sel[2][0] == curr_field) {
            goto skip_macroblock;
          }

          PutAddrIncrement(macroblock_address_increment, numTh);
          macroblock_address_increment = 1;

          PUT_MB_MODES(B_PICTURE, MB_FORWARD);
          PutMV_FRAME(numTh, k, &vector[2][0], MB_FORWARD);
        }
        else //pMBInfo.mb_type&MB_BACKWARD
        {
          if (curr_frame_dct)
          {
            GETDIFF_FRAME(Y, Y, l, pDiff, 1);
          }
          GETDIFF_FRAME(U, UV, c, pDiff, 1);
          GETDIFF_FRAME(V, UV, c, pDiff, 1);

          NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);
          if(CodedBlockPattern == 0 && try_skip &&
              vector[2][1].x == threadSpec[numTh].PMV[0][1].x &&
              vector[2][1].y == threadSpec[numTh].PMV[0][1].y &&
              pMBInfo[k].mv_field_sel[2][1] == curr_field) {
            goto skip_macroblock;
          }

          PutAddrIncrement(macroblock_address_increment, numTh);
          macroblock_address_increment = 1;

          PUT_MB_MODES(B_PICTURE, MB_BACKWARD);
          PutMV_FRAME(numTh, k, &vector[2][1], MB_BACKWARD);
        }
      }
      else //pMBInfo[k].prediction_type == MC_FIELD
      {
        if((pMBInfo[k].mb_type&MB_FORWARD)&&
          (pMBInfo[k].mb_type&MB_BACKWARD))
        {
          GETDIFF_FIELD_FB(U, UV, c, pDiff);
          GETDIFF_FIELD_FB(V, UV, c, pDiff);

          NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);

          PutAddrIncrement(macroblock_address_increment, numTh);
          macroblock_address_increment = 1;

          PUT_MB_MODES(B_PICTURE, MB_FORWARD | MB_BACKWARD);
          PutMV_FIELD(numTh, k, &vector[0][0], &vector[1][0], MB_FORWARD);
          PutMV_FIELD(numTh, k, &vector[0][1], &vector[1][1], MB_BACKWARD);
        } else
          if(pMBInfo[k].mb_type&MB_FORWARD)
          {
            GETDIFF_FIELD(U, UV, c, pDiff, 0);
            GETDIFF_FIELD(V, UV, c, pDiff, 0);

            NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);

            PutAddrIncrement(macroblock_address_increment, numTh);
            macroblock_address_increment = 1;

            PUT_MB_MODES(B_PICTURE, MB_FORWARD);
            PutMV_FIELD(numTh, k, &vector[0][0], &vector[1][0], MB_FORWARD);
          }
          else //pMBInfo.mb_type&MB_BACKWARD
          {
            GETDIFF_FIELD(U, UV, c, pDiff, 1);
            GETDIFF_FIELD(V, UV, c, pDiff, 1);

            NonIntraMBCoeffs(numTh, best, Count, &CodedBlockPattern);

            PutAddrIncrement(macroblock_address_increment, numTh);
            macroblock_address_increment = 1;

            PUT_MB_MODES(B_PICTURE, MB_BACKWARD);
            PutMV_FIELD(numTh, k, &vector[0][1], &vector[1][1], MB_BACKWARD);
          }
      } //FIELD_PREDICTION

      PUT_BLOCK_PATTERN(CodedBlockPattern);

      pMBlock = threadSpec[numTh].pMBlock;
      for (Ipp32s loop = 0; loop < block_count; loop++)
      {
        if (Count[loop]) {
          PutNonIntraBlock(pMBlock, Count[loop], numTh);
        }
        pMBlock += 64;
      }

      ippsCopy_8u((Ipp8u*)threadSpec[numTh].PMV, (Ipp8u*)pMBInfo[k].MV, sizeof(threadSpec[0].PMV));

      if (!curr_frame_dct)
        threadSpec[numTh].fieldCount += (pMBInfo[k].dct_type == DCT_FIELD)? 1 : -1;

      k++;
    } // for(i)
  } // for(j)
}

#endif // UMC_ENABLE_MPEG2_VIDEO_ENCODER