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 mikeg@ee.ubc.ca * ***********************************************************************/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]