/*
* Get a strip-organized image that has
* PlanarConfiguration contiguous if SamplesPerPixel > 1
* or
* SamplesPerPixel == 1
*/
boolean TIFFRasterImpl::gtStripContig(
const RGBvalue* Map, u_long h, u_long w
) {
u_char* buf = new u_char[TIFFStripSize(tif_)];
if (buf == nil) {
TIFFError(TIFFFileName(tif_), "No space for strip buffer");
return (false);
}
tileContigRoutine put = pickTileContigCase(Map);
u_long y = setorientation(h);
int toskew = (int)(orientation_ == ORIENTATION_TOPLEFT ? -w + -w : -w + w);
u_long rowsperstrip = (u_long) -1L;
TIFFGetField(tif_, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
u_long imagewidth;
TIFFGetField(tif_, TIFFTAG_IMAGEWIDTH, &imagewidth);
int scanline = TIFFScanlineSize(tif_);
int fromskew = (int)(w < imagewidth ? imagewidth - w : 0);
for (u_long row = 0; row < h; row += rowsperstrip) {
u_int nrow = u_int(row + rowsperstrip > h ? h - row : rowsperstrip);
if (TIFFReadEncodedStrip(
tif_, TIFFComputeStrip(tif_, row, 0), buf, nrow*scanline) < 0
) {
break;
}
(this->*put)(raster_ + y*w, buf, Map, w, nrow, fromskew, toskew);
y += (orientation_ == ORIENTATION_TOPLEFT ? -nrow : nrow);
}
delete buf;
return true;
}
/*
* Get a strip-organized image with
* SamplesPerPixel > 1
* PlanarConfiguration separated
* We assume that all such images are RGB.
*/
static int
gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileSeparateRoutine put = img->put.separate;
uint16 orientation;
u_char *buf;
u_char *r, *g, *b, *a;
uint32 row, y, nrow;
tsize_t scanline;
uint32 rowsperstrip;
uint32 imagewidth = img->width;
tsize_t stripsize;
int32 fromskew, toskew;
int alpha = img->alpha;
stripsize = TIFFStripSize(tif);
r = buf = (u_char *)_TIFFmalloc(4*stripsize);
if (buf == 0) {
TIFFError(TIFFFileName(tif), "No space for tile buffer");
return (0);
}
g = r + stripsize;
b = g + stripsize;
a = b + stripsize;
if (!alpha)
memset(a, 0xff, stripsize);
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w);
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0);
for (row = 0; row < h; row += rowsperstrip) {
nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
r, nrow*scanline) < 0 && img->stoponerr)
break;
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 1),
g, nrow*scanline) < 0 && img->stoponerr)
break;
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 2),
b, nrow*scanline) < 0 && img->stoponerr)
break;
if (alpha &&
(TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 3),
a, nrow*scanline) < 0 && img->stoponerr))
break;
(*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, r, g, b, a);
y += (orientation == ORIENTATION_TOPLEFT ?
-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (1);
}
/*
* Get an tile-organized image that has
* SamplesPerPixel > 1
* PlanarConfiguration separated
* We assume that all such images are RGB.
*/
boolean TIFFRasterImpl::gtTileSeparate(
const RGBvalue* Map, u_long h, u_long w
) {
u_long tilesize = TIFFTileSize(tif_);
u_char* buf = new u_char[3*tilesize];
if (buf == nil) {
TIFFError(TIFFFileName(tif_), "No space for tile buffer");
return false;
}
u_char* r = buf;
u_char* g = r + tilesize;
u_char* b = g + tilesize;
tileSeparateRoutine put = pickTileSeparateCase(Map);
u_long tw;
TIFFGetField(tif_, TIFFTAG_TILEWIDTH, &tw);
u_long th;
TIFFGetField(tif_, TIFFTAG_TILELENGTH, &th);
u_long y = setorientation(h);
int toskew = (int)(orientation_ == ORIENTATION_TOPLEFT ? -tw+-w : -tw+w);
for (u_long row = 0; row < h; row += th) {
u_long nrow = (row + th > h ? h - row : th);
for (u_long col = 0; col < w; col += tw) {
if (TIFFReadTile(tif_, r, col, row, 0, 0) < 0) {
break;
}
if (TIFFReadTile(tif_, g, col, row, 0, 1) < 0) {
break;
}
if (TIFFReadTile(tif_, b, col, row, 0, 2) < 0) {
break;
}
if (col + tw > w) {
/*
* Tile is clipped horizontally. Calculate
* visible portion and skewing factors.
*/
u_long npix = w - col;
int fromskew = (int)(tw - npix);
(this->*put)(
raster_ + y*w + col, r, g, b, Map,
npix, nrow, fromskew, toskew + fromskew
);
} else
(this->*put)(
raster_ + y*w + col, r, g, b, Map,
tw, nrow, 0, toskew
);
}
y += (orientation_ == ORIENTATION_TOPLEFT ? -nrow : nrow);
}
delete buf;
return true;
}
/*
* Get a strip-organized image that has
* PlanarConfiguration contiguous if SamplesPerPixel > 1
* or
* SamplesPerPixel == 1
*
* Hacked from the tif_getimage.c file.
*
* This is set up to allow us to just copy the data to the raster
* for 1-bit bitmaps
*/
static int
getStripContig1Bit(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint16 orientation;
uint32 row, y, nrow, rowstoread;
uint32 pos;
u_char* buf;
uint32 rowsperstrip;
uint32 imagewidth = img->width;
tsize_t scanline;
int32 fromskew, toskew;
tstrip_t strip;
tsize_t stripsize;
u_char* braster = (u_char*)raster; // byte wide raster
uint32 wb = WIDTHBYTES(w);
int ret = 1;
buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
return (0);
}
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? wb+wb : wb-wb);
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0)/8;
for (row = 0; row < h; row += nrow)
{
rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
nrow = (row + rowstoread > h ? h - row : rowstoread);
strip = TIFFComputeStrip(tif,row+img->row_offset, 0);
stripsize = ((row + img->row_offset)%rowsperstrip + nrow) * scanline;
if (TIFFReadEncodedStrip(tif, strip, buf, stripsize ) < 0
&& img->stoponerr)
{
ret = 0;
break;
}
pos = ((row + img->row_offset) % rowsperstrip) * scanline;
(*put)(img, (uint32*)(braster+y*wb), 0, y, w, nrow, fromskew, toskew, buf + pos);
y += (orientation == ORIENTATION_TOPLEFT ?-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (ret);
}
/*
* Get an tile-organized image that has
* PlanarConfiguration contiguous if SamplesPerPixel > 1
* or
* SamplesPerPixel == 1
*/
static int
gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint16 orientation;
uint32 col, row, y;
uint32 tw, th;
u_char* buf;
int32 fromskew, toskew;
uint32 nrow;
buf = (u_char*) _TIFFmalloc(TIFFTileSize(tif));
if (buf == 0) {
TIFFError(TIFFFileName(tif), "No space for tile buffer");
return (0);
}
TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w);
for (row = 0; row < h; row += th) {
nrow = (row + th > h ? h - row : th);
for (col = 0; col < w; col += tw) {
if (TIFFReadTile(tif, buf, col, row, 0, 0) < 0 && img->stoponerr)
break;
if (col + tw > w) {
/*
* Tile is clipped horizontally. Calculate
* visible portion and skewing factors.
*/
uint32 npix = w - col;
fromskew = tw - npix;
(*put)(img, raster+y*w+col, col, y,
npix, nrow, fromskew, toskew + fromskew, buf);
} else {
(*put)(img, raster+y*w+col, col, y, tw, nrow, 0, toskew, buf);
}
}
y += (orientation == ORIENTATION_TOPLEFT ?
-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (1);
}
int main(void) {
ALCdevice *dev;
dev = alcOpenDevice( NULL );
if( dev == NULL ) {
return 1;
}
context_id = alcCreateContext( dev, NULL);
if(context_id == NULL) {
alcCloseDevice( dev );
return 1;
}
alcMakeContextCurrent( context_id );
fixup_function_pointers();
setposition(-10.0, 10, 10);
setposition(10.0, 10, 10);
setposition(0.0, 10, 10);
setposition(0.0, 0, 0);
setorientation(0.0, 0, -1, 0, 1, 0);
setorientation(0.0, 0, 1, 0, 1, 0);
setorientation(0.0, 0, 1, 0, 1, 0);
setposition(2, 2, 2);
setorientation(0.0, 0, 1, 0, 1, 0);
setposition(0, 0, 0);
setorientation(0.0, 0, 1, 0, 1, 0);
setposition(0, -10, 0);
setorientation(1, 1, -1, 0, 1, 0);
setposition(0, 0, 0);
setorientation(0.0, 0, 1, 0, 1, 0);
alcDestroyContext(context_id);
alcCloseDevice( dev );
return 0;
}
/*
* Get a strip-organized image with
* SamplesPerPixel > 1
* PlanarConfiguration separated
* We assume that all such images are RGB.
*/
boolean TIFFRasterImpl::gtStripSeparate(
const RGBvalue* Map, u_long h, u_long w
) {
u_long stripsize = TIFFStripSize(tif_);
u_char* buf = new u_char[3*stripsize];
u_char* r = buf;
u_char* g = r + stripsize;
u_char* b = g + stripsize;
tileSeparateRoutine put = pickTileSeparateCase(Map);
u_long y = setorientation(h);
int toskew = (int)(orientation_ == ORIENTATION_TOPLEFT ? -w + -w : -w + w);
u_long rowsperstrip = (u_long) -1L;
TIFFGetField(tif_, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
u_long imagewidth;
TIFFGetField(tif_, TIFFTAG_IMAGEWIDTH, &imagewidth);
int scanline = TIFFScanlineSize(tif_);
int fromskew = (int)(w < imagewidth ? imagewidth - w : 0);
for (u_long row = 0; row < h; row += rowsperstrip) {
u_int nrow = u_int(row + rowsperstrip > h ? h - row : rowsperstrip);
if (TIFFReadEncodedStrip(
tif_, TIFFComputeStrip(tif_, row, 0), r, nrow*scanline) < 0
) {
break;
}
if (TIFFReadEncodedStrip(
tif_, TIFFComputeStrip(tif_, row, 1), g, nrow*scanline) < 0
) {
break;
}
if (TIFFReadEncodedStrip(
tif_, TIFFComputeStrip(tif_, row, 2), b, nrow*scanline) < 0
) {
break;
}
(this->*put)(raster_ + y*w, r, g, b, Map, w, nrow, fromskew, toskew);
y += (orientation_ == ORIENTATION_TOPLEFT ? -nrow : nrow);
}
delete buf;
return true;
}
/*
* Get a strip-organized image that has
* PlanarConfiguration contiguous if SamplesPerPixel > 1
* or
* SamplesPerPixel == 1
*/
static int
gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint16 orientation;
uint32 row, y, nrow;
u_char* buf;
uint32 rowsperstrip;
uint32 imagewidth = img->width;
tsize_t scanline;
int32 fromskew, toskew;
buf = (u_char*) _TIFFmalloc(TIFFStripSize(tif));
if (buf == 0) {
TIFFError(TIFFFileName(tif), "No space for strip buffer");
return (0);
}
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? w+w : w-w);
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0);
for (row = 0; row < h; row += rowsperstrip) {
nrow = (row + rowsperstrip > h ? h - row : rowsperstrip);
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, row, 0),
buf, nrow*scanline) < 0 && img->stoponerr)
break;
(*put)(img, raster+y*w, 0, y, w, nrow, fromskew, toskew, buf);
y += (orientation == ORIENTATION_TOPLEFT ?
-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (1);
}
/*
* Get an tile-organized image that has
* SamplesPerPixel > 1
* PlanarConfiguration separated
* We assume that all such images are RGB.
*/
static int
gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
{
TIFF* tif = img->tif;
tileSeparateRoutine put = img->put.separate;
uint16 orientation;
uint32 col, row, y;
uint32 tw, th;
u_char* buf;
u_char* r;
u_char* g;
u_char* b;
u_char* a;
tsize_t tilesize;
int32 fromskew, toskew;
int alpha = img->alpha;
uint32 nrow;
tilesize = TIFFTileSize(tif);
buf = (u_char*) _TIFFmalloc(4*tilesize);
if (buf == 0) {
TIFFError(TIFFFileName(tif), "No space for tile buffer");
return (0);
}
r = buf;
g = r + tilesize;
b = g + tilesize;
a = b + tilesize;
if (!alpha)
memset(a, 0xff, tilesize);
TIFFGetField(tif, TIFFTAG_TILEWIDTH, &tw);
TIFFGetField(tif, TIFFTAG_TILELENGTH, &th);
y = setorientation(img, h);
orientation = img->orientation;
toskew = -(int32) (orientation == ORIENTATION_TOPLEFT ? tw+w : tw-w);
for (row = 0; row < h; row += th) {
nrow = (row + th > h ? h - row : th);
for (col = 0; col < w; col += tw) {
if (TIFFReadTile(tif, r, col, row,0,0) < 0 && img->stoponerr)
break;
if (TIFFReadTile(tif, g, col, row,0,1) < 0 && img->stoponerr)
break;
if (TIFFReadTile(tif, b, col, row,0,2) < 0 && img->stoponerr)
break;
if (alpha && TIFFReadTile(tif,a,col,row,0,3) < 0 && img->stoponerr)
break;
if (col + tw > w) {
/*
* Tile is clipped horizontally. Calculate
* visible portion and skewing factors.
*/
uint32 npix = w - col;
fromskew = tw - npix;
(*put)(img, raster+y*w+col, col, y,
npix, nrow, fromskew, toskew + fromskew, r, g, b, a);
} else {
(*put)(img, raster+y*w+col, col, y,
tw, nrow, 0, toskew, r, g, b, a);
}
}
y += (orientation == ORIENTATION_TOPLEFT ?
-(int32) nrow : (int32) nrow);
}
_TIFFfree(buf);
return (1);
}