bisk.c

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

                             LIS,
                             LSP,
                             garbage,
                             coefficients,
                             mask,
                             significance_map,
                             sign_array,
                             threshold,
                             model,
                             buffer,
                             distortion_trace);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccWAVbiskProcessSet()");
          return(1);
        }
      else
        if (return_value == 2)
          return(2);
    }
  
  if (QccListRemoveNode(garbage, subset_node2))
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListRemoveNode()");
      return(1);
    }
  if (QccListAppendNode(next_list, subset_node2))
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccListAppendNode()");
      return(1);
    }
  
  if ((subset1->significance == QCCBISK_INSIGNIFICANT) ||
      (subset1->significance == QCCBISK_EMPTYSET))
    model->current_context = QCCBISK_CONTEXT_NOCODE;
  else
    model->current_context = 
      QCCBISK_CONTEXT_SIGNIFICANCE_SUBSET2;
  
  return_value =
    QccWAVbiskProcessSet(subset_node2,
                         current_list_node->next,
                         LIS,
                         LSP,
                         garbage,
                         coefficients,
                         mask,
                         significance_map,
                         sign_array,
                         threshold,
                         model,
                         buffer,
                         distortion_trace);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbiskCodeSet): Error calling QccWAVbiskProcessSet()");
      return(1);
    }
  else
    if (return_value == 2)
      return(2);
  
  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)
{
  int return_value;
  QccWAVbiskSet *current_set = (QccWAVbiskSet *)(current_set_node->value);
  QccList *current_list = (QccList *)(current_list_node->value);
  
  if (current_set->significance == QCCBISK_EMPTYSET)
    {
      if (QccListRemoveNode(current_list, current_set_node))
        {
          QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListRemoveNode()");
          return(1);
        }
      if (QccListAppendNode(garbage, current_set_node))
        {
          QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListAppendNode()");
          return(1);
        }
      
      return(0);
    }
  
  return_value = QccWAVbiskInputOutputSetSignificance(current_set,
                                                      significance_map,
                                                      model,
                                                      buffer);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccWAVbiskInputOutputSetSignificance()");
      return(1);
    }
  else
    if (return_value == 2)
      return(2);
  
  if (current_set->significance != QCCBISK_INSIGNIFICANT)
    {
      if (QccListRemoveNode(current_list, current_set_node))
        {
          QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListRemoveNode()");
          return(1);
        }
      if (QccListAppendNode(garbage, current_set_node))
        {
          QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListAppendNode()");
          return(1);
        }
      
      if (QccWAVbiskSetIsPixel(current_set))
        {
          current_set->significance = QCCBISK_NEWLY_SIGNIFICANT;
          return_value =
            QccWAVbiskInputOutputSign(&sign_array
                                      [current_set->origin_row]
                                      [current_set->origin_col],
                                      &coefficients->matrix
                                      [current_set->origin_row]
                                      [current_set->origin_col],
                                      current_set->origin_row,
                                      current_set->origin_col,
                                      threshold,
                                      model,
                                      buffer,
                                      distortion_trace);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccWAVbiskInputOutputSign()");
              return(1);
            }
          else
            if (return_value == 2)
              return(2);
          
          if (QccListRemoveNode(garbage, current_set_node))
            {
              QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListRemoveNode()");
              return(1);
            }
          if (QccListAppendNode(LSP, current_set_node))
            {
              QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccListAppendNode()");
              return(1);
            }
        }
      else
        {
          return_value =
            QccWAVbiskCodeSet(current_set_node,
                              current_list_node,
                              LIS,
                              LSP,
                              garbage,
                              coefficients,
                              mask,
                              significance_map,
                              sign_array,
                              threshold,
                              model,
                              buffer,
                              distortion_trace);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVbiskProcessSet): Error calling QccWAVbiskCodeSet()");
              return(1);
            }
          else
            if (return_value == 2)
              return(2);
        }
    }
  
  return(0);
}


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

  QccListInitialize(&garbage);

  if (QccWAVbiskSignificanceMap(coefficients,
                                mask,
                                significance_map,
                                threshold))
    {
      QccErrorAddMessage("(QccWAVbiskSortingPass): Error calling QccWAVbiskSignificanceMap()");
      goto Error;
    }

  current_list_node = LIS->end;
  while (current_list_node != NULL)
    {
      current_list = (QccList *)(current_list_node->value);
      current_set_node = current_list->start;
      while (current_set_node != NULL)
        {
          next_set_node = current_set_node->next;

          model->current_context = QCCBISK_CONTEXT_SIGNIFICANCE;

          return_value = QccWAVbiskProcessSet(current_set_node,
                                              current_list_node,
                                              LIS,
                                              LSP,
                                              &garbage,
                                              coefficients,
                                              mask,
                                              significance_map,
                                              sign_array,
                                              threshold,
                                              model,
                                              buffer,
                                              distortion_trace);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVbiskSortingPass): Error calling QccWAVbiskProcessSet()");
              goto Error;
            }
          else
            if (return_value == 2)
              goto Finished;

          current_set_node = next_set_node;
        }

      current_list_node = current_list_node->previous;
    }

  return_value = 0;
  goto Return;
 Finished:
  return_value = 2;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccListFree(&garbage);
  return(return_value);
}


static void QccWAVbiskRefineCoefficient(double *coefficient,
                                        int bit,
                                        double threshold)
{
  *coefficient +=
    (bit) ? (threshold / 2) : (-threshold / 2);
}


static int QccWAVbiskRefinementInputOutput(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_REFINEMENT;
  
  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      if (*coefficient >= threshold)
        {
          symbol = 1;
          *coefficient -= threshold;
        }
      else
        symbol = 0;
      
      return_value =
        QccENTArithmeticEncode(&symbol, 1,
                               model, buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value)
          {
            QccErrorAddMessage("(QccWAVbiskRefinementInputOutput): Error calling QccENTArithmeticEncode()");
            return(1);
          }
    }
  else
    {
      if (QccENTArithmeticDecode(buffer,
                                 model,
                                 &symbol, 1))
        return(2);
      
      QccWAVbiskRefineCoefficient(coefficient,
                                  symbol,
                                  threshold);
    }
  
  if (distortion_trace != NULL)
    {
      double *coefficient_value =
        &(distortion_trace->reconstructed_coefficients.matrix[row][col]);
      QccWAVbiskRefineCoefficient(coefficient_value,
                                  symbol,
                                  threshold);
      QccWAVbiskDistortionTraceUpdate(distortion_trace,
                                      row,
                                      col,
                                      buffer);
    }
  
  return(0);
}


static int QccWAVbiskRefinementPass(QccWAVSubbandPyramid *coefficients,
                                    QccList *LSP,
                                    double threshold,
                                    QccENTArithmeticModel *model,
                                    QccBitBuffer *buffer,
                                    QccWAVbiskDistortionTrace
                                    *distortion_trace)
{
  int return_value;
  QccListNode *current_set_node;
  QccWAVbiskSet *current_set;

  current_set_node = LSP->start;
  while (current_set_node != NULL)
    {
      current_set = (QccWAVbiskSet *)(current_set_node->value);
      
      if (current_set->significance == QCCBISK_NEWLY_SIGNIFICANT)
        current_set->significance = QCCBISK_SIGNIFICANT;
      else
        {
          return_value =
            QccWAVbiskRefinementInputOutput(&coefficients->matrix
                                            [current_set->origin_row]
                                            [current_set->origin_col],
                                            current_set->origin_row,
                                            current_set->origin_col,
                                            threshold,
                                            model,
                                            buffer,
                                            distortion_trace);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVbiskRefinementPass): Error calling QccWAVbiskRefinementInputOutput()");
              return(1);
            }
          else
            if (return_value == 2)
              return(2);
        }

      current_set_node = current_set_node->next;
    }

  return(0);
}


static int QccWAVbiskEncodeDWT(QccWAVSubbandPyramid *image_subband_pyramid,
                               const QccIMGImageComponent *image,
                               int num_levels,
                               double *image_mean,
                               QccWAVSubbandPyramid *mask_subband_pyramid,
                               const QccIMGImageComponent *mask,