countbit.c

H.263的压缩算法

            if (x_vec < -32)
              x_vec += 64;
            else if (x_vec > 31)
              x_vec -= 64;

            if (y_vec < -32)
              y_vec += 64;
            else if (y_vec > 31)
              y_vec -= 64;
 
            if (x_vecb < -32)
              x_vecb += 64;
            else if (x_vecb > 31)
              x_vecb -= 64;

            if (y_vecb < -32)
              y_vecb += 64;
            else if (y_vecb > 31)
              y_vecb -= 64;
          } else
          {
            if (pmv0 < -31 && x_vec < -63)
              x_vec += 64;
            else if (pmv0 > 32 && x_vec > 63)
              x_vec -= 64;

            if (pmv1 < -31 && y_vec < -63)
              y_vec += 64;
            else if (pmv1 > 32 && y_vec > 63)
              y_vec -= 64;
 
            if (pmv0b < -31 && x_vecb < -63)
              x_vecb += 64;
            else if (pmv0b > 32 && x_vecb > 63)
              x_vecb -= 64;
  
            if (pmv1b < -31 && y_vecb < -63)
              y_vecb += 64;
            else if (pmv1b > 32 && y_vecb > 63)
              y_vecb -= 64;
          }

          if (trace)
          {
            fprintf (tf, "Vectors:\n");
          }
          if (x_vec < 0)
            x_vec += 64;
          if (y_vec < 0)
            y_vec += 64;
          if (x_vecb < 0)
            x_vecb += 64;
          if (y_vecb < 0)
            y_vecb += 64;

          bits->vec += put_mv (x_vec);
          bits->vec += put_mv (y_vec);
          bits->vec += put_mv (x_vecb);
          bits->vec += put_mv (y_vecb);
 
          if (trace)
          {
            if (x_vec > 31)
              x_vec -= 64;
            if (y_vec > 31)
              y_vec -= 64;
            if (x_vecb > 31)
              x_vecb -= 64;
            if (y_vecb > 31)
              y_vecb -= 64;
            fprintf (tf, "Forward (x,y) = (%d,%d) - ",
                     (2 * MV[block][y][x]->x + MV[block][y][x]->x_half),
                     (2 * MV[block][y][x]->y + MV[block][y][x]->y_half));
            fprintf (tf, "(Px,Py) = (%d,%d)\n", pmv0, pmv1);
            fprintf (tf, "(x_diff,y_diff) = (%d,%d)\n", x_vec, y_vec);
            fprintf (tf, "Backward (x,y) = (%d,%d) - ",
                     (2 * MV[blockb][y][x]->x + MV[blockb][y][x]->x_half),
                     (2 * MV[blockb][y][x]->y + MV[blockb][y][x]->y_half));
            fprintf (tf, "(Px,Py) = (%d,%d)\n", pmv0b, pmv1b);
            fprintf (tf, "(x_diff,y_diff) = (%d,%d)\n", x_vecb, y_vecb);
          }
        }
        break;

      default:

        fprintf (stderr, "Illegal scalable prediction type in CountBitsVectors (countbit.c)\n");
        exit (-1);
        break;
    }
  }
  /* PB-frames delta vectors */
  if ((pic->PB == PB_FRAMES &&
      (pic->MODB == PBMODE_MVDB || pic->MODB == PBMODE_CBPB_MVDB)) ||
      (pic->PB == IM_PB_FRAMES &&
      (pic->MODB == PBMODE_FRW_PRED || pic->MODB == PBMODE_CBPB_FRW_PRED)))
  {
    if (pic->PB == PB_FRAMES && (pic->MODB == PBMODE_MVDB ||
                                 pic->MODB == PBMODE_CBPB_MVDB))
    {
      /* x_vec and y_vec are the PB-delta vectors */
      x_vec = MV[6][y][x]->x;
      y_vec = MV[6][y][x]->y;
    } else
    {
      /* x_vec and y_vec are the forward motion vectors for B picture in
       * Impreved PB frames mode. */

      if (newgob)
      {
        /* no predictors */
        x_vec = 2 * MV[6][y][x]->x + MV[6][y][x]->x_half;
        y_vec = 2 * MV[6][y][x]->y + MV[6][y][x]->y_half;

      } else
      {

        /* find prediction vectors */
        /* this would work even though the previous macroblock is
         * predicted bidirectionally. In that case the motion vector will
         * be ZERO vector */

        pmv0 = (2 * MV[6][y][x - 1]->x + MV[6][y][x - 1]->x_half);
        pmv1 = (2 * MV[6][y][x - 1]->y + MV[6][y][x - 1]->y_half);

        x_vec = (2 * MV[6][y][x]->x + MV[6][y][x]->x_half) - pmv0;
        y_vec = (2 * MV[6][y][x]->y + MV[6][y][x]->y_half) - pmv1;
      }
    }
    /* When PLUSPTYPE is signalled and Annex D is used, *
     * Reversible motion vector codes are used          */
    if (EPTYPE && long_vectors)
    {
      if (trace)
      {
        if (pic->PB == PB_FRAMES)
          fprintf (tf, "PB delta vectors:\n");
        if (pic->PB == IM_PB_FRAMES)
          fprintf (tf, "PB ,B forward vectors:\n");
      }

      bits->vec += put_rvlc(x_vec);
      bits->vec += put_rvlc(y_vec);

      if (trace)
      {
        fprintf (tf, "(x,y) = (%d,%d) - ",
                 (2 * MV[6][y][x]->x + MV[6][y][x]->x_half),
                 (2 * MV[6][y][x]->y + MV[6][y][x]->y_half));
        fprintf (tf, "(Px,Py) = (%d,%d)\n", pmv0, pmv1);
        fprintf (tf, "(x_diff,y_diff) = (%d,%d)\n", x_vec, y_vec);
      }

      /* prevent start code emulation */
      if (x_vec == 1 && y_vec == 1)
      {
        if (trace)
        {
          fprintf (tf, "Prevent Start Code Emulation bit:\n");
        }
        putbits (1,1);
      }
    }
    else
    {
      if (x_vec < -32)
        x_vec += 64;
      else if (x_vec > 31)
        x_vec -= 64;
      if (y_vec < -32)
        y_vec += 64;
      else if (y_vec > 31)
        y_vec -= 64;

      if (x_vec < 0)
        x_vec += 64;
      if (y_vec < 0)
        y_vec += 64;

      if (trace)
      {
        if (pic->PB == PB_FRAMES)
          fprintf (tf, "PB delta vectors:\n");
        if (pic->PB == IM_PB_FRAMES)
          fprintf (tf, "PB ,B forward vectors:\n");
      }
      bits->vec += put_mv (x_vec);
      bits->vec += put_mv (y_vec);

      if (trace)
      {
        if (x_vec > 31)
          x_vec -= 64;
        if (y_vec > 31)
          y_vec -= 64;
        fprintf (tf, "MVDB (x,y) = (%d,%d)\n", x_vec, y_vec);
      }
    }
  }
  return;
}

void Count_sac_BitsVectors (MotionVector * MV[7][MBR + 1][MBC + 2], Bits * bits,
                          int x, int y, int Mode, int newgob, Pict * pic)
{
  int y_vec, x_vec;
  int pmv0, pmv1;
  int start, stop, block;

  arith_used = 1;
  x++;
  y++;

  if (Mode == MODE_INTER4V || Mode == MODE_INTER4V_Q)
  {
    start = 1;
    stop = 4;
  } else
  {
    start = 0;
    stop = 0;
  }

  for (block = start; block <= stop; block++)
  {

    FindPMV (MV, x, y, &pmv0, &pmv1, block, newgob, 1);

    x_vec = (2 * MV[block][y][x]->x + MV[block][y][x]->x_half) - pmv0;
    y_vec = (2 * MV[block][y][x]->y + MV[block][y][x]->y_half) - pmv1;

    if (!long_vectors)
    {
      if (x_vec < -32)
        x_vec += 64;
      else if (x_vec > 31)
        x_vec -= 64;

      if (y_vec < -32)
        y_vec += 64;
      else if (y_vec > 31)
        y_vec -= 64;
    } else
    {
      if (pmv0 < -31 && x_vec < -63)
        x_vec += 64;
      else if (pmv0 > 32 && x_vec > 63)
        x_vec -= 64;

      if (pmv1 < -31 && y_vec < -63)
        y_vec += 64;
      else if (pmv1 > 32 && y_vec > 63)
        y_vec -= 64;
    }

    if (x_vec < 0)
      x_vec += 64;
    if (y_vec < 0)
      y_vec += 64;

    if (trace)
    {
      fprintf (tf, "Vectors:\n");
    }
    bits->vec += AR_Encode (indexfn (x_vec, mvdtab, 64), cumf_MVD);
    bits->vec += AR_Encode (indexfn (y_vec, mvdtab, 64), cumf_MVD);

    if (trace)
    {
      if (x_vec > 31)
        x_vec -= 64;
      if (y_vec > 31)
        y_vec -= 64;
      fprintf (tf, "(x,y) = (%d,%d) - ",
               (2 * MV[block][y][x]->x + MV[block][y][x]->x_half),
               (2 * MV[block][y][x]->y + MV[block][y][x]->y_half));
      fprintf (tf, "(Px,Py) = (%d,%d)\n", pmv0, pmv1);
      fprintf (tf, "(x_diff,y_diff) = (%d,%d)\n", x_vec, y_vec);
    }
  }

  /* PB-frames delta vectors */
  if ((pic->PB == PB_FRAMES &&
       (pic->MODB == PBMODE_MVDB || pic->MODB == PBMODE_CBPB_MVDB)) ||
      (pic->PB == IM_PB_FRAMES &&
    (pic->MODB == PBMODE_FRW_PRED || pic->MODB == PBMODE_CBPB_FRW_PRED)))
  {
    if (pic->PB == PB_FRAMES && (pic->MODB == PBMODE_MVDB ||
                                 pic->MODB == PBMODE_CBPB_MVDB))
    {
      /* x_vec and y_vec are the PB-delta vectors */
      x_vec = MV[6][y][x]->x;
      y_vec = MV[6][y][x]->y;
    }
    else
    {
      /* x_vec and y_vec are the forward motion vectors for B picture in
       * Improved PB frames mode. */

      if (newgob)
      {
        /* no predictors */
        x_vec = 2 * MV[6][y][x]->x + MV[6][y][x]->x_half;
        y_vec = 2 * MV[6][y][x]->y + MV[6][y][x]->y_half;

      } else
      {
        /* find prediction vectors */
        /* this would work even though the previous macroblock is
         * predicted bidirectionally. In that case the motion vector will
         * be ZERO vector */

        pmv0 = (2 * MV[6][y][x - 1]->x + MV[6][y][x - 1]->x_half);
        pmv1 = (2 * MV[6][y][x - 1]->y + MV[6][y][x - 1]->y_half);

        x_vec = (2 * MV[6][y][x]->x + MV[6][y][x]->x_half) - pmv0;
        y_vec = (2 * MV[6][y][x]->y + MV[6][y][x]->y_half) - pmv1;
      }
    }

    if (x_vec < -32)
      x_vec += 64;
    else if (x_vec > 31)
      x_vec -= 64;
    if (y_vec < -32)
      y_vec += 64;
    else if (y_vec > 31)
      y_vec -= 64;

    if (x_vec < 0)
      x_vec += 64;
    if (y_vec < 0)
      y_vec += 64;

    if (trace)
    {
      if (pic->PB == PB_FRAMES)
        fprintf (tf, "PB delta vectors:\n");
      if (pic->PB == IM_PB_FRAMES)
        fprintf (tf, "PB ,B forward vectors:\n");
    }
    bits->vec += AR_Encode (indexfn (x_vec, mvdtab, 64), cumf_MVD);
    bits->vec += AR_Encode (indexfn (y_vec, mvdtab, 64), cumf_MVD);

    if (trace)
    {
      if (x_vec > 31)
        x_vec -= 64;
      if (y_vec > 31)
        y_vec -= 64;
      fprintf (tf, "MVDB (x,y) = (%d,%d)\n", x_vec, y_vec);
    }
  }
  return;
}

/**********************************************************************
 *
 *	Name:           FindPMV
 *	Description:	counts bits used for MVs and writes to bitstream
 *
 *	Input:          MV struct, position, pointers to MV predictors,
 *                      block number, half pel flag.
 *
 *	Returns:        median predicted MV
 *	Side effects:
 *
 *	Date: 940111	Author:	???
 *            970831    Added support for backwards MV prediction,
 *                      modified by [e-mail]
 *
 ***********************************************************************/

void FindPMV (MotionVector * MV[7][MBR + 1][MBC + 2], int x, int y,
               int *pmv0, int *pmv1, int block,
               int newgob, int half_pel)
{
  int p1, p2, p3;
  int xin1, xin2, xin3;
  int yin1, yin2, yin3;
  int vec1, vec2, vec3;
  int l8, o8, or8;


  l8 = o8 = or8 = 0;
  if (MV[0][y][x - 1]->Mode == MODE_INTER4V || MV[0][y][x - 1]->Mode == MODE_INTER4V_Q)
    l8 = 1;
  if (MV[0][y - 1][x]->Mode == MODE_INTER4V || MV[0][y - 1][x]->Mode == MODE_INTER4V_Q)
    o8 = 1;
  if (MV[0][y - 1][x + 1]->Mode == MODE_INTER4V || MV[0][y - 1][x + 1]->Mode == MODE_INTER4V_Q)
    or8 = 1;

  switch (block)
  {
    case 0:
      vec1 = (l8 ? 2 : 0);
      yin1 = y;
      xin1 = x - 1;
      vec2 = (o8 ? 3 : 0);
      yin2 = y - 1;
      xin2 = x;
      vec3 = (or8 ? 3 : 0);
      yin3 = y - 1;
      xin3 = x + 1;
      break;
    case 1:
      vec1 = (l8 ? 2 : 0);
      yin1 = y;
      xin1 = x - 1;
      vec2 = (o8 ? 3 : 0);
      yin2 = y - 1;
      xin2 = x;
      vec3 = (or8 ? 3 : 0);
      yin3 = y - 1;
      xin3 = x + 1;
      break;
    case 2:
      vec1 = 1;
      yin1 = y;
      xin1 = x;
      vec2 = (o8 ? 4 : 0);
      yin2 = y - 1;
      xin2 = x;
      vec3 = (or8 ? 3 : 0);
      yin3 = y - 1;
      xin3 = x + 1;
      break;
    case 3:
      vec1 = (l8 ? 4 : 0);
      yin1 = y;
      xin1 = x - 1;
      vec2 = 1;
      yin2 = y;
      xin2 = x;
      vec3 = 2;
      yin3 = y;
      xin3 = x;
      break;
    case 4:
      vec1 = 3;
      yin1 = y;
      xin1 = x;
      vec2 = 1;
      yin2 = y;
      xin2 = x;
      vec3 = 2;
      yin3 = y;
      xin3 = x;
      break;
    case 5:
      vec1 = 5;
      yin1 = y;
      xin1 = x - 1;
      vec2 = 5;
      yin2 = y - 1;
      xin2 = x;
      vec3 = 5;
      yin3 = y - 1;
      xin3 = x + 1;
      break;
    default:
      fprintf (stderr, "Illegal block number in FindPMV (countbit.c)\n");
      exit (-1);
      break;
  }

  if (half_pel)
  {
    p1 = 2 * MV[vec1][yin1][xin1]->x + MV[vec1][yin1][xin1]->x_half;
    p2 = 2 * MV[vec2][yin2][xin2]->x + MV[vec2][yin2][xin2]->x_half;
    p3 = 2 * MV[vec3][yin3][xin3]->x + MV[vec3][yin3][xin3]->x_half;
  } else
  {
    p1 = 2 * MV[vec1][yin1][xin1]->x;
    p2 = 2 * MV[vec2][yin2][xin2]->x;
    p3 = 2 * MV[vec3][yin3][xin3]->x;
  }

  if (newgob && (block == 0 || block == 1 || block == 2))
    p2 = 2 * NO_VEC;

  if (p2 == 2 * NO_VEC)
  {
    p2 = p3 = p1;
  }
  *pmv0 = p1 + p2 + p3 - mmax (p1, mmax (p2, p3)) - mmin (p1, mmin (p2, p3));

  if (half_pel)
  {
    p1 = 2 * MV[vec1][yin1][xin1]->y + MV[vec1][yin1][xin1]->y_half;
    p2 = 2 * MV[vec2][yin2][xin2]->y + MV[vec2][yin2][xin2]->y_half;
    p3 = 2 * MV[vec3][yin3][xin3]->y + MV[vec3][yin3][xin3]->y_half;
  } else
  {
    p1 = 2 * MV[vec1][yin1][xin1]->y;
    p2 = 2 * MV[vec2][yin2]