arithmetic.c

spiht for linux this is used to decod and encode vedio i wich all enjoy

                                                               output_buffer);
          if (return_value == 2)
            return(2);
          else
            if (return_value == 1)
              {
                QccErrorAddMessage("(QccENTArithmeticEncodeSymbol): Error calling QccENTArithmeticOutputBitPlusFollowingOppositeBits()");
                return(1);
              }
          model->low -= QCCENT_HALFVALUE;
          model->high -= QCCENT_HALFVALUE;
        }
      else if ((model->low >= QCCENT_FIRSTQUARTERVALUE) &&
               (model->high < QCCENT_THIRDQUARTERVALUE))
        {
          model->bits_to_follow += 1;
          model->low -= QCCENT_FIRSTQUARTERVALUE;
          model->high -= QCCENT_FIRSTQUARTERVALUE;
        }
      else
        break;
      model->low *= 2;
      model->high = model->high*2 + 1;
    }

  return(0);
}


static int QccENTArithmeticEncodeEOFSymbol(int context,
                                           QccENTArithmeticModel *model, 
                                           QccBitBuffer *output_buffer)
{
  int return_value;
  int EOF_symbol_index;
  
  EOF_symbol_index = model->num_symbols[context];

  return_value =
    QccENTArithmeticEncodeSymbol(EOF_symbol_index,
                                 context,
                                 model, output_buffer);
  if (return_value == 2)
    return(2);
  else
    if (return_value == 1)
      {
        QccErrorAddMessage("(QccENTArithmeticEncodeEOFSymbol): Error calling QccENTArithmeticEncodeSymbol()");
        return(1);
      }
  
  return(0);
}


QccENTArithmeticModel *QccENTArithmeticEncodeStart(const int *num_symbols, 
                                                   int num_contexts,
                                                   QccENTArithmeticGetContext
                                                   context_function,
                                                   int target_num_bits)
{
  QccENTArithmeticModel *new_model = NULL;

  if ((new_model = 
       QccENTArithmeticCreateModel(num_symbols, num_contexts,
                                   context_function)) == NULL)
    {
      QccErrorAddMessage("(QccENTArithmeticEncodeStart): Error calling QccENTArithmeticCreateModel()");
      return(NULL);
    }

  new_model->target_num_bits = target_num_bits;

  return(new_model);
}


int QccENTArithmeticEncodeEnd(QccENTArithmeticModel *model,
                              int final_context,
                              QccBitBuffer *output_buffer)
{
  int return_value;

  if ((model == NULL) || (output_buffer == NULL))
    return(0);

  if (model->num_contexts <= 1)
    final_context = 0;

  return_value =
    QccENTArithmeticEncodeEOFSymbol(final_context, model, output_buffer);
  if (return_value == 2)
    return(2);
  else
    if (return_value == 1)
      {
        QccErrorAddMessage("(QccENTArithmeticEncodeEnd): Error calling QccENTArithmeticEncodeEOFSymbol()");
        return(1);
      }

  return_value = QccENTArithmeticEncodeFlush(model, output_buffer);
  if (return_value == 2)
    return(2);
  else
    if (return_value == 1)
      {
        QccErrorAddMessage("(QccENTArithmeticEncode): Error calling QccENTArithmeticEncodeFlush()");
        return(1);
      }
  
  return(0);
}


int QccENTArithmeticEncode(const int *symbol_stream,
                           int symbol_stream_length,
                           QccENTArithmeticModel *model,
                           QccBitBuffer *output_buffer)
{
  int return_value;
  int current_symbol;
  int symbol_index;

  if (symbol_stream == NULL)
    return(0);
  if (output_buffer == NULL)
    return(0);
  if (model == NULL)
    return(0);

  for (current_symbol = 0; current_symbol < symbol_stream_length;
       current_symbol++)
    {
      if (model->context_function != NULL)
        model->current_context =
          (model->context_function)(symbol_stream, current_symbol);

      if ((model->current_context < 0) ||
          (model->current_context >= model->num_contexts))
        {
          QccErrorAddMessage("(QccENTArithmeticEncode): Invalid context");
          return(1);
        }
      if ((symbol_stream[current_symbol] >=
           model->num_symbols[model->current_context] - 1) ||
          (symbol_stream[current_symbol] < 0))
        {
          QccErrorAddMessage("(QccENTArithmeticEncode): Invalid symbol in symbol stream");
          return(1);
        }
      symbol_index = 
        model->translate_symbol_to_index
        [model->current_context][symbol_stream[current_symbol]];
      return_value =
        QccENTArithmeticEncodeSymbol(symbol_index, model->current_context,
                                     model, output_buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccENTArithmeticEncode): Error calling QccENTArithmeticEncodeSymbol()");
            return(1);
          }
      if (model->adaptive_model == QCCENT_ADAPTIVE)
        if (QccENTArithmeticUpdateModel(model,
                                        symbol_index,
                                        model->current_context))
          {
            QccErrorAddMessage("(QccENTArithmeticEncode): Error calling QccENTArithmeticUpdateModel()");
            return(1);
          }
    }

  return(0);
}


int QccENTArithmeticEncodeFlush(QccENTArithmeticModel *model, 
                                QccBitBuffer *output_buffer)
{
  int return_value;

  if (model == NULL)
    return(0);

  model->bits_to_follow += 1;
  if (model->low < QCCENT_FIRSTQUARTERVALUE)
    {
      return_value =
        QccENTArithmeticOutputBitPlusFollowingOppositeBits(0, model, 
                                                           output_buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccENTArithmeticEncodeFlush): Error calling QccENTArithmeticOutputBitPlusFollowingOppositeBits()");
            return(1);
          }
    }
  else
    {
      return_value =
        QccENTArithmeticOutputBitPlusFollowingOppositeBits(1, model, 
                                                           output_buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccENTArithmeticEncodeFlush): Error calling QccENTArithmeticOutputBitPlusFollowingOppositeBits()");
            return(1);
          }
    }

  if (QccBitBufferFlush(output_buffer))
    {
      QccErrorAddMessage("(QccENTArithmeticEncodeFlush): Error calling QccBitBufferFlush()");
      return(1);
    }

  model->low = 0;
  model->high = QCCENT_TOPVALUE;
  model->bits_to_follow = 0;

  return(0);
}


static int QccENTArithmeticDecodeGetBit(QccENTArithmeticModel *model,
                                        QccBitBuffer *input_buffer,
                                        int *bit_value)
{
  int beyond_bounds;
  
  if (model->target_num_bits == QCCENT_ANYNUMBITS)
    beyond_bounds = QccBitBufferGetBit(input_buffer, bit_value);
  else
    if (input_buffer->bit_cnt >= model->target_num_bits)
      beyond_bounds = 1;
    else
      beyond_bounds = QccBitBufferGetBit(input_buffer, bit_value);
  
  if (beyond_bounds)
    {
      QccErrorClearMessages();
      model->garbage_bits++;
      if (model->garbage_bits > QCCENT_CODEVALUEBITS - 2)
        return(1);

      *bit_value = 0;
    }

  return(0);
}


static int QccENTArithmeticDecodeSymbol(int *symbol_index, 
                                        int context,
                                        QccENTArithmeticModel *model, 
                                        QccBitBuffer *input_buffer)
{
  long range;
  int cumulative_frequency;
  int bit_value;

  range = (long)(model->high - model->low) + 1;
  cumulative_frequency = 
    (((long)(model->current_code_value - model->low) + 1) *
     model->cumulative_frequencies[context][0] - 1) / range;

  for (*symbol_index = 1;
       model->cumulative_frequencies[context][*symbol_index] > 
         cumulative_frequency;
       *symbol_index += 1) ;

  model->high = model->low +
    (range * model->cumulative_frequencies[context][*symbol_index - 1]) /
    model->cumulative_frequencies[context][0] - 1;
  model->low = model->low +
    (range * model->cumulative_frequencies[context][*symbol_index]) /
    model->cumulative_frequencies[context][0];

  for (;;)
    {
      if (model->high < QCCENT_HALFVALUE) ;
      else if (model->low >= QCCENT_HALFVALUE)
        {
          model->current_code_value -= QCCENT_HALFVALUE;
          model->low -= QCCENT_HALFVALUE;
          model->high -= QCCENT_HALFVALUE;
        }
      else if (model->low >= QCCENT_FIRSTQUARTERVALUE &&
               model->high < QCCENT_THIRDQUARTERVALUE)
        {
          model->current_code_value -= QCCENT_FIRSTQUARTERVALUE;
          model->low -= QCCENT_FIRSTQUARTERVALUE;
          model->high -= QCCENT_FIRSTQUARTERVALUE;
        }
      else
        break;

      model->low = 2 * model->low;
      model->high = 2 * model->high + 1;

      if (QccENTArithmeticDecodeGetBit(model, input_buffer, &bit_value))
        return(1);

      model->current_code_value = 2 * (model->current_code_value) +
        bit_value;

    }

  return(0);
}


static int QccENTArithmeticSymbolIsEOF(int symbol_index,
                                       int context,
                                       QccENTArithmeticModel *model)
{
  int EOF_symbol_index;

  EOF_symbol_index = model->num_symbols[context];

  return(symbol_index == EOF_symbol_index);
}


QccENTArithmeticModel *QccENTArithmeticDecodeStart(QccBitBuffer *input_buffer,
                                                   const int *num_symbols, 
                                                   int num_contexts,
                                                   QccENTArithmeticGetContext
                                                   context_function,
                                                   int target_num_bits)
{
  int bit_index;
  int bit_value;

  QccENTArithmeticModel *new_model = NULL;

  if ((new_model = 
       QccENTArithmeticCreateModel(num_symbols, num_contexts,
                                   context_function)) == NULL)
    {
      QccErrorAddMessage("(QccENTArithmeticDecodeStart): Error calling QccENTArithmeticCreateModel()");
      return(NULL);
    }

  new_model->current_code_value = 0;
  new_model->garbage_bits = 0;
  new_model->target_num_bits = target_num_bits;
  for (bit_index = 1; bit_index <= QCCENT_CODEVALUEBITS; bit_index++)
    {
      if (QccENTArithmeticDecodeGetBit(new_model, input_buffer, &bit_value))
        {
          QccErrorAddMessage("(QccENTArithmeticDecodeStart): Error calling QccENTArithmeticDecodeGetBit()");
          QccENTArithmeticFreeModel(new_model);
          return(NULL);
        }
      new_model->current_code_value = 2*(new_model->current_code_value) + 
        bit_value;
    }

  return(new_model);
}


int QccENTArithmeticDecodeRestart(QccBitBuffer *input_buffer,
                                  QccENTArithmeticModel *model,
                                  int target_num_bits)
{
  int bit_index;
  int bit_value;

  if (model == NULL)
    return(0);
  if (input_buffer == NULL)
    return(0);

  if (QccBitBufferFlush(input_buffer))
    {
      QccErrorAddMessage("(QccENTArithmeticDecodeRestart): Error calling QccBitBufferFlush()");
      return(1);
    }

  model->current_code_value = 0;
  model->garbage_bits = 0;
  model->target_num_bits = target_num_bits;
  model->low = 0;
  model->high = QCCENT_TOPVALUE;

  for (bit_index = 1; bit_index <= QCCENT_CODEVALUEBITS; bit_index++)
    {
      if (QccENTArithmeticDecodeGetBit(model, input_buffer, &bit_value))
        {
          QccErrorAddMessage("(QccENTArithmeticDecodeRestart): Error calling QccENTArithmeticDecodeGetBit()");
          return(1);
        }
      model->current_code_value = 2*(model->current_code_value) + 
        bit_value;
    }

  return(0);
}


int QccENTArithmeticDecode(QccBitBuffer *input_buffer,
                           QccENTArithmeticModel *model,
                           int *symbol_stream,
                           int symbol_stream_length)
{
  int current_symbol;
  int symbol_index;

  if (input_buffer == NULL)
    return(0);
  if (symbol_stream == NULL)
    return(0);
  if (model == NULL)
    return(0);

  for (current_symbol = 0; current_symbol < symbol_stream_length; 
       current_symbol++)
    {
      if (model->context_function != NULL)
        model->current_context =
          (model->context_function)(symbol_stream, current_symbol);

      if (QccENTArithmeticDecodeSymbol(&symbol_index, model->current_context,
                                       model, input_buffer))
        {
          QccErrorAddMessage("(QccENTArithmeticDecode): Error calling QccENTArithmeticDecodeSymbol()");
          return(1);
        }

      if (QccENTArithmeticSymbolIsEOF(symbol_index,
                                      model->current_context, model))
        return(2);

      symbol_stream[current_symbol] =
        model->translate_index_to_symbol[model->current_context][symbol_index];

      if (model->adaptive_model == QCCENT_ADAPTIVE)
        if (QccENTArithmeticUpdateModel(model,
                                        symbol_index, model->current_context))
          {
            QccErrorAddMessage("(QccENTArithmeticDecode): Error calling QccENTArithmeticUpdateModel()");
            return(1);
          }
    }

  return(0);
}