wdr.c

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

  if (mask_subband_pyramid != NULL)
    {
      if (QccWAVSubbandPyramidInverseShapeAdaptiveDWT(image_subband_pyramid,
                                                      mask_subband_pyramid,
                                                      wavelet))
        {
          QccErrorAddMessage("(QccWAVwdrDecodeInverseDWT): Error calling QccWAVSubbandPyramidInverseShapeAdaptiveDWT()");
          goto Error;
        }
    }
  else
    if (QccWAVSubbandPyramidInverseDWT(image_subband_pyramid, wavelet))
      {
        QccErrorAddMessage("(QccWAVwdrDecodeInverseDWT): Error calling QccWAVSubbandPyramidInverseDWT()");
        goto Error;
      }
  
  if (QccWAVSubbandPyramidAddMean(image_subband_pyramid, image_mean))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeInverseDWT): Error calling QccWAVSubbandPyramidAddMean()");
      goto Error;
    }
  
  if (mask_subband_pyramid != NULL)
    for (row = 0; row < image_subband_pyramid->num_rows; row++)
      for (col = 0; col < image_subband_pyramid->num_cols; col++)
        if (QccAlphaTransparent(mask_subband_pyramid->matrix[row][col]))
          image_subband_pyramid->matrix[row][col] = 0;
  
  if (QccMatrixCopy(image->image, image_subband_pyramid->matrix,
                    image->num_rows, image->num_cols))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeInverseDWT): Error calling QccMatrixCopy()");
      goto Error;
    }
  
  if (QccIMGImageComponentSetMaxMin(image))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeInverseDWT): Error calling QccIMGImageComponentSetMaxMin()");
      return(1);
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdrAlgorithmInitialize(QccWAVSubbandPyramid *subband_pyramid,
                                        const QccWAVSubbandPyramid
                                        *mask_subband_pyramid,
                                        int num_levels,
                                        QccList *ICS,
                                        unsigned int *virtual_end)
{
  int return_value;
  int subband_num_rows, subband_num_cols;
  int row_offset, col_offset;
  int row, col, num_subbands, i;
  unsigned int current_index = 1;
  QccWAVwdrCoefficientBlock coefficient_block;
  QccListNode *new_node;
  int transparent;

  *virtual_end = 0;

  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_levels);
  for (i = 0; i < num_subbands; i++)
    {
      if (QccWAVSubbandPyramidSubbandSize(subband_pyramid,
                                          i,
                                          &subband_num_rows,
                                          &subband_num_cols))
        {
          QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccWAVSubbandPyramidSubbandSize()");
          goto Error;
        }
      
      if (QccWAVSubbandPyramidSubbandOffsets(subband_pyramid,
                                             i,
                                             &row_offset,
                                             &col_offset))
        {
          QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccWAVSubbandPyramidSubbandOffsets()");
        }
      
      if ((i % 3) == 2)
        for (col = 0; col < subband_num_cols; col++)
          for (row = 0; row < subband_num_rows; row++)
            {
              if (mask_subband_pyramid == NULL)
                transparent = 0;
              else
                transparent =
                  QccAlphaTransparent(mask_subband_pyramid->matrix
                                      [row + row_offset][col + col_offset]);
              if (!transparent)
                {
                  (*virtual_end)++;
                  coefficient_block.row = row + row_offset;
                  coefficient_block.col = col + col_offset;
                  coefficient_block.index = current_index;
                  current_index++;
                  if ((new_node =
                       QccListCreateNode(sizeof(QccWAVwdrCoefficientBlock),
                                         (void *)(&coefficient_block))) == NULL)
                    {
                      QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccListCreateNode()");
                      goto Error;
                    }
                  
                  if (QccListAppendNode(ICS, new_node))
                    {
                      QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccListAppendNode()");
                      goto Error;
                    }
                }
            }
      else
        for (row = 0; row < subband_num_rows; row++)
          for (col = 0; col < subband_num_cols; col++)
            {
              if (mask_subband_pyramid == NULL)
                transparent = 0;
              else
                transparent =
                  QccAlphaTransparent(mask_subband_pyramid->matrix
                                      [row + row_offset][col + col_offset]);
              if (!transparent)
                {
                  (*virtual_end)++;
                  coefficient_block.row = row + row_offset;
                  coefficient_block.col = col + col_offset;
                  coefficient_block.index = current_index;
                  current_index++;
                  if ((new_node =
                       QccListCreateNode(sizeof(QccWAVwdrCoefficientBlock),
                                         (void *)(&coefficient_block))) ==
                      NULL)
                    {
                      QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccListCreateNode()");
                      goto Error;
                    }
                  
                  if (QccListAppendNode(ICS, new_node))
                    {
                      QccErrorAddMessage("(QccWAVwdrAlgorithmInitialize): Error calling QccListAppendNode()");
                      goto Error;
                    }
                }
            }
    }
  
  (*virtual_end)++;

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdrInputOutputRefinementBit(QccWAVSubbandPyramid
                                             *subband_pyramid,
                                             QccBitBuffer *buffer, 
                                             double threshold,
                                             QccWAVwdrCoefficientBlock
                                             *coefficient,
                                             int method,
                                             QccENTArithmeticModel *model, 
                                             int target_bit_cnt) 
{
  int bit, return_value;
  
  if (method == QCCWAVWDR_ENCODE)
    {
      bit =
        (subband_pyramid->matrix[coefficient->row][coefficient->col] >=
         threshold);
      
      if (bit)
        subband_pyramid->matrix[coefficient->row][coefficient->col] -=
          threshold;
    }
  
  if (model != NULL)
    if (QccENTArithmeticSetModelContext(model, QCCWAVWDR_REFINEMENT_CONTEXT))
      {
        QccErrorAddMessage("(QccWAVwdrInputOutputRefinementBit): Error calling QccENTArithmeticSetModelContext()");
        goto Error;
      }

  if ((return_value = QccWAVwdrInputOutput(buffer,
                                           &bit,
                                           method,
                                           model,
                                           target_bit_cnt)))
    {
      if (return_value == 2)
        return(2);
      else
        {
          QccErrorAddMessage("(QccWAVwdrInputOutputRefinementBit): Error calling QccWAVwdrInputOutput()");
          goto Error;
        }
    }
  
  if (method == QCCWAVWDR_DECODE)
    subband_pyramid->matrix[coefficient->row][coefficient->col] += 
      (bit) ? (threshold / 2) : (-threshold / 2);
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdrOutputRunLength(QccWAVSubbandPyramid *subband_pyramid,
                                    QccBitBuffer *buffer,
                                    QccWAVwdrCoefficientBlock
                                    *coefficient_block,
                                    double threshold,
                                    int target_bit_cnt,
                                    unsigned int *relative_origin,
                                    unsigned char *significant,
                                    QccENTArithmeticModel *model)
{
  int return_value;
  int row, col, reduced_bits;
  unsigned int run_length, temp;
  
  row = coefficient_block->row;
  col = coefficient_block->col;
  
  if (subband_pyramid->matrix[row][col] >= threshold)
    {
      *significant = TRUE;
      run_length = coefficient_block->index - *relative_origin;
      *relative_origin = coefficient_block->index;
      temp = run_length;
      reduced_bits = 0;
      
      while (temp != 0)
        {
          temp >>= 1;
          reduced_bits++;
        }
      
      reduced_bits--;
      
      if (model != NULL)
        if (QccENTArithmeticSetModelContext(model, QCCWAVWDR_RUN_CONTEXT))
          {
            QccErrorAddMessage("(QccWAVwdrOutputRunLength): Error calling QccENTArithmeticSetModelContext()");
            goto Error;
          }
      
      if ((return_value = QccWAVwdrOutputSymbol(buffer,
                                                run_length,
                                                reduced_bits,
                                                target_bit_cnt,
                                                model)))
        {
          if (return_value == 2)
            return(2);
          else
            {
              QccErrorAddMessage("(QccWAVwdrOutputRunLength): Error calling QccWAVwdrOutputSymbol()");
              goto Error;
            }
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdrInputRunLength(QccWAVSubbandPyramid *subband_pyramid,
                                   QccBitBuffer *buffer,
                                   unsigned int *relative_origin,
                                   int *sign,
                                   QccENTArithmeticModel *model)
{
  int return_value;
  unsigned int run_length;
  
  if (model != NULL)
    if (QccENTArithmeticSetModelContext(model, QCCWAVWDR_RUN_CONTEXT))
      {
        QccErrorAddMessage("(QccWAVwdrInputRunLength): Error calling QccENTArithmeticSetModelContext()");
        goto Error;
      }
  
  if ((return_value = QccWAVwdrInputSymbol(buffer, &run_length, sign, model)))
    {
      if (return_value == 2)
        return(2);
      else
        {
          QccErrorAddMessage("(QccWAVwdrInputRunLength): Error calling QccWAVwdrInputSymbol()");
          goto Error;
        }
    }
  *relative_origin += run_length;	
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdrAddNodeToTPS(QccList *TPS,
                                 int row,
                                 int col,
                                 QccWAVSubbandPyramid *subband_pyramid,
                                 double threshold,
                                 int **sign_array,
                                 QccBitBuffer *buffer,
                                 int method,
                                 int target_bit_cnt,
                                 QccENTArithmeticModel *model)
{
  int return_value, symbol;
  QccWAVwdrCoefficientBlock coefficient_block;
  QccListNode *new_node = NULL;
  
  coefficient_block.row = row;
  coefficient_block.col = col;
  coefficient_block.index = 0;
  if ((new_node = QccListCreateNode(sizeof(QccWAVwdrCoefficientBlock),
                                    (void *)(&coefficient_block))) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdrAddNodeToTPS): Error calling QccListCreateNode()");
      goto Error;
    }
  
  if (QccListAppendNode(TPS, new_node))
    {
      QccErrorAddMessage("(QccWAVwdrAddNodeToTPS): Error calling QccListAppendNode()");
      goto Error;
    }
  
  if (method == QCCWAVWDR_ENCODE)
    {
      if (sign_array[row][col] == 0)
        symbol = POSITIVE;
      else
        symbol = NEGATIVE;
      
      if ((return_value = QccWAVwdrInputOutput(buffer,
                                               &symbol,
                                               QCCWAVWDR_ENCODE,
                                               model,
                                               target_bit_cnt)))
        {
          if (return_value == 2)
            return(2);
          else
            {
              QccErrorAddMessage("(QccWAVwdrAddNodeToTPS): Error calling QccWAVwdrInputOutput()");
              goto Error;
            }
        }
      
      subband_pyramid->matrix[row][col] -= threshold;		
    }
  else
    subband_pyramid->matrix[row][col] = 1.5 * threshold;
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdrSortingPass(QccWAVSubbandPyramid *subband_pyramid,