klttce3d.c

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

                    sign_array
                      [subband_origin_frame+frame]
                      [subband_origin_row + row]
                      [subband_origin_col + col] = 1;
                  }
                else
                  sign_array
                    [subband_origin_frame+frame]
                    [subband_origin_row + row]
                    [subband_origin_col + col] = 0;
          
                if (coefficient_magnitude > max_coefficient)
                  max_coefficient = coefficient_magnitude;
              }
 
          max_coefficient_bits[subband][frame] = 
            (int)floor(QccMathMax(0, QccMathLog2(max_coefficient + 0.0001)));
        }
    }
       
  return(0);
}


static int QccWAVklttce3DInverseTransform(QccWAVSubbandPyramid3D
                                          *image_subband_pyramid,
                                          char ***sign_array,
                                          QccIMGImageCube *image,
                                          const QccWAVWavelet *wavelet,
                                          const QccHYPklt *klt)
{
  int frame, row, col;

  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 (sign_array[frame][row][col])
          image_subband_pyramid->volume[frame][row][col] *= -1;
  
  if (QccWAVklttceInverseKLTDWT(image_subband_pyramid,
                                wavelet, 
                                image_subband_pyramid->spatial_num_levels,
                                klt))
    {
      QccErrorAddMessage("(QccWAVklttce3DInverseTransform): Error calling QccWAVklttceInverseKLTDWT()");
      return(1);
    }
  
  if (QccVolumeCopy(image->volume,
                    image_subband_pyramid->volume,
                    image->num_frames,
                    image->num_rows,
                    image->num_cols))
    {
      QccErrorAddMessage("(QccWAVklttce3DInverseTransform): Error calling QccVolumeCopy()");
      return(1);
    }
  
  if (QccIMGImageCubeSetMaxMin(image))
    {
      QccErrorAddMessage("(QccWAVklttce3DInverseTransform): QccError calling QccIMGImageCubeSetMaxMin()");
      return(1);
    }

  return(0);
}


int QccWAVklttce3DEncodeHeader(QccBitBuffer *buffer, 
                               int num_levels,
                               int num_frames,
                               int num_rows,
                               int num_cols,
                               int *max_coefficient_bits,
                               double alpha)
{
  int return_value;
  
  if (QccBitBufferPutChar(buffer, (unsigned char)num_levels))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPuChar()");
      goto Error;
    }
  
  if (QccBitBufferPutInt(buffer, num_frames))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPut()");
      goto Error;
    }
  
  if (QccBitBufferPutInt(buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPut()");
      goto Error;
    }
  
  if (QccBitBufferPutInt(buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPutInt()");
      goto Error;
    }

  if (QccBitBufferPutInt(buffer, max_coefficient_bits[0]))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPutInt()");
      goto Error;
    }

  if (QccBitBufferPutDouble(buffer, alpha))
    {
      QccErrorAddMessage("(QccWAVklttce3DEncodeHeader): Error calling QccBitBufferPutDouble()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


static int QccWAVklttce3DEncodeKLT(QccBitBuffer *buffer,
                                   const QccHYPklt *klt)
{
  int band1, band2;

  for (band1 = 0; band1 < klt->num_bands; band1++)
    if (QccBitBufferPutDouble(buffer, klt->mean[band1]))
      {
        QccErrorAddMessage("(QccWAVklttce3DEncodeKLT): Error calling QccBitBufferPutInt()");
        return(1);
      }

  for (band1 = 0; band1 < klt->num_bands; band1++)
    for (band2 = 0; band2 < klt->num_bands; band2++)
      if (QccBitBufferPutDouble(buffer, klt->matrix[band1][band2]))
        {
          QccErrorAddMessage("(QccWAVklttce3DEncodeKLT): Error calling QccBitBufferPutDouble()");
          return(1);
        }

  return(0);
}


static int QccWAVklttce3DDecodeKLT(QccBitBuffer *buffer,
                                   QccHYPklt *klt)
{
  int band1, band2;

  for (band1 = 0; band1 < klt->num_bands; band1++)
    if (QccBitBufferGetDouble(buffer, &klt->mean[band1]))
      {
        QccErrorAddMessage("(QccWAVklttce3DEncodeKLT): Error calling QccBitBufferGetInt()");
        return(1);
      }

  for (band1 = 0; band1 < klt->num_bands; band1++)
    for (band2 = 0; band2 < klt->num_bands; band2++)
      if (QccBitBufferGetDouble(buffer, &klt->matrix[band1][band2]))
        {
          QccErrorAddMessage("(QccWAVklttce3DEncodeKLT): Error calling QccBitBufferGetDouble()");
          return(1);
        }

  return(0);
}


static int QccWAVklttce3DRevEst(QccWAVSubbandPyramid3D *coefficients,
                                char ***significance_map,
                                int subband,
                                double *subband_significance,
                                double ***p,
                                double alpha)
{
  int return_value;
  int subband_origin_frame;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_frames;
  int subband_num_rows;
  int subband_num_cols;
  int frame,row, col;
  int current_frame,current_row, current_col;
  QccMatrix p1=NULL;
  QccVector p2 = NULL;
  QccMatrix p3=NULL;
  QccMatrix p4=NULL;
  QccVector p5 = NULL;
  char *p_char;
  int v;  
  double filter_coef;
  
  filter_coef = (1 - alpha) * (1 - alpha)*(1 - alpha) / (3*alpha + alpha*alpha*alpha)/3;
  
  subband_significance[subband] = 0.0;
  if (QccWAVSubbandPyramid3DSubbandSize(coefficients,
                                        subband,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      goto Error;
    }
  if (QccWAVSubbandPyramid3DSubbandOffsets(coefficients,
                                           subband,
                                           &subband_origin_frame,
                                           &subband_origin_row,
                                           &subband_origin_col))
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
      goto Error;
    }
  
  if ((p1 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p2 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((p3 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p4 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p5 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DRevEst): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < subband_num_rows; row++)
    for (col = 0; col < subband_num_cols; col++)
      p3[row][col]=QCCWAVKLTTCE3D_BOUNDARY_VALUE;  

  for (frame = subband_num_frames-1;frame >= 0; frame--)
    {//bbb
      current_frame=subband_origin_frame+frame;

      for (col = 0; col < subband_num_cols; col++)
        p2[col] = QCCWAVKLTTCE3D_BOUNDARY_VALUE; 
       
      for (row = subband_num_rows - 1; row >= 0; row--)
        {//bb
           
          current_row = subband_origin_row + row;
          for (col = subband_num_cols - 1; col >= 0; col--)
            {       
              current_col = subband_origin_col + col;
              p_char = &(significance_map[current_frame][current_row][current_col]);
              if (col == (subband_num_cols-1) )
                p[current_frame][current_row][current_col] =alpha * (QCCWAVKLTTCE3D_BOUNDARY_VALUE + p2[col] + p3[row][col]);
              else
                p[current_frame][current_row][current_col] =alpha *(p1[row][col+1]+p2[col]+p3[row][col]);
                 
              
              if (*p_char == QCCWAVKLTTCE3D_S)
                {
                  if (col == subband_num_cols-1 )
                    p1[row][col] = alpha *  p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col] + filter_coef * QCCWAVKLTTCE3D_REFINE_HOLDER;
                  else

                    p1[row][col] = alpha * p1[row][col+1] + filter_coef * QCCWAVKLTTCE3D_REFINE_HOLDER;
                   
                  subband_significance[subband] += QCCWAVKLTTCE3D_REFINE_HOLDER;
                }
              else
                {
                  v = (*p_char == QCCWAVKLTTCE3D_S_NEW);
                  if (col == (subband_num_cols-1) )
                    p1[row][col] = alpha *   p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col]   + filter_coef * v;
                  else

                    p1[row][col] = alpha * p1[row][col+1] + filter_coef * v;
                   
                  subband_significance[subband] += v;
                }   
              p2[col] = p1[row][col] + alpha * p2[col];   
            }
      
          for (col = 0; col < subband_num_cols; col++)
            {
              p_char = &(significance_map[current_frame][current_row][subband_origin_col + col]);
              if (col==0)
                p2[col] = p2[col] + alpha *  p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col] ;
              else
                p2[col] = p2[col] + alpha * p4[row][col-1];
               
              if (*p_char == QCCWAVKLTTCE3D_S)
                {
                  if (col==0)
                    p4[row][col] = alpha * p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col]  + filter_coef * QCCWAVKLTTCE3D_REFINE_HOLDER;
                  else 
                    p4[row][col] = alpha * p4[row][col-1] + filter_coef * QCCWAVKLTTCE3D_REFINE_HOLDER;
                }
              else
                {
                  v = (*p_char == QCCWAVKLTTCE3D_S_NEW);
                  if (col==0)
                    p4[row][col] = alpha *  p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col]  + filter_coef * v;
                  else 
                    p4[row][col] = alpha* p4[row][col-1] + filter_coef *v;
                }        
            }
        }//bb
      for (col = 0; col < subband_num_cols; col++)
        p5[col] = p[subband_origin_frame+frame][subband_origin_row][subband_origin_col + col];
      for (row = 0; row < subband_num_rows; row++)
        for (col = 0; col < subband_num_cols; col++)
          {
            p3[row][col]=p3[row][col]+alpha*p5[col];
            if (col==0)
              p5[col]=p1[row][col]+alpha*p5[col]+alpha* p[subband_origin_frame+frame][subband_origin_row +row][subband_origin_col + col] ;
            else
              p5[col]=p1[row][col]+alpha*p5[col]+alpha*p4[row][col-1];
          }
    }//bbb
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(p2);
  QccVectorFree(p5);
  QccMatrixFree(p1,subband_num_rows);