mcomp_sgl_simple.cc

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

          else if (v1)  val1=(rp1[i]+rp1b[i]+1)>>1;
          else          val1= rp1[i];

          int val2;
          if (v2 && h2) val2=(rp2[i]+rp2[i+1]+rp2b[i]+rp2b[i+1]+2)>>2;
          else if (h2)  val2=(rp2[i]+rp2[i+1]+1)>>1;
          else if (v2)  val2=(rp2[i]+rp2b[i]+1)>>1;
          else          val2= rp2[i];

          dp[ i]=(val1+val2+2)>>1;
        }
    }
}

static void MC16xXX_420_DBL_xxxx_Chroma(MotionCompensation_Common::PredData* p,
                                        bool h1,bool v1,bool h2,bool v2)
{
  const int y0     = p->y0 >>1;
  const int x0     = p->x0 >>1;
  const int yend   = y0 + p->blkheight_chr;
  const int x1     = x0 + ((p->pred1.h/2)>>1);
  const int x2     = x0 + ((p->pred2.h/2)>>1);
  const int yoffs1 = ((p->pred1.v/2)>>1);
  const int yoffs2 = ((p->pred2.v/2)>>1);

  for (int y=y0;y<yend;y++)
    {
      const Pixel* rp1 = &p->pred1.cb[y+yoffs1  ][x1];
      const Pixel* rp1b= &p->pred1.cb[y+yoffs1+1][x1];
      const Pixel* rp2 = &p->pred2.cb[y+yoffs2  ][x2];
      const Pixel* rp2b= &p->pred2.cb[y+yoffs2+1][x2];
            Pixel* dp  = &p->current.cb[y][x0];

      for (int i=0;i<8;i++)
        {
          int val1;
          if (v1 && h1) val1=(rp1[i]+rp1[i+1]+rp1b[i]+rp1b[i+1]+2)>>2;
          else if (h1)  val1=(rp1[i]+rp1[i+1]+1)>>1;
          else if (v1)  val1=(rp1[i]+rp1b[i]+1)>>1;
          else          val1= rp1[i];
      
          int val2;
          if (v2 && h2) val2=(rp2[i]+rp2[i+1]+rp2b[i]+rp2b[i+1]+2)>>2;
          else if (h2)  val2=(rp2[i]+rp2[i+1]+1)>>1;
          else if (v2)  val2=(rp2[i]+rp2b[i]+1)>>1;
          else          val2= rp2[i];

          dp[ i]=(val1+val2+2)>>1;
        }


      rp1 = &p->pred1.cr[y+yoffs1  ][x1];
      rp1b= &p->pred1.cr[y+yoffs1+1][x1];
      rp2 = &p->pred2.cr[y+yoffs2  ][x2];
      rp2b= &p->pred2.cr[y+yoffs2+1][x2];
      dp  = &p->current.cr[y][x0];

      for (int i=0;i<8;i++)
        {
          int val1;
          if (v1 && h1) val1=(rp1[i]+rp1[i+1]+rp1b[i]+rp1b[i+1]+2)>>2;
          else if (h1)  val1=(rp1[i]+rp1[i+1]+1)>>1;
          else if (v1)  val1=(rp1[i]+rp1b[i]+1)>>1;
          else          val1= rp1[i];
      
          int val2;
          if (v2 && h2) val2=(rp2[i]+rp2[i+1]+rp2b[i]+rp2b[i+1]+2)>>2;
          else if (h2)  val2=(rp2[i]+rp2[i+1]+1)>>1;
          else if (v2)  val2=(rp2[i]+rp2b[i]+1)>>1;
          else          val2= rp2[i];

          dp[ i]=(val1+val2+2)>>1;
        }
    }
}
#endif


/// #endif


#if 0
static void LumaFF(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->lastimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      for (int x=0;x<16;x++)
        {
          *dp++ = *sp++;
        }
      sp += mc->bytesperline_lum-16;
      dp += mc->bytesperline_lum-16;
    }
}
#endif

static void LumaHF(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->lastimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      int v1 = *sp;

      for (int x=0;x<8;x++)
        {
          sp++;
          int v2 = *sp;
          *dp++ = (v1 + v2 + 1)>>1;

          sp++;
          v1 = *sp;
          *dp++ = (v1 + v2 + 1)>>1;
        }
      sp += mc->bytesperline_lum-16;
      dp += mc->bytesperline_lum-16;
    }
}

static void LumaFH(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->lastimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      for (int x=0;x<16;x++)
        {
          *dp++ = (*sp + sp[mc->bytesperline_lum] + 1)>>1;
          sp++;
        }
      sp += mc->bytesperline_lum-16;
      dp += mc->bytesperline_lum-16;
    }
}

static void LumaHH(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->lastimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      int v1 = *sp + sp[mc->bytesperline_lum];

      for (int x=0;x<8;x++)
        {
          sp++;
          int v2 = *sp + sp[mc->bytesperline_lum];
          *dp++ = (v1 + v2 +2)>>2;

          sp++;
          v1 = *sp + sp[mc->bytesperline_lum];
          *dp++ = (v1 + v2 +2)>>2;
        }
      sp += mc->bytesperline_lum-16;
      dp += mc->bytesperline_lum-16;
    }
}

static void ChromaFF(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp = mc->lastimg.cr;
        Pixel* dp = mc->currimg.cr;

  int h = mc->blkheight_chr;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = *sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }


  sp = mc->lastimg.cb;
  dp = mc->currimg.cb;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = *sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }
}

static void ChromaFH(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp = mc->lastimg.cr;
        Pixel* dp = mc->currimg.cr;

  int h = mc->blkheight_chr;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = (*sp + sp[mc->bytesperline_chr]+1)>>1; sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }


  sp = mc->lastimg.cb;
  dp = mc->currimg.cb;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = (*sp + sp[mc->bytesperline_chr]+1)>>1; sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }
}

static void ChromaHF(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp = mc->lastimg.cr;
        Pixel* dp = mc->currimg.cr;

  int h = mc->blkheight_chr;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = (*sp + sp[1]+1)>>1; sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }


  sp = mc->lastimg.cb;
  dp = mc->currimg.cb;

  for (int y=0;y<h;y++)
    {
      for (int x=0;x<8;x++)
        {
          *dp++ = (*sp + sp[1]+1)>>1; sp++;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }
}

static void ChromaHH(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp = mc->lastimg.cr;
        Pixel* dp = mc->currimg.cr;

  int h = mc->blkheight_chr;

  for (int y=0;y<h;y++)
    {
      int v1 = *sp + sp[mc->bytesperline_chr];

      for (int x=0;x<8;x++)
        {
          sp++;
          int v2 = *sp + sp[mc->bytesperline_chr];
          *dp++ = (v1 + v2+2)>>2;
          v1 = v2;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }


  sp = mc->lastimg.cb;
  dp = mc->currimg.cb;

  for (int y=0;y<h;y++)
    {
      int v1 = *sp + sp[mc->bytesperline_chr];

      for (int x=0;x<8;x++)
        {
          sp++;
          int v2 = *sp + sp[mc->bytesperline_chr];
          *dp++ = (v1 + v2+2)>>2;
          v1 = v2;
        }
      sp += mc->bytesperline_chr-8;
      dp += mc->bytesperline_chr-8;
    }
}





static void LumaFFadd(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->nextimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      for (int x=0;x<16;x++)
        {
          *dp = (*dp + *sp + 1)>>1;
          dp++;
          sp++;
        }
      sp += mc->bytesperline_lum-16;
      dp += mc->bytesperline_lum-16;
    }
}

static void LumaHFadd(MotionCompensation_SglMB::MCData* mc)
{
  const Pixel* sp;
        Pixel* dp;

  sp = mc->nextimg.y;
  dp = mc->currimg.y;

  for (int y=0;y<mc->blkheight;y++)
    {
      for (int x=0;x<16;x++)
        {
          *dp = (*dp + ((*sp + sp[1] + 1)>>1) + 1)>>1;
          dp++;
          sp++;