GImage *
GImageReadTiff (char *filename)
{
  TIFF *tif;
  uint32_t w, h, i, j;
  uint32_t *ipt, *fpt;
  size_t npixels;
  uint32 *raster;
  GImage *ret = NULL;
  struct _GImage *base;

  tif = TIFFOpen (filename, "r");

  if (tif == NULL)
    return (ret);

  TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &w);
  TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &h);
  npixels = w * h;
  raster = (uint32_t *) xmalloc (szmax (1, npixels * sizeof (uint32_t)));
  if (raster != NULL)
    {
      if (TIFFReadRGBAImage (tif, w, h, raster, 0))
        {
          ret = GImageCreate (it_true, w, h);
          if (ret != NULL)
            {
              base = ret->u.image;
              for (i = 0; i < h; ++i)
                {
                  ipt = (uint32_t *) (base->data + i * base->bytes_per_line);
                  fpt = raster + (h - 1 - i) * w;
                  for (j = 0; j < w; ++j)
                    *ipt++ =
                      COLOR_CREATE (TIFFGetR (fpt[j]), TIFFGetG (fpt[j]),
                                    TIFFGetB (fpt[j]));
                }
            }
        }
      free (raster);
    }
  TIFFClose (tif);
  return (ret);
}
GImage *
GImageReadRgb (char *filename)
{
  FILE *fp = fopen (filename, "rb");
  struct sgiheader header;
  int j, i;
  unsigned char *pt, *end;
  unsigned long *ipt, *iend;
  GImage *ret;
  struct _GImage *base;

  if (fp == NULL)
    return (NULL);
  getsgiheader (&header, fp);
  if (header.magic != SGI_MAGIC ||
      (header.format != VERBATIM && header.format != RLE) ||
      (header.bpc != 1 && header.bpc != 2) ||
      header.dim < 1 || header.dim > 3 ||
      header.pixmax > 65535 || (header.pixmax > 255 && header.bpc == 1) ||
      (header.chans != 1 && header.chans != 3 && header.chans != 4) ||
      header.pixmax < 0 || header.pixmin < 0 || header.pixmin > header.pixmax ||
      header.colormap != 0)
    {
      fclose (fp);
      return (NULL);
    }

  ret =
    GImageCreate (header.dim == 3 ? it_true : it_index, header.width,
                  header.height);
  base = ret->u.image;

  if (header.format == RLE)
    {
      unsigned long *starttab /*, *lengthtab */ ;
      unsigned char **ptrtab;
      long tablen;

      tablen = header.height * header.chans;
      starttab = (unsigned long *) xmalloc (szmax (1, tablen * sizeof (long)));
      /*lengthtab = (unsigned long *)xmalloc(szmax(1, tablen*sizeof(long))); */
      ptrtab =
        (unsigned char **)
        xmalloc (szmax (1, tablen * sizeof (unsigned char *)));
      readlongtab (fp, starttab, tablen);
      /*readlongtab(fp,lengthtab,tablen); */
      for (i = 0; i < tablen; ++i)
        find_scanline (fp, &header, i, starttab, ptrtab);
      if (header.chans == 1)
        {
          for (i = 0; i < header.height; ++i)
            memcpy (base->data + (header.height - 1 - i) * base->bytes_per_line,
                    ptrtab[i], header.width);
        }
      else
        {
          unsigned long *ipt;
          for (i = 0; i < header.height; ++i)
            {
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              for (j = 0; j < header.width; ++j)
                *ipt++ = COLOR_CREATE (ptrtab[i][j],
                                       ptrtab[i + header.height][j],
                                       ptrtab[i + 2 * header.height][j]);
            }
        }
      freeptrtab (ptrtab, tablen);
      free (ptrtab);
      free (starttab);          /*free(lengthtab); */
    }
  else
    {
      if (header.chans == 1 && header.bpc == 1)
        {
          for (i = 0; i < header.height; ++i)
            {
              fread (base->data +
                     (header.height - 1 - i) * base->bytes_per_line,
                     header.width, 1, fp);
              if (header.pixmax != 255)
                {
                  pt =
                    (unsigned char *) (base->data +
                                       (header.height - 1 -
                                        i) * base->bytes_per_line);
                  for (end = pt + header.width; pt < end; ++pt)
                    *pt = (*pt * 255) / header.pixmax;
                }
            }
        }
      else if (header.chans == 1)
        {
          for (i = 0; i < header.height; ++i)
            {
              pt =
                (unsigned char *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              for (end = pt + header.width; pt < end;)
                *pt++ = (getshort (fp) * 255L) / header.pixmax;
            }
        }
      else if (header.bpc == 1)
        {
          unsigned char *r, *g, *b, *a = NULL;
          unsigned char *rpt, *gpt, *bpt;
          r = (unsigned char *) xmalloc (header.width);
          g = (unsigned char *) xmalloc (header.width);
          b = (unsigned char *) xmalloc (header.width);
          if (header.chans == 4)
            a = (unsigned char *) xmalloc (header.width);
          for (i = 0; i < header.height; ++i)
            {
              fread (r, header.width, 1, fp);
              fread (g, header.width, 1, fp);
              fread (b, header.width, 1, fp);
              if (header.chans == 4)
                fread (a, header.width, 1, fp);
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              rpt = r;
              gpt = g;
              bpt = b;
              for (iend = ipt + header.width; ipt < iend;)
                *ipt++ = COLOR_CREATE (*rpt++ * 255L / header.pixmax,
                                       *gpt++ * 255L / header.pixmax,
                                       *bpt++ * 255L / header.pixmax);
            }
          free (r);
          free (g);
          free (b);
          free (a);
        }
      else
        {
          unsigned char *r, *g, *b, *a = NULL;
          unsigned char *rpt, *gpt, *bpt;
          r = (unsigned char *) xmalloc (header.width);
          g = (unsigned char *) xmalloc (header.width);
          b = (unsigned char *) xmalloc (header.width);
          if (header.chans == 4)
            a = (unsigned char *) xmalloc (header.width);
          for (i = 0; i < header.height; ++i)
            {
              for (j = 0; j < header.width; ++j)
                r[j] = getshort (fp) * 255L / header.pixmax;
              for (j = 0; j < header.width; ++j)
                g[j] = getshort (fp) * 255L / header.pixmax;
              for (j = 0; j < header.width; ++j)
                b[j] = getshort (fp) * 255L / header.pixmax;
              if (header.chans == 4)
                {
                  fread (a, header.width, 1, fp);
                  fread (a, header.width, 1, fp);
                }
              ipt =
                (unsigned long *) (base->data +
                                   (header.height - 1 -
                                    i) * base->bytes_per_line);
              rpt = r;
              gpt = g;
              bpt = b;
              for (iend = ipt + header.width; ipt < iend;)
                *ipt++ = COLOR_CREATE (*rpt++, *gpt++, *bpt++);
            }
          free (r);
          free (g);
          free (b);
          free (a);
        }
    }

  return (ret);
}
Exemple #3
0
static void
initTiles(
    BlasGenSettings* gset,
    TileSet* tileSet,
    const struct SubproblemDim *subdims,
    KernelExtraFlags kflags,
    DataType dtype,
    PrivateStorageType storType)
{
    unsigned int rowsA;
    unsigned int rowsB;
    unsigned int rowsC;
    unsigned int colsA;
    unsigned int colsB;
    unsigned int colsC;
    bool transA;
    bool transB;
    unsigned int vecLenA;
    unsigned int vecLenB;
    unsigned int vecLenC;

    rowsA = (unsigned int)subdims[1].y;
    colsA = (unsigned int)szmax(subdims[1].y, subdims[1].bwidth);

    rowsB = (unsigned int)szmax(subdims[1].y, subdims[1].bwidth);
    colsB = (unsigned int)szmax(subdims[1].x, subdims[1].y);

    rowsC = (unsigned int)subdims[1].y;
    colsC = (unsigned int)subdims[1].x;

    transA = isMatrixAccessColMaj(CLBLAS_TRSM, kflags, MATRIX_A);
    transB = isMatrixAccessColMaj(CLBLAS_TRSM, kflags, MATRIX_B);

    vecLenA = (unsigned int)((transA) ? subdims[1].y : subdims[1].bwidth);
    vecLenA = umin(vecLenA, MAX_TILE_VECLEN);
    vecLenB = (unsigned int)((transB) ? subdims[1].x : subdims[1].bwidth);
    vecLenB = umin(vecLenB, MAX_TILE_VECLEN);
    vecLenC = (transB) ? vecLenB : vecLenA;

    initTile(&tileSet->rectA, "a", (unsigned int)subdims[1].y,
             (unsigned int)subdims[1].bwidth, vecLenA, dtype,
             storType, transA, false);

    initTile(&tileSet->squareA, "a", (unsigned int)subdims[1].y,
             (unsigned int)subdims[1].y, vecLenA, dtype, storType,
             transA, false);

    initTile(&tileSet->origB, "b", (unsigned int)subdims[1].bwidth,
             (unsigned int)subdims[1].x, vecLenB, dtype, storType,
             !transB, false);

    initTile(&tileSet->bStage2, "b", (unsigned int)subdims[1].y,
             (unsigned int)subdims[1].x, vecLenB, dtype, storType,
             !transB, false);

    initTile(&tileSet->bAsSqA, "b", (unsigned int)subdims[1].y,
             (unsigned int)subdims[1].y, vecLenB, dtype, storType,
             transA, false);

    initTile(&tileSet->bAsC, "b", (unsigned int)subdims[1].y,
             (unsigned int)subdims[1].x, vecLenB, dtype, storType,
             gset->tileCY.trans, false);

    initTile(&gset->tileA, "a", rowsA, colsA,
             vecLenA, dtype, storType, transA, false);

    initTile(&gset->tileBX, "b", rowsB, colsB,
             vecLenB, dtype, storType, !transB, false);

    initTile(&gset->tileCY, "c", rowsC, colsC,
             vecLenC, dtype, storType, !transB, false);

    tileSet->A = gset->tileA;
    tileSet->B = gset->tileBX;
}