skl_mb_c.cpp

mpeg4编解码器

/********************************************************
 * Some code. Copyright (C) 2003 by Pascal Massimino.   *
 * All Rights Reserved.      (http://skal.planet-d.net) *
 * For Educational/Academic use ONLY. See 'LICENSE.TXT'.*
 ********************************************************/
/*
 *  skl_mb_c.cpp
 *
 *  Macro-block processing
 *
 ********************************************************/

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

#include "skl.h"
#include "skl_syst/skl_dsp.h"

extern "C" {

void Skl_Init_MB_Clip() {}

#define COPY(d,s)    (d) = SKL_DSP_CLIP((s))  // <0 ? 0 : (s)>255 ? 255 : (s)
#define ADD(d,s)     COPY( (d), (s)+(d) )

//////////////////////////////////////////////////////////
// 8b <-> 8b transfer
//////////////////////////////////////////////////////////

extern "C" SKL_MB_FUNCS Skl_MB_Funcs_Add_C;
extern "C" SKL_MB_FUNCS Skl_MB_Funcs_Copy_C;


#define PRELUDE(H,S)          \
  for(int j=(H); j>0; j--) {    \
    for(int i=-(S); i<0; ++i) {

#define EPILOG                \
    }                         \
    Dst += BpS; Src += BpS;   \
  }
#define MIX(x)  Dst[(x)] = (Dst[(x)]+v +1)>>1

#define MB_FUNC(Name) void Name(SKL_BYTE *Dst, const SKL_BYTE *Src, const int BpS)
#define MB_FUNC_QP(Name) void Name(SKL_BYTE *Dst, const SKL_BYTE *Src, \
                                   SKL_BYTE *Tmp_X, SKL_BYTE *Tmp_Y,  \
                                   const int BpS)

//////////////////////////////////////////////////////////
//
//  Half-pixel add
//
//////////////////////////////////////////////////////////

  // 16x8 Half-Pixel additive ops

static MB_FUNC(Skl_Add_16x8_FF_C) {
  PRELUDE(8,16)
    const SKL_UINT32 v = Src[16+i];
    MIX(16+i);
  EPILOG
}

  // 8x8 Half-Pixel additive ops

static MB_FUNC(Skl_Add_8x8_FF_C) { 
  PRELUDE(8,8)
    const SKL_UINT32 v = Src[8+i]; MIX(8+i); 
  EPILOG
}

  // 8x4 Half-Pixel additive ops

static MB_FUNC(Skl_Add_8x4_FF_C) { 
  PRELUDE(4,8) 
    const SKL_UINT32 v = Src[8+i]; MIX(8+i); 
  EPILOG
}

static MB_FUNC(Skl_Add_16x8_FH_Rnd0_C) {
  PRELUDE(8,16) 
    const SKL_UINT32 v = (Src[16+i] + Src[16+1+i] + 1)>>1;
    MIX(16+i);
  EPILOG
}
static MB_FUNC(Skl_Add_16x8_HF_Rnd0_C) {
  PRELUDE(8,16) 
    const SKL_UINT32 v = (Src[16+i] + Src[16+BpS+i] + 1)>>1;
    MIX(16+i);
  EPILOG
}
static MB_FUNC(Skl_Add_16x8_HH_Rnd0_C) {
  PRELUDE(8,16) 
    const SKL_UINT32 v = (  Src[16+i] + Src[16+1+i] 
                        + Src[16+BpS+i] + Src[16+1+BpS+i]+ 2) >> 2;
    MIX(16+i);
  EPILOG
}

static MB_FUNC(Skl_Add_8x8_FH_Rnd0_C) {
  PRELUDE(8,8) 
    const SKL_UINT32 v = (Src[8+i] + Src[8+1+i] + 1)>>1; MIX(8+i);
  EPILOG
}
static MB_FUNC(Skl_Add_8x8_HF_Rnd0_C) {
  PRELUDE(8,8) 
    const SKL_UINT32 v = (Src[8+i] + Src[8+BpS+i] + 1)>>1; MIX(8+i);
  EPILOG
}
static MB_FUNC(Skl_Add_8x8_HH_Rnd0_C) {
  PRELUDE(8,8)
    const SKL_UINT32 v = (Src[8+i] + Src[8+1+i] 
                        + Src[8+BpS+i] + Src[8+1+BpS+i]+ 2) >> 2;
    MIX(8+i);
  EPILOG
}

static MB_FUNC(Skl_Add_8x4_FH_Rnd0_C) {
  PRELUDE(4,8) 
    const SKL_UINT32 v = (Src[8+i] + Src[8+1+i] + 1)>>1; MIX(8+i);
  EPILOG
}
static MB_FUNC(Skl_Add_8x4_HF_Rnd0_C) {
  PRELUDE(4,8) 
    const SKL_UINT32 v = (Src[8+i] + Src[8+BpS+i] + 1)>>1; MIX(8+i);
  EPILOG
}
static MB_FUNC(Skl_Add_8x4_HH_Rnd0_C) {
  PRELUDE(4,8)
    const SKL_UINT32 v = (  Src[8+i] + Src[8+1+i] 
                            + Src[8+BpS+i] + Src[8+1+BpS+i]+ 2) >> 2;
    MIX(8+i);
  EPILOG
}


//////////////////////////////////////////////////////////
//
//  Half-pixel copy
//
//////////////////////////////////////////////////////////

  // 16x8 Half-Pixel copy ops

static MB_FUNC(Skl_Copy_16x8_FF_C) {
  for(int j=8; j>0; j--) {
    memcpy(Dst, Src, 16*sizeof(*Dst));
    Dst += BpS;
    Src += BpS;
  }
}
static MB_FUNC(Skl_Copy_16x8_FH_Rnd1_C) {
  PRELUDE(8,16)
      Dst[16+i] = (Src[16+i] + Src[16+1+i]) >>1;
  EPILOG
}
static MB_FUNC(Skl_Copy_16x8_HF_Rnd1_C) {
    PRELUDE(8,16)
      Dst[16+i] = (Src[16+i] + Src[16+BpS+i]) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_16x8_HH_Rnd1_C) {
    PRELUDE(8,16) 
      Dst[16+i] = (Src[16+i] + Src[16+1+i] + 
                   Src[16+BpS+i] + Src[16+1+BpS+i] + 1) >> 2;
    EPILOG
}

  // 8x8 Half-Pixel copy ops

static MB_FUNC(Skl_Copy_8x8_FF_C) {
  for(int j=8; j>0; j--) {
    memcpy(Dst, Src, 8*sizeof(*Dst));
    Dst += BpS;
    Src += BpS;
  }
}
static MB_FUNC(Skl_Copy_8x8_FH_Rnd1_C) {
    PRELUDE(8,8)
      Dst[8+i] = (Src[8+i] + Src[8+1+i]) >>1;
    EPILOG
}

static MB_FUNC(Skl_Copy_8x8_HF_Rnd1_C) {
    PRELUDE(8,8)
      Dst[8+i] = (Src[8+i] + Src[8+BpS+i]) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x8_HH_Rnd1_C) {
    PRELUDE(8,8)
      Dst[8+i] = ( Src[8+i] + Src[8+1+i] 
                  + Src[8+BpS+i] + Src[8+1+BpS+i]+ 1) >> 2;
    EPILOG
}

  // 8x4 Half-Pixel copy ops

static MB_FUNC(Skl_Copy_8x4_FF_C) {
  for(int j=4; j>0; j--) {
    memcpy(Dst, Src, 8*sizeof(*Dst));
    Dst += BpS;
    Src += BpS;
  }
}
static MB_FUNC(Skl_Copy_8x4_FH_Rnd1_C) {
    PRELUDE(4,8)
      Dst[8+i] = (Src[8+i] + Src[8+1+i]) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x4_HF_Rnd1_C) {
    PRELUDE(4,8)
      Dst[8+i] = (Src[8+i] + Src[8+BpS+i]) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x4_HH_Rnd1_C) {
    PRELUDE(4,8)
      Dst[8+i] = ( Src[8+i] + Src[8+1+i] 
                  + Src[8+BpS+i] + Src[8+1+BpS+i]+ 1) >> 2;
    EPILOG
}


    // the same, with rounding = 0


static MB_FUNC(Skl_Copy_16x8_FH_Rnd0_C) {
    PRELUDE(8,16)
      Dst[16+i] = (Src[16+i] + Src[16+1+i]+1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_16x8_HF_Rnd0_C) {
    PRELUDE(8,16) 
      Dst[16+i] = (Src[16+i] + Src[16+BpS+i]+1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_16x8_HH_Rnd0_C) {
    PRELUDE(8,16) 
      Dst[16+i] = (Src[16+i] + Src[16+1+i] + 
                   Src[16+BpS+i] + Src[16+1+BpS+i] + 2) >> 2;
    EPILOG
}

static MB_FUNC(Skl_Copy_8x8_FH_Rnd0_C) {
    PRELUDE(8,8)
      Dst[8+i] = (Src[8+i] + Src[8+1+i] + 1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x8_HF_Rnd0_C) {
    PRELUDE(8,8)
      Dst[8+i] = (Src[8+i] + Src[8+BpS+i] + 1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x8_HH_Rnd0_C) {
    PRELUDE(8,8)
      Dst[8+i] = ( Src[8+i] + Src[8+1+i] 
                  + Src[8+BpS+i] + Src[8+1+BpS+i]+ 2) >> 2;
    EPILOG
}

static MB_FUNC(Skl_Copy_8x4_FH_Rnd0_C) {
    PRELUDE(4,8)
      Dst[8+i] = (Src[8+i] + Src[8+1+i] + 1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x4_HF_Rnd0_C) {
    PRELUDE(4,8)
      Dst[8+i] = (Src[8+i] + Src[8+BpS+i] + 1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_8x4_HH_Rnd0_C) {
    PRELUDE(4,8)
      Dst[8+i] = ( Src[8+i] + Src[8+1+i] 
                  + Src[8+BpS+i] + Src[8+1+BpS+i]+ 2) >> 2;
    EPILOG
}

    // HV Filter for 16x16 block

static MB_FUNC(Skl_Copy_16x16_FH_Rnd0_C) {
    PRELUDE(16,16)
      Dst[16+i] = (Src[16+i] + Src[16+1+i]+1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_16x16_HF_Rnd0_C) {
    PRELUDE(16,16) 
      Dst[16+i] = (Src[16+i] + Src[16+BpS+i]+1) >>1;
    EPILOG
}
static MB_FUNC(Skl_Copy_16x16_HH_Rnd0_C) {
    PRELUDE(16,16) 
      Dst[16+i] = (Src[16+i] + Src[16+1+i] + 
                   Src[16+BpS+i] + Src[16+1+BpS+i] + 2) >> 2;
    EPILOG
}

const SKL_HV_FILTER Skl_Filter_2_C = { 
  Skl_Copy_16x16_FH_Rnd0_C, Skl_Copy_16x16_HF_Rnd0_C, Skl_Copy_16x16_HH_Rnd0_C
};

//////////////////////////////////////////////////////////
//
//  Half-pixel SAD
//
//////////////////////////////////////////////////////////

#define ABS(x) ((x)<0 ? -(x) : (x))

void Skl_SAD_HP_16x16_Rnd0_C(const SKL_BYTE *Cur, const SKL_BYTE *Src,
                             int BpS, SKL_UINT32 Sad[3])
{
  SKL_UINT32 Sad_H = 0, Sad_V = 0, Sad_HV = 0;
  for(int j=16; j>0; j--) {
    for(int i=-16; i<0; i++) {
      SKL_INT32 v1 = Src[16+i]     + Src[16+i+1]     + 1;
      SKL_INT32 v2 = Src[16+i+BpS] + Src[16+i+1+BpS] + 1 + v1;
      v1 = (v1>>1) - Cur[16+i];
      v2 = (v2>>2) - Cur[16+i];
      Sad_H  += ABS(v1);
      Sad_HV += ABS(v2);
      SKL_INT32 v3 = Src[16+i+BpS] + Src[16+i]     + 1;
      v3 = (v3>>1) - Cur[16+i];
      Sad_V  += ABS(v3);
    }
    Cur += BpS;
    Src += BpS;
  }
  Sad[0] = Sad_H;
  Sad[1] = Sad_V;
  Sad[2] = Sad_HV;
}

void Skl_SAD_HP_16x16_Rnd1_C(const SKL_BYTE *Cur, const SKL_BYTE *Src,
                             int BpS, SKL_UINT32 Sad[3])
{
  SKL_UINT32 Sad_H = 0, Sad_V = 0, Sad_HV = 0;
  for(int j=16; j>0; j--) {
    for(int i=-16; i<0; i++) {
      SKL_INT32 v1 = Src[16+i]     + Src[16+i+1];
      SKL_INT32 v2 = Src[16+i+BpS] + Src[16+i+1+BpS] + 1 + v1;
      v1 = (v1>>1) - Cur[16+i];
      v2 = (v2>>2) - Cur[16+i]; 
      Sad_H  += ABS(v1);
      Sad_HV += ABS(v2);
      SKL_INT32 v3 = Src[16+i+BpS] + Src[16+i];
      v3 = (v3>>1) - Cur[16+i];
      Sad_V  += ABS(v3);
    }
    Cur += BpS;
    Src += BpS;
  }
  Sad[0] = Sad_H;
  Sad[1] = Sad_V;
  Sad[2] = Sad_HV;
}

void Skl_SAD_HP_8x8_Rnd0_C(const SKL_BYTE *Cur, const SKL_BYTE *Src,
                           int BpS, SKL_UINT32 Sad[3])