bisk.c

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

                                    QccList *LSP,
                                    const QccWAVSubbandPyramid *coefficients,
                                    const QccWAVSubbandPyramid *mask)
{
  QccWAVbiskSet set;
  int subband;
  int num_subbands;
  int return_value;

  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);

  if (QccWAVbiskLengthenLIS(LIS))
    {
      QccErrorAddMessage("(QccWAVbiskInitialization): Error calling QccWAVbiskLengthenLIS()");
      return(1);
    }

  for (subband = 0; subband < num_subbands; subband++)
    {
      set.level =
        QccWAVSubbandPyramidCalcLevelFromSubband(subband,
                                                 coefficients->num_levels) * 2;
      set.significance = QCCBISK_INSIGNIFICANT;
      return_value = QccWAVbiskSetSize(&set,
                                       coefficients,
                                       mask,
                                       subband);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbiskInitialization): Error calling QccWAVbiskSetSize()");
          return(1);
        }
      
      if (return_value != 2)
        if (QccWAVbiskInsertSet(LIS,
                                &set,
                                NULL,
                                NULL))
          {
            QccErrorAddMessage("(QccWAVbiskInitialization): Error calling QccWAVbiskInsertSet()");
            return(1);
          }
    }

  QccListInitialize(LSP);

  return(0);
}


static void QccWAVbiskFreeLIS(QccList *LIS)
{
  QccListNode *current_list_node;
  QccList *current_list;

  current_list_node = LIS->start;
  while (current_list_node != NULL)
    {
      current_list = (QccList *)(current_list_node->value);
      QccListFree(current_list);
      current_list_node = current_list_node->next;
    }

  QccListFree(LIS);
}


static int QccWAVbiskSignificanceMap(const QccWAVSubbandPyramid *coefficients,
                                     const QccWAVSubbandPyramid *mask,
                                     char **significance_map,
                                     double threshold)
{
  int row, col;

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

  for (row = 0; row < coefficients->num_rows; row++)
    for (col = 0; col < coefficients->num_cols; col++)
      if (!QccWAVbiskTransparent(mask, row, col))
        if (coefficients->matrix[row][col] >= threshold)
          significance_map[row][col] = QCCBISK_SIGNIFICANT;
        else
          significance_map[row][col] = QCCBISK_INSIGNIFICANT;
      else
        significance_map[row][col] = QCCBISK_INSIGNIFICANT;

  return(0);
}


static int QccWAVbiskSetSignificance(QccWAVbiskSet *set,
                                     char **significance_map)
{
  int row, col;
  
  set->significance = QCCBISK_INSIGNIFICANT;
  
  for (row = 0; row < set->num_rows; row++)
    for (col = 0; col < set->num_cols; col++)
      if (significance_map[set->origin_row + row]
          [set->origin_col + col] ==
          QCCBISK_SIGNIFICANT)
        {
          set->significance = QCCBISK_SIGNIFICANT;
          return(0);
        }
  
  return(0);
}


static int QccWAVbiskInputOutputSetSignificance(QccWAVbiskSet *current_set,
                                                char **significance_map,
                                                QccENTArithmeticModel *model,
                                                QccBitBuffer *buffer)
{
  int symbol;
  int return_value;

  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      if (model->current_context != QCCBISK_CONTEXT_NOCODE)
        {
          if (QccWAVbiskSetSignificance(current_set,
                                        significance_map))
            {
              QccErrorAddMessage("(QccWAVbiskInputOutputSetSignificance): Error calling QccWAVbiskSetSignificance()");
              return(1);
            }
          
          symbol = (current_set->significance == QCCBISK_SIGNIFICANT);
          
          return_value =
            QccENTArithmeticEncode(&symbol, 1,
                                   model, buffer);
          if (return_value == 2)
            return(2);
          else
            if (return_value)
              {
                QccErrorAddMessage("(QccWAVbiskInputOutputSetSignificance): Error calling QccENTArithmeticEncode()");
                return(1);
              }
        }
      else
        current_set->significance = QCCBISK_SIGNIFICANT;
    }
  else
    if (model->current_context != QCCBISK_CONTEXT_NOCODE)
      {
        if (QccENTArithmeticDecode(buffer,
                                   model,
                                   &symbol, 1))
          return(2);
        
        current_set->significance =
          (symbol) ? QCCBISK_SIGNIFICANT : QCCBISK_INSIGNIFICANT;
      }
    else
      current_set->significance = QCCBISK_SIGNIFICANT;
  
  return(0);
}


static int QccWAVbiskInputOutputSign(char *sign,
                                     double *coefficient,
                                     int row,
                                     int col,
                                     double threshold,
                                     QccENTArithmeticModel *model,
                                     QccBitBuffer *buffer,
                                     QccWAVbiskDistortionTrace
                                     *distortion_trace)
{
  int return_value;
  int symbol;
  
  model->current_context = QCCBISK_CONTEXT_SIGN;
  
  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      symbol = (*sign == QCCBISK_POSITIVE);
      *coefficient -= threshold;
      
      return_value =
        QccENTArithmeticEncode(&symbol, 1,
                               model, buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value)
          {
            QccErrorAddMessage("(QccWAVbiskInputOutputSign): Error calling QccENTArithmeticEncode()");
            return(1);
          }
    }
  else
    {
      if (QccENTArithmeticDecode(buffer,
                                 model,
                                 &symbol, 1))
        return(2);
      
      *sign =
        (symbol) ? QCCBISK_POSITIVE : QCCBISK_NEGATIVE;
      
      *coefficient  = 1.5 * threshold;
    }
  
  if (distortion_trace != NULL)
    {
      distortion_trace->reconstructed_coefficients.matrix[row][col] =
        1.5 * threshold;
      QccWAVbiskDistortionTraceUpdate(distortion_trace,
                                      row,
                                      col,
                                      buffer);
    }
  
  return(0);
}


static int QccWAVbiskPartitionSet(const QccWAVbiskSet *set,
                                  const QccWAVSubbandPyramid *mask,
                                  QccListNode **subset_node1,
                                  QccListNode **subset_node2)
{
  QccWAVbiskSet subset1;
  QccWAVbiskSet subset2;
  int split_row;
  int split_col;
  int num_rows;
  int num_cols;
  int return_value;

  split_row = set->num_rows / 2;
  split_col = set->num_cols / 2;
  
  if (set->level & 1)
    {
      num_cols = set->num_cols - split_col;
      
      /* Right */
      subset1.origin_row = set->origin_row;
      subset1.origin_col = set->origin_col + num_cols;
      subset1.num_rows = set->num_rows;
      subset1.num_cols = set->num_cols - num_cols;
      
      /* Left */
      subset2.origin_row = set->origin_row;
      subset2.origin_col = set->origin_col;
      subset2.num_rows = set->num_rows;
      subset2.num_cols = num_cols;
    }
  else
    {
      num_rows = set->num_rows - split_row;
      
      /* Bottom */
      subset1.origin_row = set->origin_row + num_rows;
      subset1.origin_col = set->origin_col;
      subset1.num_rows = set->num_rows - num_rows;
      subset1.num_cols = set->num_cols;
      
      /* Top */
      subset2.origin_row = set->origin_row;
      subset2.origin_col = set->origin_col;
      subset2.num_rows = num_rows;
      subset2.num_cols = set->num_cols;
    }

  subset1.level = set->level + 1;
  subset1.significance = QCCBISK_INSIGNIFICANT;

  subset2.level = set->level + 1;
  subset2.significance = QCCBISK_INSIGNIFICANT;

  return_value = QccWAVbiskSetShrink(&subset1, mask);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbiskPartitionSet): Error calling QccWAVbiskSetShrink()");
      return(1);
    }
  if (return_value == 2)
    subset1.significance = QCCBISK_EMPTYSET;

  return_value = QccWAVbiskSetShrink(&subset2, mask);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbiskPartitionSet): Error calling QccWAVbiskSetShrink()");
      return(1);
    }
  if (return_value == 2)
    subset2.significance = QCCBISK_EMPTYSET;

  if ((*subset_node1 =
       QccListCreateNode(sizeof(QccWAVbiskSet), &subset1)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbiskPartitionSet): Error calling QccListCreateNode()");
      return(1);
    }
  if ((*subset_node2 =
       QccListCreateNode(sizeof(QccWAVbiskSet), &subset2)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbiskPartitionSet): Error calling QccListCreateNode()");
      return(1);
    }

  return(0);
}


static int QccWAVbiskProcessSet(QccListNode *current_set_node,
                                QccListNode *current_list_node,
                                QccList *LIS,
                                QccList *LSP,
                                QccList *garbage,
                                QccWAVSubbandPyramid *coefficients,
                                const QccWAVSubbandPyramid *mask,
                                char **significance_map,
                                char **sign_array,
                                double threshold,
                                QccENTArithmeticModel *model,
                                QccBitBuffer *buffer,
                                QccWAVbiskDistortionTrace
                                *distortion_trace);


static int QccWAVbiskCodeSet(QccListNode *current_set_node,
                             QccListNode *current_list_node,
                             QccList *LIS,
                             QccList *LSP,
                             QccList *garbage,
                             QccWAVSubbandPyramid *coefficients,
                             const QccWAVSubbandPyramid *mask,
                             char **significance_map,
                             char **sign_array,
                             double threshold,
                             QccENTArithmeticModel *model,
                             QccBitBuffer *buffer,
                             QccWAVbiskDistortionTrace
                             *distortion_trace)
{
  int return_value;
  QccWAVbiskSet *current_set = (QccWAVbiskSet *)(current_set_node->value);
  QccList *next_list;
  QccWAVbiskSet *subset1;
  QccListNode *subset_node1;
  QccListNode *subset_node2;
  
  if (current_list_node->next == NULL)
    if (QccWAVbiskLengthenLIS(LIS))
      {
        QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccWAVbiskLengthenLIS()");
        return(1);
      }
  next_list = (QccList *)(current_list_node->next->value);
  
  if (QccWAVbiskPartitionSet(current_set,
                             mask,
                             &subset_node1,
                             &subset_node2))
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccWAVbiskPartitionSet()");
      return(1);
    }
  
  if (QccListAppendNode(garbage, subset_node1))
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListAppendNode()");
      return(1);
    }
  if (QccListAppendNode(garbage, subset_node2))
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListAppendNode()");
      return(1);
    }
  
  subset1 = (QccWAVbiskSet *)(subset_node1->value);
  
  if (subset1->significance != QCCBISK_EMPTYSET)
    {
      if (QccListRemoveNode(garbage, subset_node1))
        {
          QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListRemoveNode()");
          return(1);
        }
      if (QccListAppendNode(next_list, subset_node1))
        {
          QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListAppendNode()");
          return(1);
        }
      
      model->current_context = 
        QCCBISK_CONTEXT_SIGNIFICANCE_SUBSET1;
      
      return_value =
        QccWAVbiskProcessSet(subset_node1,
                             current_list_node->next,