python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2024-12-30 20:06:17 +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 */ /* Number of bytes per channel per pixel */
int bpc; 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; } SGISTATE;

59
libImaging/SgiRleDecode.c
View File

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