python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2024-12-28 10:56:18 +03:00
Code Issues Packages Projects Releases Wiki Activity

store SgiRleDecoder elements in SGISTATE struct

Browse Source
This commit is contained in:
Mickael B 2017-07-29 02:39:37 -04:00 committed by Eric Soroos
parent c55b3aa402
commit 7fe23b39b9
2 changed files with 58 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
libImaging/Sgi.h
View File

@ -7,4 +7,34 @@ typedef struct {
/* Number of bytes per channel per pixel */
int bpc;
/* RLE offsets table */
uint32_t *starttab;
/* RLE lengths table */
uint32_t *lengthtab;
/* current row offset */
uint32_t rleoffset;
/* current row length */
uint32_t rlelength;
/* RLE table size */
int tablen;
/* RLE table index */
int tabindex;
/* buffer index */
int bufindex;
/* current row index */
int rowno;
/* current channel index */
int channo;
/* image data size from file descriptor */
long bufsize;
} SGISTATE;

59
libImaging/SgiRleDecode.c
View File

@ -92,24 +92,21 @@ int
ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
UINT8* buf, int bytes)
{
uint32_t *starttab, *lengthtab, rleoffset, rlelength;
int tablen, i, j, rowno, channo;
long bufsize;
UINT8 *ptr;
SGISTATE *context;
SGISTATE *c;
/* Get all data from File descriptor */
c = (SGISTATE*)state->context;
_imaging_seek_pyFd(state->fd, 0L, SEEK_END);
bufsize = _imaging_tell_pyFd(state->fd);
bufsize -= SGI_HEADER_SIZE;
ptr = malloc(sizeof(UINT8) * bufsize);
c->bufsize = _imaging_tell_pyFd(state->fd);
c->bufsize -= SGI_HEADER_SIZE;
ptr = malloc(sizeof(UINT8) * c->bufsize);
_imaging_seek_pyFd(state->fd, SGI_HEADER_SIZE, SEEK_SET);
_imaging_read_pyFd(state->fd, (char*)ptr, bufsize);
_imaging_read_pyFd(state->fd, (char*)ptr, c->bufsize);
/* decoder initialization */
state->count = 0;
context = (SGISTATE*)state->context;
state->y = 0;
if (state->ystep < 0)
state->y = im->ysize - 1;
@ -119,39 +116,39 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
/* Allocate memory for RLE tables and rows */
free(state->buffer);
state->buffer = malloc(sizeof(UINT8) * 2 * im->xsize * im->bands);
tablen = im->bands * im->ysize;
starttab = calloc(tablen, sizeof(uint32_t));
lengthtab = calloc(tablen, sizeof(uint32_t));
c->tablen = im->bands * im->ysize;
c->starttab = calloc(c->tablen, sizeof(uint32_t));
c->lengthtab = calloc(c->tablen, sizeof(uint32_t));
/* populate offsets table */
for (i = 0, j = 0; i < tablen; i++, j+=4)
read4B(&starttab[i], &ptr[j]);
for (c->tabindex = 0, c->bufindex = 0; c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4)
read4B(&c->starttab[c->tabindex], &ptr[c->bufindex]);
/* populate lengths table */
for (i = 0, j = tablen * sizeof(uint32_t); i < tablen; i++, j+=4)
read4B(&lengthtab[i], &ptr[j]);
for (c->tabindex = 0, c->bufindex = c->tablen * sizeof(uint32_t); c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4)
read4B(&c->lengthtab[c->tabindex], &ptr[c->bufindex]);
state->count += tablen * sizeof(uint32_t) * 2;
state->count += c->tablen * sizeof(uint32_t) * 2;
/* read compressed rows */
for (rowno = 0; rowno < im->ysize; rowno++, state->y += state->ystep)
for (c->rowno = 0; c->rowno < im->ysize; c->rowno++, state->y += state->ystep)
{
for (channo = 0; channo < im->bands; channo++)
for (c->channo = 0; c->channo < im->bands; c->channo++)
{
rleoffset = starttab[rowno + channo * im->ysize];
rlelength = lengthtab[rowno + channo * im->ysize];
rleoffset -= SGI_HEADER_SIZE;
c->rleoffset = c->starttab[c->rowno + c->channo * im->ysize];
c->rlelength = c->lengthtab[c->rowno + c->channo * im->ysize];
c->rleoffset -= SGI_HEADER_SIZE;
/* row decompression */
if (context->bpc ==1) {
if(expandrow(&state->buffer[channo], &ptr[rleoffset], rlelength, im->bands))
if (c->bpc ==1) {
if(expandrow(&state->buffer[c->channo], &ptr[c->rleoffset], c->rlelength, im->bands))
goto sgi_finish_decode;
}
else {
if(expandrow2((UINT16*)&state->buffer[channo * 2], (UINT16*)&ptr[rleoffset], rlelength, im->bands))
if(expandrow2((UINT16*)&state->buffer[c->channo * 2], (UINT16*)&ptr[c->rleoffset], c->rlelength, im->bands))
goto sgi_finish_decode;
}
state->count += rlelength;
state->count += c->rlelength;
}
/* store decompressed data in image */
@ -159,13 +156,13 @@ ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
}
bufsize++;
c->bufsize++;
sgi_finish_decode:
sgi_finish_decode: ;
free(starttab);
free(lengthtab);
free(c->starttab);
free(c->lengthtab);
free(ptr);
return state->count - bufsize;
return state->count - c->bufsize;
}