image.c

spiht的压缩解压缩c编写的

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

int QccIMGImageInitialize(QccIMGImage *image)
{
  if (image == NULL)
    return(0);

  image->image_type = QCCIMGTYPE_UNKNOWN;
  QccStringMakeNull(image->filename);
  QccIMGImageComponentInitialize(&(image->Y));
  QccIMGImageComponentInitialize(&(image->U));
  QccIMGImageComponentInitialize(&(image->V));

  return(0);
}

int QccIMGImageGetResolution(const QccIMGImage *image,
                             int *num_rows, int *num_cols)
{
  if ((image == NULL) || (num_rows == NULL) || (num_cols == NULL))
    return(0);

  *num_rows = image->Y.num_rows;
  *num_cols = image->Y.num_cols;

  return(0);
}

int QccIMGImageSetResolution(QccIMGImage *image,
                             int num_rows, int num_cols)
{
  if (image == NULL)
    return(0);

  if (QccIMGImageColor(image))
    {
      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;
    }
  else
    {
      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;
    }

  return(0);
}

int QccIMGImageAlloc(QccIMGImage *image)
{
  if (image == NULL)
    return(0);

  if (QccIMGImageComponentAlloc(&(image->Y)))
    {
      QccErrorAddMessage("(QccIMGImageAlloc): Error calling QccIMGImageComponentAlloc()");
      goto QccIMGErr;
    }
  if (QccIMGImageComponentAlloc(&(image->U)))
    {
      QccErrorAddMessage("(QccIMGImageAlloc): Error calling QccIMGImageComponentAlloc()");
      goto QccIMGErr;
    }
  if (QccIMGImageComponentAlloc(&(image->V)))
    {
      QccErrorAddMessage("(QccIMGImageAlloc): Error calling QccIMGImageComponentAlloc()");
      goto QccIMGErr;
    }
  
  return(0);

 QccIMGErr:
  QccIMGImageComponentFree(&(image->Y));
  QccIMGImageComponentFree(&(image->U));
  QccIMGImageComponentFree(&(image->V));
  return(1);
}

void QccIMGImageFree(QccIMGImage *image)
{
  if (image == NULL)
    return;

  QccIMGImageComponentFree(&(image->Y));
  QccIMGImageComponentFree(&(image->U));
  QccIMGImageComponentFree(&(image->V));
}

double QccIMGClipPixelValue(double val)
{
  double new_val;

  if (val < 0)
    new_val = 0;
  else if (val > 255)
    new_val = 255;
  else
    new_val = val;

  return(new_val);
}

int QccIMGImageColor(const QccIMGImage *image)
{
  return(image->image_type == QCCIMGTYPE_PPM);
}

int QccIMGImageDetermineType(QccIMGImage *image)
{
  QccString magic_num;
  QccString extension;

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

  if (image->image_type != QCCIMGTYPE_UNKNOWN)
    return(0);

  if (QccFileExists(image->filename))
    {
      if (QccFileGetMagicNumber(image->filename, magic_num))
        {
          QccErrorAddMessage("(QccIMGImageDetermineType): Error calling QccFileGetMagicNumber()");
          goto Return;
        }

      if (!strncmp(magic_num, "ICP", QCCSTRINGLEN))
        {
          image->image_type = QCCIMGTYPE_ICP;
          return(0);
        }

      QccIMGImagePnmGetType(magic_num, &image->image_type, NULL);
      if (image->image_type != QCCIMGTYPE_UNKNOWN)
        return(0);
    }

  if (QccFileGetExtension(image->filename, extension))
    goto Error;

  if (!strncmp(extension, "icp", QCCSTRINGLEN))
    {
      image->image_type = QCCIMGTYPE_ICP;
      return(0);
    }
  if (!strncmp(extension, "pbm", QCCSTRINGLEN))
    {
      image->image_type = QCCIMGTYPE_PBM;
      return(0);
    }
  if (!strncmp(extension, "pgm", QCCSTRINGLEN))
    {
      image->image_type = QCCIMGTYPE_PGM;
      return(0);
    }
  if (!strncmp(extension, "ppm", QCCSTRINGLEN))
    {
      image->image_type = QCCIMGTYPE_PPM;
      return(0);
    }

Error:
  image->image_type = QCCIMGTYPE_UNKNOWN;
  QccErrorAddMessage("(QccIMGImageDetermineType): Unknown image type");
 Return:
  return(1);
}

int QccIMGImageRead(QccIMGImage *image)
{
  if (image == NULL)
    return(0);
  
  image->image_type = QCCIMGTYPE_UNKNOWN;

  if (QccIMGImageDetermineType(image))
    {
      QccErrorAddMessage("(QccIMGImageRead): Error calling QccIMGImageDetermineType()");
      return(1);
    }
  
  switch (image->image_type)
    {
    case QCCIMGTYPE_ICP:
      QccStringCopy(image->Y.filename, image->filename);
      if (QccIMGImageComponentRead(&(image->Y)))
        {
          QccErrorAddMessage("(QccIMGImageRead): Error calling QccIMGImageComponentRead()");
          return(1);
        }
      break;

    case QCCIMGTYPE_PBM:
    case QCCIMGTYPE_PGM:
    case QCCIMGTYPE_PPM:
      if (QccIMGImagePnmRead(image))
        {
          QccErrorAddMessage("(QccIMGImageRead): Error calling QccIMGImagePnmRead()");
          return(1);
        }
      break;

    default:
      QccErrorAddMessage("(QccIMGImageRead): Unknown image type");
      return(1);
    }

  QccIMGImageSetMax(image);
  QccIMGImageSetMin(image);

  return(0);
}

int QccIMGImageWrite(QccIMGImage *image)
{
  if (image == NULL)
    return(0);

  if (QccIMGImageDetermineType(image))
    {
      QccErrorAddMessage("(QccIMGImageWrite): Error calling QccIMGImageDetermineType()");
      return(1);
    }

  switch (image->image_type)
    {
    case QCCIMGTYPE_ICP:
      QccStringCopy(image->Y.filename, image->filename);
      if (QccIMGImageComponentWrite(&(image->Y)))
        {
          QccErrorAddMessage("(QccIMGImageWrite): Error calling QccIMGImageComponentWrite()");
          return(1);
        }
      break;

    case QCCIMGTYPE_PBM:
    case QCCIMGTYPE_PGM:
    case QCCIMGTYPE_PPM:
      if (QccIMGImagePnmWrite(image))
        {
          QccErrorAddMessage("(QccIMGImageWrite): Error calling QccIMGImagePnmWrite()");
          return(1);
        }
      break;

    default:
      QccErrorAddMessage("(QccIMGImageWrite): Unknown image type");
      return(1);
    }

  return(0);
}

int QccIMGImageSetMin(QccIMGImage *image)
{
  if (image == NULL)
    return(0);

  QccIMGImageComponentSetMin(&(image->Y));
  QccIMGImageComponentSetMin(&(image->U));
  QccIMGImageComponentSetMin(&(image->V));

  return(0);
}

int QccIMGImageSetMax(QccIMGImage *image)
{
  if (image == NULL)
    return(0);

  QccIMGImageComponentSetMax(&(image->Y));
  QccIMGImageComponentSetMax(&(image->U));
  QccIMGImageComponentSetMax(&(image->V));

  return(0);
}