wdr3d.c

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

          image_subband_pyramid->volume[frame][row][col] *= -1;
  
  if (mask_subband_pyramid != NULL)
    {
      if (QccWAVSubbandPyramid3DInverseShapeAdaptiveDWT(image_subband_pyramid,
                                                        mask_subband_pyramid,
                                                        wavelet))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DInverseShapeAdaptiveDWT()");
          return(1);
        }
    }
  else
    if (QccWAVSubbandPyramid3DInverseDWT(image_subband_pyramid,
                                         wavelet))
      {
        QccErrorAddMessage("(QccWAVwdr3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DInverseDWT()");
        return(1);
      }
  
  if (QccWAVSubbandPyramid3DAddMean(image_subband_pyramid,
                                    image_mean))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DAddMean()");
      return(1);
    }
  
  if (mask_subband_pyramid != NULL)
    for (frame = 0; frame < image_subband_pyramid->num_frames; frame++)
      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->volume
                                  [frame][row][col]))
            image_subband_pyramid->volume[frame][row][col] = 0;
  
  if (QccVolumeCopy(image_cube->volume,
                    image_subband_pyramid->volume,
                    image_cube->num_frames,
                    image_cube->num_rows,
                    image_cube->num_cols))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeInverseDWT): Error calling QccVolumeCopy()");
      return(1);
    }
  
  if (QccIMGImageCubeSetMaxMin(image_cube))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeInverseDWT): Error calling QccIMGImageCubeSetMaxMin()");
      return(1);
    }
  
  return(0);
}


static int QccWAVwdr3DAlgorithmInitialize(QccWAVSubbandPyramid3D *coefficients,
                                          const QccWAVSubbandPyramid3D *mask,
                                          QccList *ICS,
                                          unsigned int *virtual_end)
{
  int return_value;
  int subband_num_frames, subband_num_rows, subband_num_cols;
  int frame_offset, row_offset, col_offset;
  int frame, row, col, num_subbands, i;
  unsigned int current_index = 1;
  QccWAVwdr3DCoefficientBlock coefficient_block;
  QccListNode *new_node;
  int transparent;
  
  *virtual_end = 0;
  
  if (coefficients->transform_type == QCCWAVSUBBANDPYRAMID3D_DYADIC)
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsDyadic(coefficients->spatial_num_levels);
  else
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsPacket(coefficients->temporal_num_levels,
                                                         coefficients->spatial_num_levels);
  
  for (i = 0; i < num_subbands; i++)
    {
      if (QccWAVSubbandPyramid3DSubbandSize(coefficients,
                                            i,
                                            &subband_num_frames,
                                            &subband_num_rows,
                                            &subband_num_cols))
        {
          QccErrorAddMessage("(QccWAVwdr3DAlgorithmInitialize): Error calling QccWAVSubbandPyramid3DSubbandSize()");
          goto Error;
        }
      
      if (QccWAVSubbandPyramid3DSubbandOffsets(coefficients,
                                               i,
                                               &frame_offset,
                                               &row_offset,
                                               &col_offset))
        {
          QccErrorAddMessage("(QccWAVwdr3DAlgorithmInitialize): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
        }
      
      for (frame = 0; frame < subband_num_frames; frame++)
        for (col = 0; col < subband_num_cols; col++)
          for (row = 0; row < subband_num_rows; row++)
            {
              if (mask == NULL)
                transparent = 0;
              else
                transparent =
                  QccAlphaTransparent(mask->volume
                                      [frame + frame_offset]
                                      [row + row_offset]
                                      [col + col_offset]);
              if (!transparent)
                {
                  (*virtual_end)++;
                  coefficient_block.frame = frame + frame_offset;
                  coefficient_block.row = row + row_offset;
                  coefficient_block.col = col + col_offset;
                  coefficient_block.index = current_index;
                  current_index++;
                  if ((new_node =
                       QccListCreateNode(sizeof(QccWAVwdr3DCoefficientBlock),
                                         (void *)(&coefficient_block))) ==
                      NULL)
                    {
                      QccErrorAddMessage("(QccWAVwdr3DAlgorithmInitialize): Error calling QccListCreateNode()");
                      goto Error;
                    }
                  
                  if (QccListAppendNode(ICS, new_node))
                    {
                      QccErrorAddMessage("(QccWAVwdr3DAlgorithmInitialize): Error calling QccListAppendNode()");
                      goto Error;
                    }
                }
            }
    }
  
  (*virtual_end)++;
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdr3DInputOutputRefinementBit(QccWAVSubbandPyramid3D
                                               *subband_pyramid,
                                               QccBitBuffer *buffer, 
                                               double threshold,
                                               QccWAVwdr3DCoefficientBlock
                                               *coefficient,
                                               int method,
                                               QccENTArithmeticModel *model, 
                                               int target_bit_cnt) 
{
  int bit, return_value;
  
  if (method == QCCWAVWDR3D_ENCODE)
    {
      bit =
        (subband_pyramid->volume
         [coefficient->frame][coefficient->row][coefficient->col] >=
         threshold);
      
      if (bit)
        subband_pyramid->volume
          [coefficient->frame][coefficient->row][coefficient->col] -=
          threshold;
    }
  
  if (model != NULL)
    if (QccENTArithmeticSetModelContext(model, QCCWAVWDR3D_REFINEMENT_CONTEXT))
      {
        QccErrorAddMessage("(QccWAVwdr3DInputOutputRefinementBit): Error calling QccENTArithmeticSetModelContext()");
        goto Error;
      }
  
  if ((return_value = QccWAVwdr3DInputOutput(buffer,
                                             &bit,
                                             method,
                                             model,
                                             target_bit_cnt)))
    {
      if (return_value == 2)
        return(2);
      else
        {
          QccErrorAddMessage("(QccWAVwdr3DInputOutputRefinementBit): Error calling QccWAVwdr3DInputOutput()");
          goto Error;
        }
    }
  
  if (method == QCCWAVWDR3D_DECODE)
    subband_pyramid->volume
      [coefficient->frame][coefficient->row][coefficient->col] += 
      (bit) ? (threshold / 2) : (-threshold / 2);
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdr3DOutputRunLength(QccWAVSubbandPyramid3D *subband_pyramid,
                                      QccBitBuffer *buffer,
                                      QccWAVwdr3DCoefficientBlock
                                      *coefficient_block,
                                      double threshold,
                                      int target_bit_cnt,
                                      unsigned int *relative_origin,
                                      unsigned char *significant,
                                      QccENTArithmeticModel *model)
{
  int return_value;
  int frame, row, col, reduced_bits;
  unsigned int run_length, temp;
  
  frame = coefficient_block->frame;
  row = coefficient_block->row;
  col = coefficient_block->col;
  
  if (subband_pyramid->volume[frame][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, QCCWAVWDR3D_RUN_CONTEXT))
          {
            QccErrorAddMessage("(QccWAVwdr3DOutputRunLength): Error calling QccENTArithmeticSetModelContext()");
            goto Error;
          }
      
      if ((return_value = QccWAVwdr3DOutputSymbol(buffer,
                                                  run_length,
                                                  reduced_bits,
                                                  target_bit_cnt,
                                                  model)))
        {
          if (return_value == 2)
            return(2);
          else
            {
              QccErrorAddMessage("(QccWAVwdr3DOutputRunLength): Error calling QccWAVwdr3DOutputSymbol()");
              goto Error;
            }
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdr3DInputRunLength(QccWAVSubbandPyramid3D *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, QCCWAVWDR3D_RUN_CONTEXT))
      {
        QccErrorAddMessage("(QccWAVwdr3DInputRunLength): Error calling QccENTArithmeticSetModelContext()");
        goto Error;
      }
  
  if ((return_value =
       QccWAVwdr3DInputSymbol(buffer, &run_length, sign, model)))
    {
      if (return_value == 2)
        return(2);
      else
        {
          QccErrorAddMessage("(QccWAVwdr3DInputRunLength): Error calling QccWAVwdr3DInputSymbol()");
          goto Error;
        }
    }
  *relative_origin += run_length;
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdr3DAddNodeToTPS(QccList *TPS,
                                   int frame,
                                   int row,
                                   int col,
                                   QccWAVSubbandPyramid3D *subband_pyramid,
                                   double threshold,
                                   unsigned char ***sign_array,
                                   QccBitBuffer *buffer,
                                   int method,
                                   int target_bit_cnt,
                                   QccENTArithmeticModel *model)
{
  int return_value, symbol;
  QccWAVwdr3DCoefficientBlock coefficient_block;
  QccListNode *new_node = NULL;
  
  coefficient_block.frame = frame;
  coefficient_block.row = row;
  coefficient_block.col = col;
  coefficient_block.index = 0;
  
  if ((new_node = QccListCreateNode(sizeof(QccWAVwdr3DCoefficientBlock),
                                    (void *)(&coefficient_block))) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdr3DAddNodeToTPS): Error calling QccListCreateNode()");
      goto Error;
    }
  
  if (QccListAppendNode(TPS, new_node))
    {
      QccErrorAddMessage("(QccWAVwdr3DAddNodeToTPS): Error calling QccListAppendNode()");
      goto Error;
    }
  
  if (method == QCCWAVWDR3D_ENCODE)
    {
      symbol = QccWAVwdr3DGetSign(sign_array[frame][row][col]);
      
      if ((return_value = QccWAVwdr3DInputOutput(buffer,
                                                 &symbol,
                                                 QCCWAVWDR3D_ENCODE,
                                                 model,
                                                 target_bit_cnt)))
        {
          if (return_value == 2)
            return(2);
          else
            {
              QccErrorAddMessage("(QccWAVwdr3DAddNodeToTPS): Error calling QccWAVwdr3DInputOutput()");
              goto Error;
            }
        }
      
      subband_pyramid->volume[frame][row][col] -= threshold;
    }
  else
    subband_pyramid->volume[frame][row][col] = 1.5 * threshold;
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdr3DSortingPass(QccWAVSubbandPyramid3D *subband_pyramid,
                                  unsigned char ***sign_array,
                                  QccBitBuffer *buffer,
                                  double threshold,
                                  QccList *ICS,
                                  QccList *TPS,
                                  int method, 
                                  int target_bit_cnt,
                                  unsigned int *relative_origin,
                                  unsigned int virtual_end,
                                  QccENTArithmeticModel *model)
{
  int sign = 0;
  int return_value;
  unsigned char significant;
  QccWAVwdr3DCoefficientBlock *current_coefficient_block;
  QccListNode *current_list_node;
  QccListNode *next_list_node;
  
  current_list_node = ICS->start;
  
  if (method == QCCWAVWDR3D_ENCODE)
    while (current_list_node != NULL)
      {
        next_list_node = current_list_node->next;
        current_coefficient_block =
          QccWAVwdr3DGetCoefficientBlockFromNode(current_list_node);
        significant = FALSE;
        
        if ((return_value =
             QccWAVwdr3DOutputRunLength(subband_pyramid,
                                        buffer,
                                        current_coefficient_block,
                                        threshold,
                                        target_bit_cnt,
                                        relative_origin,
                                        &significant,
                                        model)))
          {
            if (return_value == 2)
              return(2);
            else
              {
                QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccWAVwdr3DOutputRunLength()");
                goto Error;
              }