countbit.c

H.263的压缩算法

          total_length_intra += length_intra;

        }
        prev_run = run;
        prev_level = level;
        run = first = 0;
      }
    }
    /* Check the last coeff */
    if (!first)
    {
      if (prev_level >= 0 && prev_level < 26 && prev_run < 64)
      {
        if (prev_level < 13)
        {
          show_inter_coeff (prev_run, prev_level, 1, &length_inter, &code_inter);
          if (!(length_inter))
            length_inter = 22;
        } else
          length_inter = 22;
        show_intra_coeff (prev_run, prev_level, 1, &length_intra, &code_intra);
        if (!(length_intra))
          length_intra = 22;
      } else
        length_intra = 22;
      if (modified_quantization && (prev_level < -127 || prev_level > 127))
      {
        length_inter += 11;
        length_intra += 11;
      }
      if (length_intra < 22)
      {
        run_inter += show_inter_run (length_intra, code_intra) + 1;
      } else
      {
        run_inter += prev_run + 1;
      }
      total_length_inter += length_inter;
      total_length_intra += length_intra;
      if (total_length_intra < total_length_inter && run_inter > 64)
      {
        /* conditions are satisfied to use intra table for inter coeff */
        use_intra = 1;
      }
    }
    if (trace)
    {
      fprintf (tf, "Alternative Inter VLC Table: %s\n", use_intra ? "Intra" : "Inter");
    }
  }
  /* Encode the coefficients */
  run = bits = 0;
  first = 1;
  prev_run = prev_level = level = s = prev_s = 0;

  for (j = block * ncoeffs; j < (block + 1) * ncoeffs; j++)
  {
    /* Do this block's DC-coefficient first (unless advanced intra coding
     * is used) */
    if ((!(j % ncoeffs) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)) && (!advanced_intra_coding))
    {
      /* DC coeff */
      if (trace)
      {
        fprintf (tf, "DC: ");
      }
      if (qcoeff[block * ncoeffs] != 128)
        putbits (8, qcoeff[block * ncoeffs]);
      else
        putbits (8, 255);
      bits += 8;
    } else
    {
      /* AC coeff (or DC/AC in advanced intra coding mode) */
      s = 0;
      /* Increment run if coeff is zero */
      if ((level = qcoeff[j]) == 0)
      {
        run++;
      } else
      {
        /* code run & level and count bits */
        if (-127 <= level && level < 0)
        {
          s = 1;
          level = -level;
        }
        if (!first)
        {
          /* Encode the previous coefficient */
          if (advanced_intra_coding && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
              || (alternative_inter_vlc && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q) && use_intra))
          {
            if (prev_level >= 0 && prev_level < 26 && prev_run < 64)
            {
              if (trace)
              {
                fprintf (tf, "run: %2i  level: %3i  code: ", prev_run, prev_s ? -(prev_level) : prev_level);
              }
              length = put_intra_coeff (prev_run, prev_level, 0);
            } else
            {
              length = 0;
            }
          } else
          {
            if (prev_level >= 0 && prev_level < 13 && prev_run < 64)
            {
              if (trace)
              {
                fprintf (tf, "run: %2i  level: %3i  code: ", prev_run, prev_s ? -(prev_level) : prev_level);
              }
              length = put_coeff (prev_run, prev_level, 0);
            } else
              length = 0;
          }
          if (length == 0)
          {                     /* Escape coding */
            if (trace)
            {
              fprintf (tf, "Escape code: ");
            }
            if (!modified_quantization || (prev_level >= -127 && prev_level <= 127))
            {
              use_extended_escape = 0;
              if (prev_s == 1)
              {
                prev_level = (prev_level ^ 0xffff) + 1;
              }
            } else
              use_extended_escape = 1;
            putbits (7, 3);     /* Escape code */
            if (trace)
              fprintf (tf, "last(0): ");
            putbits (1, 0);
            if (trace)
              fprintf (tf, "run(%4d): ", prev_run);
            putbits (6, prev_run);

            if (!use_extended_escape)
            {
              if (trace)
                fprintf (tf, "level(%4d): ", prev_level);
              putbits (8, prev_level);
              bits += 22;
            } else
            {                   /* use extended escape code to code
                                 * coefficient that are outside the range
                                 * of -127, +127 */
              if (trace)
              {
                fprintf (tf, "Extended Escape code: ");
              }
              putbits (8, 0x80);/* extended escape code */
              if (trace)
                fprintf (tf, "extended level: ");
              putbits (11, (prev_level >> 5 & 0x003F) | (prev_level << 6));
              bits += 33;
            }
          } else
          {
            putbits (1, prev_s);
            bits += length + 1;
          }
        }
        prev_run = run;
        prev_s = s;
        prev_level = level;
        run = first = 0;
      }
    }
  }

  /* Encode the last coeff */
  if (!first)
  {
    if (trace)
    {
      fprintf (tf, "Last coeff: ");
    }
    if (advanced_intra_coding && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
        || (alternative_inter_vlc && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q) && use_intra))
    {
      if (prev_level >= 0 && prev_level < 26 && prev_run < 64)
      {
        if (trace)
        {
          fprintf (tf, "run: %2i  level: %3i  code: ", prev_run, s ? -(prev_level) : prev_level);
        }
        length = put_intra_coeff (prev_run, prev_level, 1);
      } else
        length = 0;
    } else
    {
      if (prev_level >= 0 && prev_level < 13 && prev_run < 64)
      {
        if (trace)
        {
          fprintf (tf, "run: %2i  level: %3i  code: ", prev_run, s ? -(prev_level) : prev_level);
        }
        length = put_coeff (prev_run, prev_level, 1);
      } else
        length = 0;
    }
    if (length == 0)
    {                           /* Escape coding */
      if (trace)
      {
        fprintf (tf, "Escape code: ");
      }
      if (!modified_quantization || (prev_level >= -127 && prev_level <= 127))
      {
        use_extended_escape = 0;
        if (prev_s == 1)
        {
          prev_level = (prev_level ^ 0xffff) + 1;
        }
      } else
        use_extended_escape = 1;

      putbits (7, 3);           /* Escape code */
      if (trace)
        fprintf (tf, "last(1): ");
      putbits (1, 1);
      if (trace)
        fprintf (tf, "run(%4d): ", prev_run);
      putbits (6, prev_run);

      if (!use_extended_escape)
      {
        if (trace)
          fprintf (tf, "level(%4d): ", prev_level);
        putbits (8, prev_level);
        bits += 22;
      } else
      {                         /* use extended escape code to code
                                 * coefficient that are outside the range
                                 * of -127, +127 */
        if (trace)
        {
          fprintf (tf, "Extended Escape code: ");
        }
        putbits (8, 0x80);      /* extended escape code */
        if (trace)
          fprintf (tf, "extended level: ");
        putbits (11, (prev_level >> 5 & 0x003F) | (prev_level << 6));
        bits += 33;
      }
    } else
    {
      putbits (1, prev_s);
      bits += length + 1;
    }
  }
  return bits;
}


/**********************************************************************
 *
 *      Name:           Count_sac_BitsCoeff
 *                      counts bits using SAC models
 *
 *      Input:          qcoeff, coding mode CBP, bits structure, no. of
 *                      coeffs
 *
 *      Returns:        struct with no. of bits used
 *      Side effects:
 *
 *      Author:        [e-mail]
 *
 ***********************************************************************/

void Count_sac_BitsCoeff (int *qcoeff, int Mode, int CBP, Bits * bits, int ncoeffs)
{

  int i;

  arith_used = 1;

  if ((Mode == MODE_INTRA || Mode == MODE_INTRA_Q) && !advanced_intra_coding)
  {
    for (i = 0; i < 4; i++)
    {
      bits->Y += Code_sac_Coeff (Mode, qcoeff, i, ncoeffs);
    }
    for (i = 4; i < 6; i++)
    {
      bits->C += Code_sac_Coeff (Mode, qcoeff, i, ncoeffs);
    }
  } else
  {
    for (i = 0; i < 4; i++)
    {
      if ((i == 0 && CBP & 32) ||
          (i == 1 && CBP & 16) ||
          (i == 2 && CBP & 8) ||
          (i == 3 && CBP & 4) ||
          (i == 4 && CBP & 2) ||
          (i == 5 && CBP & 1))
      {
        bits->Y += Code_sac_Coeff (Mode, qcoeff, i, ncoeffs);
      }
    }
    for (i = 4; i < 6; i++)
    {
      if ((i == 0 && CBP & 32) ||
          (i == 1 && CBP & 16) ||
          (i == 2 && CBP & 8) ||
          (i == 3 && CBP & 4) ||
          (i == 4 && CBP & 2) ||
          (i == 5 && CBP & 1))
      {
        bits->C += Code_sac_Coeff (Mode, qcoeff, i, ncoeffs);
      }
    }
  }
  return;
}

int Code_sac_Coeff (int Mode, int *qcoeff, int block, int ncoeffs)
{
  int j, bits, mod_index, intra;
  int prev_run, run, prev_level, level, first, prev_position, position;
  int prev_ind, ind, prev_s, s, length;

  run = bits = 0;
  first = 1;
  position = 0;
  intra = 0;

  level = s = ind = 0;
  prev_run = prev_level = prev_ind = prev_s = prev_position = 0;

  /* SAC table for Coeff in advanced intra coding not specified */
  /* use same tables and encode DC as AC                        */

  intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);

  for (j = block * ncoeffs; j < (block + 1) * ncoeffs; j++)
  {

    if ((!(j % ncoeffs) && (intra && !(advanced_intra_coding))))
    {
      if (trace)
      {
        fprintf (tf, "DC: ");
      }
      if (qcoeff[block * ncoeffs] != 128)
        mod_index = indexfn (qcoeff[block * ncoeffs], intradctab, 254);
      else
        mod_index = indexfn (255, intradctab, 254);
      bits += AR_Encode (mod_index, cumf_INTRADC);
    } else
    {

      s = 0;
      /* Increment run if coeff is zero */
      if ((level = qcoeff[j]) == 0)
      {
        run++;
      } else
      {
        /* code run & level and count bits */
        if (level < 0)
        {
          s = 1;
          level = -level;
        }
        ind = level | run << 4;
        ind = ind | 0 << 12;    /* Not last coeff */
        position++;

        if (!first)
        {
          mod_index = indexfn (prev_ind, tcoeftab, 103);
          if (prev_level < 13 && prev_run < 64)
            length = CodeTCoef (mod_index, prev_position, intra);
          else
            length = -1;

          if (length == -1)
          {                     /* Escape coding */
            if (trace)
            {
              fprintf (tf, "Escape coding:\n");
            }
            if (prev_s == 1)
            {
              prev_level = (prev_level ^ 0xff) + 1;
            }
            mod_index = indexfn (ESCAPE, tcoeftab, 103);
            bits += CodeTCoef (mod_index, prev_position, intra);

            if (intra)
              bits += AR_Encode (indexfn (0, lasttab, 2), cumf_LAST_intra);
            else
              bits += AR_Encode (indexfn (0, lasttab, 2), cumf_LAST);

            if (intra)
              bits += AR_Encode (indexfn (prev_run, runtab, 64), cumf_RUN_intra);
            else
              bits += AR_Encode (indexfn (prev_run, runtab, 64), cumf_RUN);

            if (intra)
              bits += AR_Encode (indexfn (prev_level, leveltab, 254),
                                 cumf_LEVEL_intra);
            else
              bits += AR_Encode (indexfn (prev_level, leveltab, 254),
                                 cumf_LEVEL);

          } else
          {
            bits += AR_Encode (indexfn (prev_s, signtab, 2), cumf_SIGN);
            bits += length;
          }
        }
        prev_run = run;
        prev_s = s;
        prev_level = level;
        prev_ind = ind;
        prev_position = position;

        run = first = 0;

      }
    }
  }

  /* Encode Last Coefficient */

  if (!first)
  {
    if (trace)
    {
      fprintf (tf, "Last coeff: ");
    }
    prev_ind = prev_ind | 1 << 12;  /* last coeff */
    mod_index = indexfn (prev_ind, tcoeftab, 103);

    if (prev_level < 13 && prev_run < 64)
      length = CodeTCoef (mod_index, prev_position, intra);
    else
      length = -1;

    if (length == -1)
    {                           /* Escape coding */
      if (trace)
      {
        fprintf (tf, "Escape coding:\n");
      }
      if (prev_s == 1)
      {
        prev_level = (prev_level ^ 0xff) + 1;
      }
      mod_index = indexfn (ESCAPE, tcoeftab, 103);
      bits += CodeTCoef (mod_index, prev_position, intra);

      if (intra)
        bits += AR_Encode (indexfn (1, lasttab, 2), cumf_LAST_intra);
      else
        bits += AR_Encode (indexfn (1, lasttab, 2), cumf_LAST);

      if (intra)
        bits += AR_Encode (indexfn (prev_run, runtab, 64), cumf_RUN_intra);
      else
        bits += AR_Encode (indexfn (prev_run, runtab, 64), cumf_RUN);

      if (intra)
        bits += AR_Encode (indexfn (prev_level, leveltab, 254), cumf_LEVEL_intra);
      else
        bits += AR_Encode (indexfn (prev_level, leveltab, 254), cumf_LEVEL);
    } else
    {
      bits += AR_Encode (indexfn (prev_s, signtab, 2), cumf_SIGN);
      bits += length;
    }
  }                             /* last coeff */
  return bits;
}

/*********************************************************************
 *
 *      Name:           CodeTCoef
 *
 *      Description:    Encodes an AC Coefficient using the
 *                      relevant SAC model.
 *
 *      Input:          Model index, position in DCT block and intra/
 *        inter flag.
 *
 *      Returns:        Number of bits used.
 *
 *      Side Effects:   None
 *
 *      Author:         [e-mail]
 *
 *********************************************************************/