subband_pyramid3d.c

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

    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DRead): Error calling QccFileOpen()");
      return(1);
    }

  if (QccWAVSubbandPyramid3DReadHeader(infile, subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DRead): Error calling QccWAVSubbandPyramid3DReadHeader()");
      return(1);
    }

  if (QccWAVSubbandPyramid3DAlloc(subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DRead): Error calling QccIMGSubbandPyramidAlloc()");
      return(1);
    }

  for (frame = 0; frame < subband_pyramid->num_frames; frame++)
    for (row = 0; row < subband_pyramid->num_rows; row++)
      for (col = 0; col < subband_pyramid->num_cols; col++)
        if (QccFileReadDouble(infile,
                              &(subband_pyramid->volume[frame][row][col])))
          {
            QccErrorAddMessage("(QccWAVSubbandPyramid3DRead): Error calling QccFileReadDouble()",
                               subband_pyramid->filename);
            return(1);
          }

  QccFileClose(infile);
  return(0);
}


static int QccWAVSubbandPyramid3DWriteHeader(FILE *outfile,
                                             const QccWAVSubbandPyramid3D
                                             *subband_pyramid)
{
  if ((outfile == NULL) || (subband_pyramid == NULL))
    return(0);

  if (QccFileWriteMagicNumber(outfile, QCCWAVSUBBANDPYRAMID3D_MAGICNUM))
    goto Error;

  fprintf(outfile, "%d\n", subband_pyramid->transform_type);
  if (ferror(outfile))
    goto Error;

  switch (subband_pyramid->transform_type)
    {
    case QCCWAVSUBBANDPYRAMID3D_DYADIC:
      fprintf(outfile, "%d\n", subband_pyramid->spatial_num_levels);
      if (ferror(outfile))
        goto Error;
      break;
    case QCCWAVSUBBANDPYRAMID3D_PACKET:
      fprintf(outfile, "%d %d\n",
              subband_pyramid->temporal_num_levels,
              subband_pyramid->spatial_num_levels);
      if (ferror(outfile))
        goto Error;
      break;
    default:
      QccErrorAddMessage("(QccWAVSubbandPyramid3DWriteHeader): Unrecognized transform type");
      goto Error;
    }
  
  fprintf(outfile, "%d %d %d\n",
          subband_pyramid->num_cols,
          subband_pyramid->num_rows,
	  subband_pyramid->num_frames);
  if (ferror(outfile))
    goto Error;

  return(0);

 Error:
  QccErrorAddMessage("(QccWAVSubbandPyramid3DWriteHeader): Error writing header to %s",
                     subband_pyramid->filename);
  return(1);
}


int QccWAVSubbandPyramid3DWrite(const QccWAVSubbandPyramid3D *subband_pyramid)
{
  FILE *outfile;
  int frame, row, col;

  if (subband_pyramid == NULL)
    return(0);

  if ((outfile = QccFileOpen(subband_pyramid->filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DWrite): Error calling QccFileOpen()");
      return(1);
    }

  if (QccWAVSubbandPyramid3DWriteHeader(outfile, subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DWrite): Error calling QccWAVSubbandPyramid3DWriteHeader()");
      return(1);
    }

  for (frame = 0; frame < subband_pyramid->num_frames; frame++)
    for (row = 0; row < subband_pyramid->num_rows; row++)
      for (col = 0; col < subband_pyramid->num_cols; col++)
        if (QccFileWriteDouble(outfile,
                               subband_pyramid->volume[frame][row][col]))
          {
            QccErrorAddMessage("(QccWAVSubbandPyramid3DWrite): Error calling QccFileWriteDouble()");
            return(1);
          }

  QccFileClose(outfile);
  return(0);
}


int QccWAVSubbandPyramid3DCopy(QccWAVSubbandPyramid3D *subband_pyramid1,
                               const QccWAVSubbandPyramid3D *subband_pyramid2)
{
  if (subband_pyramid1 == NULL)
    return(0);
  if (subband_pyramid2 == NULL)
    return(0);

  if ((subband_pyramid1->num_rows != subband_pyramid2->num_rows) ||
      (subband_pyramid1->num_cols != subband_pyramid2->num_cols) ||
      (subband_pyramid1->num_frames != subband_pyramid2->num_frames))
    {
      QccWAVSubbandPyramid3DFree(subband_pyramid1);
      subband_pyramid1->num_frames = subband_pyramid2->num_frames;
      subband_pyramid1->num_rows = subband_pyramid2->num_rows;
      subband_pyramid1->num_cols = subband_pyramid2->num_cols;
      if (QccWAVSubbandPyramid3DAlloc(subband_pyramid1))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidd3DCopy): Error calling QccWAVSubbandPyramid3DAlloc()");
          return(1);
        }
    }

  subband_pyramid1->transform_type = subband_pyramid2->transform_type;

  subband_pyramid1->spatial_num_levels = subband_pyramid2->spatial_num_levels;
  subband_pyramid1->temporal_num_levels =
    subband_pyramid2->temporal_num_levels;

  subband_pyramid1->origin_frame = subband_pyramid2->origin_frame;
  subband_pyramid1->origin_row = subband_pyramid2->origin_row;
  subband_pyramid1->origin_col = subband_pyramid2->origin_col;

  subband_pyramid1->subsample_pattern_frame =
    subband_pyramid2->subsample_pattern_frame;
  subband_pyramid1->subsample_pattern_row =
    subband_pyramid2->subsample_pattern_row;
  subband_pyramid1->subsample_pattern_col =
    subband_pyramid2->subsample_pattern_col;

  if (QccVolumeCopy(subband_pyramid1->volume,
                    subband_pyramid2->volume,
		    subband_pyramid1->num_frames,
                    subband_pyramid1->num_rows,
                    subband_pyramid1->num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DCopy): Error calling QccVolumeCopy()");
      return(1);
    }

  return(0);
}


int QccWAVSubbandPyramid3DZeroSubband(QccWAVSubbandPyramid3D *subband_pyramid,
                                      int subband)
{
  int num_subbands;
  int subband_num_frames;
  int subband_num_rows;
  int subband_num_cols;
  int subband_frame;
  int subband_row;
  int subband_col;
  int frame, row, col;
  int spatial_num_levels = subband_pyramid->spatial_num_levels;
  int temporal_num_levels = subband_pyramid->temporal_num_levels;

  if (subband_pyramid == NULL)
    return(0);
  if (subband_pyramid->volume == NULL)
    return(0);
  if (subband < 0)
    return(0);
  
  switch (subband_pyramid->transform_type)
    {
    case QCCWAVSUBBANDPYRAMID3D_DYADIC:
      num_subbands =
        QccWAVSubbandPyramid3DNumLevelsToNumSubbandsDyadic(spatial_num_levels);
      break;
    case QCCWAVSUBBANDPYRAMID3D_PACKET:
      num_subbands =
        QccWAVSubbandPyramid3DNumLevelsToNumSubbandsPacket(spatial_num_levels,
                                                           temporal_num_levels);
      break;
    default:
      QccErrorAddMessage("(QccWAVSubbandPyramid3DZeroSubband): Unrecognized transform type");
      return(1);
    }

  if (subband > num_subbands)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DZeroSubband): specified subband is large for given subband pyramid");
      return(1);
    }
  
  if (QccWAVSubbandPyramid3DSubbandSize(subband_pyramid,
                                        subband,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DZeroSubband): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      return(1);
    }
  
  if (QccWAVSubbandPyramid3DSubbandOffsets(subband_pyramid,
                                           subband,
                                           &subband_frame,
                                           &subband_row,
                                           &subband_col))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DZeroSubband): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
      return(1);
    }
  
  for (frame = subband_frame; frame < subband_frame + subband_num_frames;
       frame++)
    for (row = subband_row; row < subband_row + subband_num_rows; row++)
      for (col = subband_col; col < subband_col + subband_num_cols; col++)
        subband_pyramid->volume[frame][row][col] = 0;
  
  return(0);
}


int QccWAVSubbandPyramid3DSubtractMean(QccWAVSubbandPyramid3D *subband_pyramid,
                                       double *mean,
                                       const QccSQScalarQuantizer *quantizer)
{
  int subband_frame, subband_row, subband_col;
  int subband_num_frames, subband_num_rows, subband_num_cols;
  int partition;
  
  double mean1;
  
  if (subband_pyramid == NULL)
    return(0);
  if (subband_pyramid->volume == NULL)
    return(0);
  
  if (QccWAVSubbandPyramid3DSubbandSize(subband_pyramid,
                                        0,
  			                &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DSubtractMean): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      return(1);
    }
  
  mean1 = QccVolumeMean(subband_pyramid->volume,
                        subband_num_frames,
			subband_num_rows,
                        subband_num_cols);
  
  if (quantizer != NULL)
    {
      if (QccSQScalarQuantization(mean1, quantizer, NULL, &partition))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramid3DSubtractMean): Error calling QccSQScalarQuantization()");
          return(1);
        }
      if (QccSQInverseScalarQuantization(partition, quantizer, &mean1))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramid3DSubtractMean): Error calling QccSQInverseScalarQuantization()");
          return(1);
        }
    }
  
  for (subband_frame = 0; subband_frame < subband_num_frames; subband_frame++)
    for (subband_row = 0; subband_row < subband_num_rows; subband_row++)
      for (subband_col = 0; subband_col < subband_num_cols; subband_col++)
        subband_pyramid->volume[subband_frame][subband_row][subband_col] -=
          mean1;
  
  if (mean != NULL)
    *mean = mean1;
  
  return(0);
}


int QccWAVSubbandPyramid3DAddMean(QccWAVSubbandPyramid3D *subband_pyramid,
                                  double mean)
{
  int subband_frame, subband_row, subband_col;
  int subband_num_frames, subband_num_rows, subband_num_cols;
  
  if (subband_pyramid == NULL)
    return(0);
  if (subband_pyramid->volume == NULL)
    return(0);
  if (subband_pyramid->spatial_num_levels ||
      subband_pyramid->temporal_num_levels)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DAddMean): Subband-pyramid number of levels is not zero");
      return(1);
    }
  
  if (QccWAVSubbandPyramid3DSubbandSize(subband_pyramid,
                                        0,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DAddMean): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      return(1);
    }
  
  for (subband_frame = 0; subband_frame < subband_num_frames; subband_frame++)
    for (subband_row = 0; subband_row < subband_num_rows; subband_row++)
      for (subband_col = 0; subband_col < subband_num_cols; subband_col++)
        subband_pyramid->volume[subband_frame][subband_row][subband_col] +=
          mean;
  
  return(0);
}


int QccWAVSubbandPyramid3DDWT(QccWAVSubbandPyramid3D *subband_pyramid,
                              int transform_type,
                              int temporal_num_levels,
                              int spatial_num_levels,
                              const QccWAVWavelet *wavelet)
{
  int return_value;
  
  if (subband_pyramid == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  if (subband_pyramid->spatial_num_levels ||
      subband_pyramid->temporal_num_levels)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramid3DDWT): Subband pyramid is already decomposed");
      goto Error;
    }
  
  switch (transform_type)
    {
    case QCCWAVSUBBANDPYRAMID3D_DYADIC:
      subband_pyramid->transform_type = QCCWAVSUBBANDPYRAMID3D_DYADIC;
      if (spatial_num_levels != temporal_num_levels)
        {
          QccErrorAddMessage("(QccWAVSubbandPyramid3DDWT): Spatial and temporal number of levels must be identical for a dyadic transform");
          goto Error;
        }
      subband_pyramid->spatial_num_levels =
        subband_pyramid->temporal_num_levels = spatial_num_levels;
      if (QccWAVWaveletDyadicDWT3D(subband_pyramid->volume,
				   subband_pyramid->num_frames,
				   subband_pyramid->num_rows,
                                   subband_pyramid->num_cols,
                                   subband_pyramid->origin_frame,
                                   subband_pyramid->origin_row,
                                   subband_pyramid->origin_col,
                                   subband_pyramid->subsample_pattern_frame,
                                   subband_pyramid->subsample_pattern_row,
                                   subband_pyramid->subsample_pattern_col,
				   spatial_num_levels,
				   wavelet))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramid3DDWT): Error calling QccWAVWaveletDyadicDWT3D()");
          goto Error;
        }