wdr3d.c

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

          }
        
        if (significant == TRUE)
          {
            if ((return_value =
                 QccWAVwdr3DAddNodeToTPS(TPS,
                                         current_coefficient_block->frame,
                                         current_coefficient_block->row,
                                         current_coefficient_block->col,
                                         subband_pyramid,
                                         threshold,
                                         sign_array,
                                         buffer,
                                         method,
                                         target_bit_cnt,
                                         model)))
              {
                if (return_value == 2)
                  return(2);
                else
                  {
                    QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccWAVwdr3DAddNodeToTPS()");
                    goto Error;
                  }
              }
            
            if (QccListDeleteNode(ICS, current_list_node))
              {
                QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccListDeleteNode()");
                goto Error;
              }
          }
        
        current_list_node = next_list_node;
      }
  else
    {
      while (*relative_origin != virtual_end)
        {
          if ((return_value = QccWAVwdr3DInputRunLength(subband_pyramid,
                                                        buffer,
                                                        relative_origin,
                                                        &sign,
                                                        model)))
            {
              if (return_value == 2)
                return(2);
              else
                {
                  QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccWAVwdr3DInputRunLength()");
                  goto Error;
                }
            }
          
          if (*relative_origin == virtual_end)
            break;
          
          if (*relative_origin > virtual_end)
            {
              QccErrorAddMessage("(QccWAVwdr3DSortingPass): Synchronization Error In Decoding");
              goto Error;
            }
          
          current_coefficient_block =
            QccWAVwdr3DGetCoefficientBlockFromNode(current_list_node);
          
          while (current_coefficient_block->index != *relative_origin)
            {
              current_list_node = current_list_node->next;
              current_coefficient_block =
                QccWAVwdr3DGetCoefficientBlockFromNode(current_list_node);
            }
          
          if (QccWAVwdr3DAddNodeToTPS(TPS,
                                      current_coefficient_block->frame,
                                      current_coefficient_block->row,
                                      current_coefficient_block->col,
                                      subband_pyramid,
                                      threshold,
                                      sign_array,
                                      buffer,
                                      method,
                                      target_bit_cnt,
                                      model))
            {
              QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccWAVwdr3DAddNodeToTPS()");
              goto Error;
            }
          
          if (sign == POSITIVE)
            QccWAVwdr3DPutSign(&sign_array[current_coefficient_block->frame]
                               [current_coefficient_block->row]
                               [current_coefficient_block->col],
                               POSITIVE);
          else
            QccWAVwdr3DPutSign(&sign_array[current_coefficient_block->frame]
                               [current_coefficient_block->row]
                               [current_coefficient_block->col],
                               NEGATIVE);
          
          next_list_node = current_list_node->next;
          if (QccListDeleteNode(ICS, current_list_node))
            {
              QccErrorAddMessage("(QccWAVwdr3DSortingPass): Error calling QccListDeleteNode()");
              goto Error;
            }
          current_list_node = next_list_node;
        }
      
      if (sign == NEGATIVE)
        {
          QccErrorAddMessage("(QccWAVwdr3DSortingPass): Synchronization Error In Decoding");
          goto Error;
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVwdr3DOutputVirtualEnd(QccBitBuffer *buffer,
                                       unsigned int relative_origin,
                                       unsigned int virtual_end,
                                       int target_bit_cnt, 
                                       QccENTArithmeticModel *model)
{
  unsigned int run_length, temp;
  int symbol = POSITIVE, reduced_bits, return_value;
  
  run_length = virtual_end - relative_origin;
  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("(QccWAVwdr3DOutputVirtualEnd): 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("(QccWAVwdr3DOutputVirtualEnd): Error calling QccWAVwdr3DOutputSymbol()");
          goto Error;
        }
    }
  
  if ((return_value = QccWAVwdr3DInputOutput(buffer,
                                             &symbol,
                                             QCCWAVWDR3D_ENCODE,
                                             model,
                                             target_bit_cnt)))
    {
      if (return_value == 2)
        return(2);
      else
        {
          QccErrorAddMessage("(QccWAVwdr3DOutputVirtualEnd): Error calling QccWAVwdr3DInputOutput()");
          goto Error;
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


static int QccWAVwdr3DUpdateIndex(QccList *ICS)
{
  QccListNode *current_node, *stop;
  QccWAVwdr3DCoefficientBlock *current_coefficient;
  unsigned int adjust_index = 1;
  
  current_node = ICS->start;
  stop = ICS->end;
  if ((current_node == NULL) || (stop == NULL))
    return(0);
  stop = stop->next;
  
  while (current_node != stop)
    {
      current_coefficient =
        QccWAVwdr3DGetCoefficientBlockFromNode(current_node);
      current_coefficient->index = adjust_index;
      adjust_index++;
      current_node = current_node->next;
    }
  
  return(0);
}


static int QccWAVwdr3DRefinementPass(QccWAVSubbandPyramid3D *subband_pyramid,
                                     QccBitBuffer *buffer,
                                     double threshold, 
                                     QccList *SCS,
                                     QccListNode *stop,
                                     int method,
                                     int target_bit_cnt,
                                     QccENTArithmeticModel *model)
{
  QccListNode *current_node;
  QccWAVwdr3DCoefficientBlock *current_coefficient;
  int return_value;
  
  current_node = SCS->start;
  if ((current_node == NULL) || (stop == NULL))
    return(0);
  stop = stop->next;
  
  while (current_node != stop)
    {
      current_coefficient = QccWAVwdr3DGetCoefficientBlockFromNode(current_node);
      
      if ((return_value =
           QccWAVwdr3DInputOutputRefinementBit(subband_pyramid,
                                               buffer,
                                               threshold,
                                               current_coefficient,
                                               method,
                                               model,
                                               target_bit_cnt)))
        {
          if (return_value == 2)
            return(2);
          else
            {
              QccErrorAddMessage("(QccWAVwdr3DRefinementPass): Error calling QccWAVwdr3DInputOutputRefinementBit()");
              goto Error;
            }
        }
      
      current_node = current_node->next;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);    
}


int QccWAVwdr3DEncode(QccIMGImageCube *image_cube,
                      QccIMGImageCube *mask,
                      int transform_type,
                      int temporal_num_levels,
                      int spatial_num_levels,
                      const QccWAVWavelet *wavelet,
                      QccBitBuffer *output_buffer,
                      int target_bit_cnt)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid3D image_subband_pyramid;
  QccWAVSubbandPyramid3D mask_subband_pyramid;
  unsigned char ***sign_array = NULL;
  double image_mean=0;
  int max_coefficient_bits;
  double threshold;
  int frame;
  int row, col;
  
  QccList ICS;
  QccList SCS;
  QccList TPS;
  QccListNode *stop;
  unsigned int relative_origin;
  unsigned int virtual_end;
  int bitplane = 0;
  
  if (image_cube == NULL)
    return(0);
  if (output_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccListInitialize(&ICS);
  QccListInitialize(&SCS);
  QccListInitialize(&TPS);
  QccWAVSubbandPyramid3DInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramid3DInitialize(&mask_subband_pyramid);
  
  image_subband_pyramid.temporal_num_levels = 0;
  image_subband_pyramid.spatial_num_levels = 0;
  image_subband_pyramid.num_frames = image_cube->num_frames;
  image_subband_pyramid.num_rows = image_cube->num_rows;
  image_subband_pyramid.num_cols = image_cube->num_cols;
  image_subband_pyramid.transform_type = transform_type;
  
  if (QccWAVSubbandPyramid3DAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVSubbandPyramid3DAlloc()");
      goto Error;
    } 
  
  if (mask != NULL)
    {
      if ((mask->num_frames != image_cube->num_frames) ||
          (mask->num_rows != image_cube->num_rows) ||
          (mask->num_cols != image_cube->num_cols))
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Mask and image must be same size");
          goto Error;
        }
      
      mask_subband_pyramid.temporal_num_levels = 0;
      mask_subband_pyramid.spatial_num_levels = 0;
      mask_subband_pyramid.num_frames = mask->num_frames;
      mask_subband_pyramid.num_rows = mask->num_rows;
      mask_subband_pyramid.num_cols = mask->num_cols;
      
      if (QccWAVSubbandPyramid3DAlloc(&mask_subband_pyramid))
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVSubbandPyramid3DAlloc()");
          goto Error;
        }
    }
  
  if ((sign_array =
       (unsigned char ***)malloc(sizeof(unsigned char **) *
                                 (image_cube->num_frames))) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error allocating memory");
      goto Error;
    }
  for (frame = 0; frame < image_cube->num_frames; frame++)
    {
      if ((sign_array[frame] =
           (unsigned char **)malloc(sizeof(unsigned char *) *
                                    (image_cube->num_rows))) == NULL)
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error allocating memory");
          goto Error;
        }
      for (row = 0; row < image_cube->num_rows; row++)
        if ((sign_array[frame][row] =
             (unsigned char *)malloc(sizeof(unsigned char) *
                                     (image_cube->num_cols))) == NULL)
          {
            QccErrorAddMessage("(QccWAVwdr3DEncode): Error allocating memory");
            goto Error;
          }
    } 
  
  for (frame = 0; frame < (image_cube->num_frames); frame++)
    for (row = 0; row < (image_cube->num_rows); row++)
      for (col = 0; col < (image_cube->num_cols); col++)
        sign_array[frame][row][col] = ZERO;
  
  if (QccWAVwdr3DEncodeDWT(&image_subband_pyramid,
                           sign_array,
                           image_cube,
                           transform_type,
                           temporal_num_levels,
                           spatial_num_levels,
                           &image_mean,
                           &max_coefficient_bits,
                           ((mask != NULL) ? &mask_subband_pyramid : NULL),
                           mask,
                           wavelet))                          
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DEncodeDWT()");
      goto Error;
    }
  
  
  if (QccWAVwdr3DEncodeHeader(output_buffer,
                              transform_type,
                              temporal_num_levels,
                              spatial_num_levels,
                              image_cube->num_frames,
                              image_cube->num_rows,
                              image_cube->num_cols,
                              image_mean,
                              max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DEncodeHeader()");
      goto Error;
    }
  
  if ((model = QccENTArithmeticEncodeStart(QccWAVwdr3DArithmeticContexts,
                                           QCCWAVWDR3D_NUM_CONTEXTS,
                                           NULL,
                                           QCCENT_ANYNUMBITS)) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccENTArithmeticEncodeStart()");
      goto Error;
    }
  
  if (QccWAVwdr3DAlgorithmInitialize(&image_subband_pyramid,
                                     ((mask != NULL) ?
                                      &mask_subband_pyramid : NULL),
                                     &ICS,
                                     &virtual_end))
    {
      QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DAlgorithmInitialize()");
      goto Error;
    }
  threshold = pow((double)2, (double)max_coefficient_bits);