subband_pyramid.c

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

                                          QccWAVSubbandPyramid
                                          *subband_pyramid)
{
  
  if ((infile == NULL) || (subband_pyramid == NULL))
    return(0);
  
  if (QccFileReadMagicNumber(infile,
                             subband_pyramid->magic_num,
                             &subband_pyramid->major_version,
                             &subband_pyramid->minor_version))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading magic number in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  if (strcmp(subband_pyramid->magic_num, QCCWAVSUBBANDPYRAMID_MAGICNUM))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): %s is not of subband-pyramid (%s) type",
                         subband_pyramid->filename, 
                         QCCWAVSUBBANDPYRAMID_MAGICNUM);
      return(1);
    }
  
  fscanf(infile, "%d", &(subband_pyramid->num_levels));
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of levels in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  if (QccFileSkipWhiteSpace(infile, 0))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of levels in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  fscanf(infile, "%d", &(subband_pyramid->num_cols));
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of columns in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  if (QccFileSkipWhiteSpace(infile, 0))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of columns in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  fscanf(infile, "%d", &(subband_pyramid->num_rows));
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of rows in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  if (QccFileSkipWhiteSpace(infile, 0))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading number of rows in %s",
                         subband_pyramid->filename);
      return(1);
    }
  
  if (QccCompareQccPackVersions(subband_pyramid->major_version,
                                subband_pyramid->minor_version,
                                0, 12) < 0)
    {
      QccErrorWarning("(QccWAVSubbandPyramidReadHeader): converting %s from outdated version %d.%d to current version",
                      subband_pyramid->filename,
                      subband_pyramid->major_version,
                      subband_pyramid->minor_version);

      /*  Min value  */
      fscanf(infile, "%*f");
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading min value in %s",
                             subband_pyramid->filename);
          return(1);
        }
      
      if (QccFileSkipWhiteSpace(infile, 0))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading min value in %s",
                             subband_pyramid->filename);
          return(1);
        }
      
      /*  Max val  */
      fscanf(infile, "%*f");
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading max value in %s",
                             subband_pyramid->filename);
          return(1);
        }
    }
  
  fscanf(infile, "%*1[\n]");
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidReadHeader): Error reading subband pyramid %s",
                         subband_pyramid->filename);
      return(1);
    }

  return(0);
}


int QccWAVSubbandPyramidRead(QccWAVSubbandPyramid *subband_pyramid)
{
  FILE *infile = NULL;
  int row, col;
  
  if (subband_pyramid == NULL)
    return(0);
  
  if ((infile = QccFileOpen(subband_pyramid->filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidRead): Error calling QccFileOpen()");
      return(1);
    }
  
  if (QccWAVSubbandPyramidReadHeader(infile, subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidRead): Error calling QccWAVSubbandPyramidReadHeader()");
      return(1);
    }
  
  if (QccWAVSubbandPyramidAlloc(subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidRead): Error calling QccIMGSubbandPyramidAlloc()");
      return(1);
    }
  
  for (row = 0; row < subband_pyramid->num_rows; row++)
    for (col = 0; col < subband_pyramid->num_cols; col++)
      if (QccFileReadDouble(infile,
                            &(subband_pyramid->matrix[row][col])))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidRead): Error calling QccFileReadDouble()",
                             subband_pyramid->filename);
          return(1);
        }
  
  QccFileClose(infile);
  return(0);
}


static int QccWAVSubbandPyramidWriteHeader(FILE *outfile, 
                                           const QccWAVSubbandPyramid
                                           *subband_pyramid)
{
  if ((outfile == NULL) || (subband_pyramid == NULL))
    return(0);
  
  if (QccFileWriteMagicNumber(outfile, QCCWAVSUBBANDPYRAMID_MAGICNUM))
    goto Error;
  
  fprintf(outfile, "%d\n%d %d\n",
          subband_pyramid->num_levels,
          subband_pyramid->num_cols,
          subband_pyramid->num_rows);
  if (ferror(outfile))
    goto Error;
  
  return(0);
  
 Error:
  QccErrorAddMessage("(QccWAVSubbandPyramidWriteHeader): Error writing header to %s",
                     subband_pyramid->filename);
  return(1);
}


int QccWAVSubbandPyramidWrite(const QccWAVSubbandPyramid *subband_pyramid)
{
  FILE *outfile;
  int row, col;
  
  if (subband_pyramid == NULL)
    return(0);
  
  if ((outfile = QccFileOpen(subband_pyramid->filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidWrite): Error calling QccFileOpen()");
      return(1);
    }
  
  if (QccWAVSubbandPyramidWriteHeader(outfile, subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidWrite): Error calling QccWAVSubbandPyramidWriteHeader()");
      return(1);
    }
  
  for (row = 0; row < subband_pyramid->num_rows; row++)
    for (col = 0; col < subband_pyramid->num_cols; col++)
      if (QccFileWriteDouble(outfile,
                             subband_pyramid->matrix[row][col]))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidWrite): Error calling QccFileWriteDouble()");
          return(1);
        }
  
  QccFileClose(outfile);
  return(0);
}


int QccWAVSubbandPyramidCopy(QccWAVSubbandPyramid *subband_pyramid1,
                             const QccWAVSubbandPyramid *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))
    {
      QccWAVSubbandPyramidFree(subband_pyramid1);
      subband_pyramid1->num_rows = subband_pyramid2->num_rows;
      subband_pyramid1->num_cols = subband_pyramid2->num_cols;
      if (QccWAVSubbandPyramidAlloc(subband_pyramid1))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidCopy): Error calling QccWAVSubbandPyramidAlloc()");
          return(1);
        }
    }

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

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

  if (QccMatrixCopy(subband_pyramid1->matrix,
                    subband_pyramid2->matrix,
                    subband_pyramid1->num_rows,
                    subband_pyramid1->num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidCopy): Error calling QccMatrixCopy()");
      return(1);
    }

  return(0);
}


int QccWAVSubbandPyramidZeroSubband(QccWAVSubbandPyramid *subband_pyramid,
                                    int subband)
{
  int num_subbands;
  int subband_num_rows;
  int subband_num_cols;
  int subband_row;
  int subband_col;
  int row, col;

  if (subband_pyramid == NULL)
    return(0);
  if (subband_pyramid->matrix == NULL)
    return(0);
  if (subband < 0)
    return(0);

  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(subband_pyramid->num_levels);

  if (subband > num_subbands)
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidZeroSubband): specified subband is large for given subband pyramid");
      return(1);
    }
  
  if (QccWAVSubbandPyramidSubbandSize(subband_pyramid,
                                      subband,
                                      &subband_num_rows,
                                      &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidZeroSubband): Error calling QccWAVSubbandPyramidSubbandSize()");
      return(1);
    }
  
  if (QccWAVSubbandPyramidSubbandOffsets(subband_pyramid,
                                         subband,
                                         &subband_row,
                                         &subband_col))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidZeroSubband): Error calling QccWAVSubbandPyramidSubbandOffsets()");
      return(1);
    }
  
  for (row = subband_row; row < subband_row + subband_num_rows; row++)
    for (col = subband_col; col < subband_col + subband_num_cols; col++)
      subband_pyramid->matrix[row][col] = 0;

  return(0);
}


int QccWAVSubbandPyramidSubtractMean(QccWAVSubbandPyramid *subband_pyramid,
                                     double *mean,
                                     const QccSQScalarQuantizer *quantizer)
{
  int subband_row, subband_col;
  int subband_num_rows, subband_num_cols;
  int partition;
  
  double mean1;
  
  if (subband_pyramid == NULL)
    return(0);
  if (subband_pyramid->matrix == NULL)
    return(0);

  if (QccWAVSubbandPyramidSubbandSize(subband_pyramid,
                                      0,
                                      &subband_num_rows,
                                      &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVSubbandPyramidSubtractMean): Error calling QccWAVSubbandPyramidSubbandSize()");
      return(1);
    }
  
  mean1 = QccMatrixMean(subband_pyramid->matrix,
                        subband_num_rows,
                        subband_num_cols);
  
  if (quantizer != NULL)
    {
      if (QccSQScalarQuantization(mean1, quantizer, NULL, &partition))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidSubtractMean): Error calling QccSQScalarQuantization()");
          return(1);
        }
      if (QccSQInverseScalarQuantization(partition, quantizer, &mean1))
        {
          QccErrorAddMessage("(QccWAVSubbandPyramidSubtractMean): Error calling QccSQInverseScalarQuantization()");
          return(1);
        }
    }
  
  for (subband_row = 0; subband_row < subband_num_rows; subband_row++)
    for (subband_col = 0; subband_col < subband_num_cols; subband_col++)
      subband_pyramid->matrix[subband_row][subband_col] -= mean1;
  
  if (mean != NULL)
    *mean = mean1;