skl_mpg4_rvop.cpp

mpeg4编解码器

  Tmp[3][1] = SCALE_UP_MV(MV2[1][1]);
  Clip_Field(Tmp[0], Tmp[0]);   // TODO: dunno if it's correct.
  Clip_Field(Tmp[1], Tmp[1]);
  Clip_Field(Tmp[2], Tmp[2]);
  Clip_Field(Tmp[3], Tmp[3]);

  if (!VOL->Quarter) {
    SKL_BYTE * Y = Y1;
    Predict_16x8 (Y,        Y        +Fwd_CoLoc, Tmp[0], Ops);
    Predict_16x8 (Y+BpS8,   Y+BpS8   +Fwd_CoLoc, Tmp[0], Ops);
    Predict_16x8 (Y+16,     Y+16     +Fwd_CoLoc, Tmp[1], Ops);
    Predict_16x8 (Y+16+BpS8,Y+16+BpS8+Fwd_CoLoc, Tmp[1], Ops);

    Y += 2*BpS8;
    Predict_16x8 (Y,        Y        +Fwd_CoLoc, Tmp[2], Ops);
    Predict_16x8 (Y+BpS8,   Y+BpS8   +Fwd_CoLoc, Tmp[2], Ops);
    Predict_16x8 (Y+16,     Y+16     +Fwd_CoLoc, Tmp[3], Ops);
    Predict_16x8 (Y+16+BpS8,Y+16+BpS8+Fwd_CoLoc, Tmp[3], Ops);
  }
  else {
    SKL_BYTE * Y = Y1;
    Predict_16x16_QP(Y,   Y   +Fwd_CoLoc, Tmp[0], Ops);
    Predict_16x16_QP(Y+16,Y+16+Fwd_CoLoc, Tmp[1], Ops);

    Y += 2*BpS8;
    Predict_16x16_QP(Y,   Y   +Fwd_CoLoc, Tmp[2], Ops);
    Predict_16x16_QP(Y+16,Y+16+Fwd_CoLoc, Tmp[3], Ops);
  }

  SKL_MV uv_MV;
  Derive_uv_MV_From_4MV(uv_MV, &Tmp[0], &Tmp[2]);

  const int Halves = (uv_MV[0]&1) | ((uv_MV[1]&1)<<1);
  const int Off = Fwd_CoLoc + (uv_MV[1]>>1)*BpS + (uv_MV[0]>>1);
  Ops->HP_16x8[Halves](U,      U     +Off, BpS);
  Ops->HP_16x8[Halves](U+BpS8, U+BpS8+Off, BpS);
  Ops->HP_16x8[Halves](V,      V     +Off, BpS);
  Ops->HP_16x8[Halves](V+BpS8, V+BpS8+Off, BpS);
}

#undef SCALE_UP_MV

//////////////////////////////////////////////////////////

static void Read_Reduced_P_VOP(SKL_FBB * const Bits, const SKL_MP4_I * const VOP)
{
  SKL_ASSERT(VOP->Reduced_VOP>0);

  SKL_MB MB(VOP);
  SKL_INT16 Base[7*64+SKL_ALIGN];
  SKL_INT16 * const In = (SKL_INT16*)SKL_ALIGN_PTR(Base, SKL_ALIGN);

  while(MB.y<VOP->MB_H)
  {
    MB.Init_Scanline(VOP, 0);
    const SKL_MV *Left_Predictor = MB.MVs - 1;

    while(MB.x<VOP->MB_W)
    {
      if (Bits->Get_Bits(1)) // not coded
      {
        SKL_ASSERT(!MB.MC_Sel);   // no Reduced_VOP for GMC
        MB.MB_Type = SKL_MB_SKIPPED;
        MB.Predict_Reduced_With_0MV();
        MB.Store_Zero_MV();          
        MB.Set_Not_Intra();
        Left_Predictor = &MB.MVs[1];        
        // no post-filter for skipped macroblock
      }
      else
      {
        MB.Decode_Inter_Infos(Bits, Left_Predictor);
        SKL_ASSERT(MB.MC_Sel==0); // no reduced VOP for GMC

        if (MB.MB_Type >= SKL_MB_INTRA)  {  /* INTRA or INTRA_Q */
          MB.Decode_Intra_Blocks(Bits, In, VOP);
          MB.Copy_16To8_Upsampled(In+1*64);
          MB.Store_Zero_MV();
          Left_Predictor = &MB.MVs[1];
        }
        else
        {
          MB.Set_Not_Intra();
          if (MB.MB_Type == SKL_MB_INTER4V)
          {
            MB.Predict_Reduced_With_4MV(MB.MVs, MB.MVs2);
            Left_Predictor = &MB.MVs[1];
          }
          else   /*  INTER or INTER_Q */
          {
            if (MB.Field_Pred)
            {                
                // Impl: we don't multiply the final field 
                // vectors by 2 (cf. Store_16x8_MV())
              MB.Predict_Reduced_Fields(MB.MVs, MB.Field_Dir);
              MB.Store_16x8_MV(&MB.MVs2[0], &MB.MVs[0]); // field MV mode
              Left_Predictor = &MB.MVs2[1]; // wow!
            }
            else
            {
              MB.Predict_Reduced_With_1MV(MB.MVs[0]);
              MB.Store_16x16_MV();          // 16x16 mode
              Left_Predictor = &MB.MVs[1];
            }
          }

          MB.Decode_Inter_Blocks(Bits, In, VOP);
          MB.Add_16To8_Upsampled(In + 1*64);
        }
        Post_Filter(&MB);
      }
      MB.Store_Map_Infos();
      MB.Expand_Reduced();

      if (!MB.Resync || !MB.Resync_Marker(Bits))
        MB.Next_Reduced();

      if (VOP->Debug_Level==5) {
        if (MB.MB_Type==SKL_MB_SKIPPED) printf( "s" ); 
        else if (MB.Field_Pred==1) printf( "=" );
        else if (MB.MB_Type==SKL_MB_INTER4V) printf( "4" );
        else printf( "%c", ".-="[1+MB.Field_DCT] );
        if (MB.x==VOP->MB_W)    printf( "\n" );
      }
    }

    if (VOP->Debug_Level==2) VOP->Dump_Line(0, &MB);
    if (MB.y>0 && VOP->Slicer) VOP->Slicer(VOP->Cur, (MB.y-2)*16, 32, VOP->Slicer_Data);
    MB.y += 2;
  }
  if (VOP->Debug_Level==1)  VOP->Dump_MVs(VOP->Cur, 2);
  if (MB.y>0 && VOP->Slicer) VOP->Slicer(VOP->Cur, (MB.y-2)*16, 32, VOP->Slicer_Data);
}



//////////////////////////////////////////////////////////
// entry point

void SKL_MP4_I::Read_Reduced_VOP(SKL_FBB * const Bits) const
{
  SKL_ASSERT(Reduced_VOP==1 && Coding!=B_VOP && Coding!=S_VOP);
  if      (Coding==I_VOP) Read_Reduced_I_VOP(Bits, this);
  else /* P/S-VOP */      Read_Reduced_P_VOP(Bits, this);
}

//////////////////////////////////////////////////////////
//
//  Encoding
//
//////////////////////////////////////////////////////////

void SKL_MB_ENC::Copy_8To16_Downsampled(SKL_INT16 Out[6*64]) const
{
  if (Field_DCT<=0) {
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+0*64, Y1,           BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+1*64, Y1+16,        BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+2*64, Y1+16*BpS,    BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+3*64, Y1+16*BpS+16, BpS);
  }
  else {
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+0*64, Y1,        2*BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+1*64, Y1+16,     2*BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+2*64, Y1+BpS,    2*BpS);
    VOL->MB_Ops.Filter_18x18_To_8x8(Out+3*64, Y1+BpS+16, 2*BpS);
  }
  VOL->MB_Ops.Filter_18x18_To_8x8(Out+4*64, U, BpS);
  VOL->MB_Ops.Filter_18x18_To_8x8(Out+5*64, V, BpS);
}

void SKL_MB_ENC::Diff_8To16_Downsampled(SKL_INT16 Out[6*64]) const
{
  if (Field_DCT<=0) {
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+0*64, Y1,           BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+1*64, Y1+16,        BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+2*64, Y1+16*BpS,    BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+3*64, Y1+16*BpS+16, BpS);
  }
  else {
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+0*64, Y1,        2*BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+1*64, Y1+16,     2*BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+2*64, Y1+BpS,    2*BpS);
    VOL->MB_Ops.Filter_Diff_18x18_To_8x8(Out+3*64, Y1+BpS+16, 2*BpS);
  }
  VOL->MB_Ops.Filter_Diff_18x18_To_8x8( Out+4*64, U, BpS);
  VOL->MB_Ops.Filter_Diff_18x18_To_8x8( Out+5*64, V, BpS);
}

//////////////////////////////////////////////////////////  

void SKL_MB_ENC::Decimate_Reduced_Intra(SKL_INT16 Out[12*64]) const
{
  Copy_8To16_Downsampled(Out+6*64);  // import
  SKL_INT16 *C = Out;                // Decimate
  const SKL_MP4_ENC_I * const Vol = (const SKL_MP4_ENC_I *)VOL;
  for(int blk=0; blk<6; ++blk) {
    const int DC_Q = SKL_MP4_I::DC_Scales[(blk<4)][Quant-1];
    Vol->Decimate_Intra(C, C+6*64, Quant, DC_Q);
    C += 64;
  }
  Copy_16To8_Upsampled(Out+6*64);    // transfer back decimated data
}

//////////////////////////////////////////////////////////

void SKL_MP4_ENC_I::Write_Reduced_I_VOP(SKL_FBB * const Bits)
{
  SKL_INT16 Base[12*64+SKL_ALIGN];
  SKL_INT16 * const In = (SKL_INT16*)SKL_ALIGN_PTR(Base, SKL_ALIGN);

  SKL_MB_ENC MB(this);
  while(MB.y<MB_H)
  {
    MB.Init_Scanline(this, 0);
    while(MB.x<MB_W)
    {
      MB.MB_Type = SKL_MB_INTRA;
      MB.Set_Final_Params();
      SKL_ASSERT(MB.MB_Type == SKL_MB_INTRA);
      MB.Decimate_Reduced_Intra(In);
      MB.Encode_Intra(Bits, In, 1);
      Post_Filter(&MB);
      MB.Expand_Reduced();
      MB.Next_Reduced();
    }
    if (Debug_Level==2) Dump_Line(0, &MB);
    if (MB.y>0 && Slicer) Slicer(Cur, (MB.y-2)*16, 32, Slicer_Data);
    MB.y+=2;
  }
  if (MB.y>0 && Slicer) Slicer(Cur, (MB.y-2)*16, 32, Slicer_Data);

  Texture_Bits = MB.Get_Texture_Bits();
  MV_Bits = MB.Get_MV_Bits();
}

//////////////////////////////////////////////////////////

/*
#define SCALE_DOWN(V)   \
  (V)[0][0] = ( (V)[0][0] + (V)[2][0] + (V)[2*MV_Stride][0] + (V)[2*MV_Stride+2][0] ) >> 3; \
  (V)[0][1] = ( (V)[0][1] + (V)[2][1] + (V)[2*MV_Stride][1] + (V)[2*MV_Stride+2][1] ) >> 3
*/
#define SCALE_DOWN(V)   (V)[0][0] /= 2; (V)[0][1] /= 2

static inline int Find_Last(const SKL_INT16 C[6*64], const int *Zigzag, int i)
{
  while(i>=0)
    if (C[Zigzag[i]])
      return i;
    else i--;
  return -1;
}

void SKL_MB_ENC::Decimate_Reduced_Inter(SKL_INT16 Out[12*64])
{
  if (MB_Type==SKL_MB_SKIPPED) {
    Predict_Reduced_With_0MV();
    Store_Zero_MV();
    return;
  }

    // Fwd predict

  int Skippable = (dQuant==0) && SKL_IS_ZERO_MV(MVs[0]);
  Copy_8To16_Downsampled(Out+6*64);    // save original data
  if (Field_Pred) {                    // form predictions
    Predict_Reduced_Fields(MVs, Field_Dir);
    Store_16x8_MV(&MVs2[0], &MVs[0]);
    SKL_COPY_MV(MVs[1], MVs2[0]);      // update left predictor
    if (Skippable) Skippable &= SKL_IS_ZERO_MV(MVs2[0]);
  }
  else {
    if (MB_Type!=SKL_MB_INTER4V) {
      Predict_Reduced_With_1MV(MVs[0]);
      Store_16x16_MV();
    }
    else {
      Predict_Reduced_With_4MV(&MVs[0], &MVs2[0]);
      if (Skippable) {
        Skippable &= SKL_IS_ZERO_MV(MVs [1]);
        Skippable &= SKL_IS_ZERO_MV(MVs2[0]);
        Skippable &= SKL_IS_ZERO_MV(MVs2[1]);
      }
    }
  }

  Diff_8To16_Downsampled(Out+6*64);    // diff original/predicted data

  SKL_INT16 *C = Out;                  // Decimate and set Cbp
  Cbp = 0x00;
  const SKL_MP4_ENC_I * const Vol = (const SKL_MP4_ENC_I *)VOL;
  for(int blk=0; blk<6; ++blk)
  {
    const int SAV = Vol->Decimate_Inter(C, C+6*64,Quant);
    if (SAV>0) {
      Last[blk] = Find_Last(C, SKL_MP4_I::Scan_Order[0], 63);
      SKL_ASSERT(Last[blk]>=0);
      Cbp |= 1<<(5-blk);
    }
    else Last[blk] = -1;
    C += 64;
  }


  if (Skippable && Cbp==0)
    MB_Type = SKL_MB_SKIPPED;          // won't be coded (don't transfer back data)
  else
    Add_16To8_Upsampled(Out+6*64);     // transfer back decimated delta data
}

void SKL_MP4_ENC_I::Write_Reduced_P_VOP(SKL_FBB * const Bits)
{
  SKL_INT16 Base[12*64+SKL_ALIGN];
  SKL_INT16 * const In = (SKL_INT16*)SKL_ALIGN_PTR(Base, SKL_ALIGN);

  SKL_MB_ENC MB(this);
  while(MB.y<MB_H)
  {
    MB.Init_Scanline(this, 0);
    while(MB.x<MB_W)
    {
      MB.Set_Type();
      SKL_ASSERT(MB.MB_Type!=SKL_MB_INTER4V);
      if (MB.MB_Type!=SKL_MB_SKIPPED) {
        SCALE_DOWN(MB.MVs);
        MB.Set_Final_Params();
      }
      if (MB.MB_Type==SKL_MB_INTRA) MB.Decimate_Reduced_Intra(In);
      else                          MB.Decimate_Reduced_Inter(In);

      if (MB.MB_Type==SKL_MB_SKIPPED)
      {
        Bits->Put_Bits( 1, 1 );          // not_coded
        MB.Set_Not_Intra();
      }
      else {
        Bits->Put_Bits( 0, 1 );          // coded
        if (MB.MB_Type>=SKL_MB_INTRA) MB.Encode_Intra(Bits, In, 0);
        else                          MB.Encode_Inter(Bits, In, Fwd_Code);
        Post_Filter(&MB);
      }
      MB.Store_Map_Infos();
      MB.Expand_Reduced();
      MB.Next_Reduced();
    }
    if (Debug_Level==2) Dump_Line(0, &MB);
    if (MB.y>0 && Slicer) Slicer(Cur, (MB.y-2)*16, 32, Slicer_Data);
    MB.y += 2;
  }
  if (MB.y>0 && Slicer) Slicer(Cur, (MB.y-2)*16, 32, Slicer_Data);

  Texture_Bits = MB.Get_Texture_Bits();
  MV_Bits = MB.Get_MV_Bits();

  if (Debug_Level==1)  Dump_MVs(Cur, 2); // will trash the encoded frame
}

#undef SCALE_DOWN

//////////////////////////////////////////////////////////