image_pnm.c

spiht的压缩解压缩c编写的

#include "spiht.h"
#include "spihtdecode.h"

void QccIMGImagePnmGetType(const QccString magic_number,
                           int *returned_image_type,
                           int *returned_raw)
{
  int image_type;
  int raw =  QCCIMG_PNM_RAW;

  if (!strncmp(magic_number, "P1", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PBM;
      raw = QCCIMG_PNM_ASCII;
      goto QccReturn;
    }
  if (!strncmp(magic_number, "P4", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PBM;
      raw = QCCIMG_PNM_RAW;
      goto QccReturn;
    }
  
  if (!strncmp(magic_number, "P2", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PGM;
      raw = QCCIMG_PNM_ASCII;
      goto QccReturn;
    }
  if (!strncmp(magic_number, "P5", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PGM;
      raw = QCCIMG_PNM_RAW;
      goto QccReturn;
    }
  
  if (!strncmp(magic_number, "P3", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PPM;
      raw = QCCIMG_PNM_ASCII;
      goto QccReturn;
    }
  if (!strncmp(magic_number, "P6", QCCSTRINGLEN))
    {
      image_type = QCCIMGTYPE_PPM;
      raw = QCCIMG_PNM_RAW;
      goto QccReturn;
    }
  
  image_type = QCCIMGTYPE_UNKNOWN;
  
 QccReturn:
  if (returned_image_type != NULL)
    *returned_image_type = image_type;
  if (returned_raw != NULL)
    *returned_raw = raw;
}

static int QccIMGImagePnmReadHeader(FILE *infile,
                                    QccIMGImage *image,
                                    int *image_raw)
{
  QccString magic_number;
  int num_rows, num_cols;
  int maxval;

  if (QccFileReadString(infile, magic_number))
    {
      QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                         image->filename);
      return(1);
    }
  if (QccFileSkipWhiteSpace(infile, 1))
    {
      QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                         image->filename);
      return(1);
    }


  QccIMGImagePnmGetType(magic_number, &image->image_type, image_raw);

  if (image->image_type == QCCIMGTYPE_PBM)
    {
      fscanf(infile, "%d", &num_cols);
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      if (QccFileSkipWhiteSpace(infile, 1))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }

      if (*image_raw == QCCIMG_PNM_RAW)
        fscanf(infile, "%d%*c", &num_rows);
      else
        {
          fscanf(infile, "%d", &num_rows);
          if (QccFileSkipWhiteSpace(infile, 1))
            {
              QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                                 image->filename);
              return(1);
            }
        }
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
    }

  if ((image->image_type == QCCIMGTYPE_PGM) ||
      (image->image_type == QCCIMGTYPE_PPM))
    {
      fscanf(infile, "%d", &num_cols);
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      if (QccFileSkipWhiteSpace(infile, 1))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      
      fscanf(infile, "%d", &num_rows);
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      if (QccFileSkipWhiteSpace(infile, 1))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      
      if (*image_raw == QCCIMG_PNM_RAW)
        fscanf(infile, "%d%*c", &maxval);
      else
        {
          fscanf(infile, "%d", &maxval);
          if (QccFileSkipWhiteSpace(infile, 1))
            {
              QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                                 image->filename);
              return(1);
            }
        }
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
      if ((image_raw == QCCIMG_PNM_RAW) && (maxval != 255))
        {
          QccErrorAddMessage("QccIMGImagePnmReadheader): Raw PGM and PPM files must have maxval = 255");
          QccErrorAddMessage("QccIMGImagePnmReadHeader): Error reading %s",
                             image->filename);
          return(1);
        }
    }

  switch (image->image_type)
    {
    case QCCIMGTYPE_PPM:
      image->Y.num_rows = image->U.num_rows = image->V.num_rows = num_rows;
      image->Y.num_cols = image->U.num_cols = image->V.num_cols = num_cols;
      break;
    case QCCIMGTYPE_PBM:
    case QCCIMGTYPE_PGM:
      image->Y.num_rows = num_rows;
      image->U.num_rows = image->V.num_rows = 0;
      image->Y.num_cols = num_cols;
      image->U.num_cols = image->V.num_cols = 0;
      break;
    case QCCIMGTYPE_UNKNOWN:
    default:
      QccErrorAddMessage("(QccIMGImagePnmRead): Unknown image type %d",
                         image->image_type);
      return(1);
    }

  return(0);
}

static int QccIMGImagePbmReadData(FILE *infile,
                                  QccIMGImage *image,
                                  int image_raw)
{
  int row, col;
  int bit_count = 0;
  unsigned char ch = 0;

  if (image_raw == QCCIMG_PNM_RAW)
    {
      for (row = 0; row < image->Y.num_rows; row++)
        for (col = 0; col < image->Y.num_cols; col++)
          {
            if (!bit_count)
              {
                if (QccFileReadChar(infile, (char *)(&ch)))
                  goto QccError;
                bit_count = 8;
              }
            image->Y.image[row][col] = 
              ((ch & 0x80) == 0);
            ch <<= 1;
            bit_count--;
          }
    }
  else
    {
      for (row = 0; row < image->Y.num_rows; row++)
        for (col = 0; col < image->Y.num_cols; col++)
          {
            int val;

            fscanf(infile, "%d", &val);
            if (ferror(infile) || feof(infile))
              goto QccError;
            image->Y.image[row][col] = (double)val;
          }
    }
      
  return(0);
 QccError:
  QccErrorAddMessage("QccIMGImagePbmReadData): Error reading data in %s",
                     image->filename);
  return(1);

}

static int QccIMGImagePgmReadData(FILE *infile,
                                  QccIMGImage *image,
                                  int image_raw)
{
  int row, col;
  unsigned char ch;

  if (image_raw == QCCIMG_PNM_RAW)
    {
      for (row = 0; row < image->Y.num_rows; row++)
        for (col = 0; col < image->Y.num_cols; col++)
          {
            if (QccFileReadChar(infile, (char *)(&ch)))
              goto QccError;
            image->Y.image[row][col] = (int)ch;
          }
    }
  else
    {
      for (row = 0; row < image->Y.num_rows; row++)
        for (col = 0; col < image->Y.num_cols; col++)
          {
            int val;

            fscanf(infile, "%d", &val);
            if (ferror(infile) || feof(infile))
              goto QccError;
            image->Y.image[row][col] = (double)val;
          }
    }
      
  return(0);
 QccError:
  QccErrorAddMessage("QccIMGImagePgmReadData): Error reading data in %s",
                     image->filename);
  return(1);
}

static int QccIMGImagePpmReadData(FILE *infile,
                                  QccIMGImage *image,
                                  int image_raw)
{
  int row, col;
  int red, green, blue;
  unsigned char ch;

  if (image_raw == QCCIMG_PNM_RAW)
    {
      for (row = 0; row < image->Y.num_rows; row++)
        for (col = 0; col < image->Y.num_cols; col++)
          {
            if (QccFileReadChar(infile, (char *)(&ch)))
              goto QccError;
            red = (int)ch;
            if (QccFileReadChar(infile, (char *)(&ch)))
              goto QccError;
            green = (int)ch;
            if (QccFileReadChar(infile, (char *)(&ch)))
              goto QccError;
            blue = (int)ch;
            QccIMGImageRGBtoYUV(&(image->Y.image[row][col]),
                                &(image->U.image[row][col]),
                                &(image->V.image[row][col]),
                                red, green, blue);
          }
    }
  else
    {
      for (row = 0; row < image->Y.num_rows; row++)