#2704

pending completion

Build # #2704

Build Type

push

github-actions

Committed by

hugovk

Commit Message

Test on new Travis CPUs https://blog.travis-ci.com/2019-11-12-multi-cpu-architecture-ibm-power-ibm-z

Run Details

18 of 18 new or added lines in 5 files covered. (100.0%)

35045 of 40293 relevant lines covered (86.98%)

199285.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.43

/src/libImaging/SgiRleDecode.c

/*
 * The Python Imaging Library.
 * $Id$
 *
 * decoder for Sgi RLE data.
 *
 * history:
 * 2017-07-28 mb    fixed for images larger than 64KB
 * 2017-07-20 mb        created
 *
 * Copyright (c) Mickael Bonfill 2017.
 *
 * See the README file for information on usage and redistribution.
 */

#include "Imaging.h"
#include "Sgi.h"

#define SGI_HEADER_SIZE 512
#define RLE_COPY_FLAG 0x80
#define RLE_MAX_RUN 0x7f

static void read4B(UINT32* dest, UINT8* buf)
{
    *dest = (UINT32)((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]);
}

static int expandrow(UINT8* dest, UINT8* src, int n, int z, int xsize)
{
    UINT8 pixel, count;

    for (;n > 0; n--)
    {
        pixel = *src++;
        if (n == 1 && pixel != 0)
            return n;
        count = pixel & RLE_MAX_RUN;
        if (!count)
            return count;
        if (count > xsize) {
            return -1;
        }
        if (pixel & RLE_COPY_FLAG) {
            while(count--) {
                *dest = *src++;
                dest += z;
            }

        }
        else {
            pixel = *src++;
            while (count--) {
                *dest = pixel;
                dest += z;
            }
        }

    }
    return 0;
}

static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)
{
    UINT8 pixel, count;


    for (;n > 0; n--)
    {
        pixel = src[1];
        src+=2;
        if (n == 1 && pixel != 0)
            return n;
        count = pixel & RLE_MAX_RUN;
        if (!count)
            return count;
        if (count > xsize) {
            return -1;
        }
        if (pixel & RLE_COPY_FLAG) {
            while(count--) {
                memcpy(dest, src, 2);
                src += 2;
                dest += z * 2;
            }
        }
        else {
            while (count--) {
                memcpy(dest, src, 2);
                dest += z * 2;
            }
            src+=2;
        }
    }
    return 0;
}


int
ImagingSgiRleDecode(Imaging im, ImagingCodecState state,
                    UINT8* buf, Py_ssize_t bytes)
{
    UINT8 *ptr;
    SGISTATE *c;
    int err = 0;
    int status;

    /* Get all data from File descriptor */
    c = (SGISTATE*)state->context;
    _imaging_seek_pyFd(state->fd, 0L, SEEK_END);
    c->bufsize = _imaging_tell_pyFd(state->fd);
    c->bufsize -= SGI_HEADER_SIZE;
    ptr = malloc(sizeof(UINT8) * c->bufsize);
    if (!ptr) {
        return IMAGING_CODEC_MEMORY;
    }
    _imaging_seek_pyFd(state->fd, SGI_HEADER_SIZE, SEEK_SET);
    _imaging_read_pyFd(state->fd, (char*)ptr, c->bufsize);


    /* decoder initialization */
    state->count = 0;
    state->y = 0;
    if (state->ystep < 0) {
        state->y = im->ysize - 1;
    } else {
        state->ystep = 1;
    }

    if (im->xsize > INT_MAX / im->bands ||
        im->ysize > INT_MAX / im->bands) {
        err = IMAGING_CODEC_MEMORY;
        goto sgi_finish_decode;
    }

    /* Allocate memory for RLE tables and rows */
    free(state->buffer);
    state->buffer = NULL;
    /* malloc overflow check above */
    state->buffer = calloc(im->xsize * im->bands, sizeof(UINT8) * 2);
    c->tablen = im->bands * im->ysize;
    c->starttab = calloc(c->tablen, sizeof(UINT32));
    c->lengthtab = calloc(c->tablen, sizeof(UINT32));
    if (!state->buffer ||
        !c->starttab ||
        !c->lengthtab) {
        err = IMAGING_CODEC_MEMORY;
        goto sgi_finish_decode;
    }
    /* populate offsets table */
    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 (c->tabindex = 0, c->bufindex = c->tablen * sizeof(UINT32); c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4)
        read4B(&c->lengthtab[c->tabindex], &ptr[c->bufindex]);

    state->count += c->tablen * sizeof(UINT32) * 2;

    /* read compressed rows */
    for (c->rowno = 0; c->rowno < im->ysize; c->rowno++, state->y += state->ystep)
    {
        for (c->channo = 0; c->channo < im->bands; c->channo++)
        {
            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;

            if (c->rleoffset + c->rlelength > c->bufsize) {
                state->errcode = IMAGING_CODEC_OVERRUN;
                return -1;
            }

            /* row decompression */
            if (c->bpc ==1) {
                status = expandrow(&state->buffer[c->channo], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);
            }
            else {
                status = expandrow2(&state->buffer[c->channo * 2], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);
            }
            if (status == -1) {
                state->errcode = IMAGING_CODEC_OVERRUN;
                return -1;
            } else if (status == 1) {
                goto sgi_finish_decode;
            }

            state->count += c->rlelength;
        }

        /* store decompressed data in image */
        state->shuffle((UINT8*)im->image[state->y], state->buffer, im->xsize);

    }

    c->bufsize++;

sgi_finish_decode: ;

    free(c->starttab);
    free(c->lengthtab);
    free(ptr);
    if (err != 0){
        return err;
    }
    return state->count - c->bufsize;
}

1	/*
2	* The Python Imaging Library.
3	* $Id$
4	*
5	* decoder for Sgi RLE data.
6	*
7	* history:
8	* 2017-07-28 mb fixed for images larger than 64KB
9	* 2017-07-20 mb created
10	*
11	* Copyright (c) Mickael Bonfill 2017.
12	*
13	* See the README file for information on usage and redistribution.
14	*/
15
16	#include "Imaging.h"
17	#include "Sgi.h"
18
19	#define SGI_HEADER_SIZE 512
20	#define RLE_COPY_FLAG 0x80
21	#define RLE_MAX_RUN 0x7f
22
23	static void read4B(UINT32* dest, UINT8* buf)	4,428✔
24	{
25	*dest = (UINT32)((buf[0] << 24) \| (buf[1] << 16) \| (buf[2] << 8) \| buf[3]);	4,428✔
26	}	4,428✔
27
28	static int expandrow(UINT8* dest, UINT8* src, int n, int z, int xsize)	390✔
29	{
30	UINT8 pixel, count;
31
32	for (;n > 0; n--)	4,029✔
33	{
34	pixel = *src++;	4,029✔
35	if (n == 1 && pixel != 0)	4,029✔
36	return n;	×
37	count = pixel & RLE_MAX_RUN;	4,029✔
38	if (!count)	4,029✔
39	return count;	389✔
40	if (count > xsize) {	3,640✔
41	return -1;	1✔
42	}
43	if (pixel & RLE_COPY_FLAG) {	3,639✔
44	while(count--) {	44,413✔
45	dest = src++;	42,875✔
46	dest += z;	42,875✔
47	}
48
49	}
50	else {
51	pixel = *src++;	2,101✔
52	while (count--) {	8,892✔
53	*dest = pixel;	6,791✔
54	dest += z;	6,791✔
55	}
56	}
57
58	}
59	return 0;	×
60	}	390✔
61
62	static int expandrow2(UINT8* dest, const UINT8* src, int n, int z, int xsize)	1,441✔
63	{
64	UINT8 pixel, count;
65
66
67	for (;n > 0; n--)	16,264✔
68	{
69	pixel = src[1];	16,264✔
70	src+=2;	16,264✔
71	if (n == 1 && pixel != 0)	16,264✔
72	return n;	×
73	count = pixel & RLE_MAX_RUN;	16,264✔
74	if (!count)	16,264✔
75	return count;	1,440✔
76	if (count > xsize) {	14,824✔
77	return -1;	1✔
78	}
79	if (pixel & RLE_COPY_FLAG) {	14,823✔
80	while(count--) {	464,578✔
81	memcpy(dest, src, 2);	458,332✔
82	src += 2;	458,332✔
83	dest += z * 2;	458,332✔
84	}
85	}
86	else {
87	while (count--) {	471,845✔
88	memcpy(dest, src, 2);	463,268✔
89	dest += z * 2;	463,268✔
90	}
91	src+=2;	8,577✔
92	}
93	}
94	return 0;	×
95	}	1,441✔
96
97
98	int
99	ImagingSgiRleDecode(Imaging im, ImagingCodecState state,	5✔
100	UINT8* buf, Py_ssize_t bytes)
101	{
102	UINT8 *ptr;
103	SGISTATE *c;
104	int err = 0;
105	int status;
106
107	/* Get all data from File descriptor */
108	c = (SGISTATE*)state->context;	5✔
109	_imaging_seek_pyFd(state->fd, 0L, SEEK_END);	5✔
110	c->bufsize = _imaging_tell_pyFd(state->fd);	5✔
111	c->bufsize -= SGI_HEADER_SIZE;	5✔
112	ptr = malloc(sizeof(UINT8) * c->bufsize);	5✔
113	if (!ptr) {	5✔
114	return IMAGING_CODEC_MEMORY;	×
115	}
116	_imaging_seek_pyFd(state->fd, SGI_HEADER_SIZE, SEEK_SET);	5✔
117	_imaging_read_pyFd(state->fd, (char*)ptr, c->bufsize);	5✔
118
119
120	/* decoder initialization */
121	state->count = 0;	5✔
122	state->y = 0;	5✔
123	if (state->ystep < 0) {	5✔
124	state->y = im->ysize - 1;	5✔
125	} else {	5✔
126	state->ystep = 1;	×
127	}
128
129	if (im->xsize > INT_MAX / im->bands \|\|	5✔
130	im->ysize > INT_MAX / im->bands) {	5✔
131	err = IMAGING_CODEC_MEMORY;
132	goto sgi_finish_decode;	×
133	}
134
135	/* Allocate memory for RLE tables and rows */
136	free(state->buffer);	5✔
137	state->buffer = NULL;	5✔
138	/* malloc overflow check above */
139	state->buffer = calloc(im->xsize * im->bands, sizeof(UINT8) * 2);	5✔
140	c->tablen = im->bands * im->ysize;	5✔
141	c->starttab = calloc(c->tablen, sizeof(UINT32));	5✔
142	c->lengthtab = calloc(c->tablen, sizeof(UINT32));	5✔
143	if (!state->buffer \|\|	10✔
144	!c->starttab \|\|	5✔
145	!c->lengthtab) {	5✔
146	err = IMAGING_CODEC_MEMORY;
147	goto sgi_finish_decode;	×
148	}
149	/* populate offsets table */
150	for (c->tabindex = 0, c->bufindex = 0; c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4)	2,219✔
151	read4B(&c->starttab[c->tabindex], &ptr[c->bufindex]);	2,214✔
152	/* populate lengths table */
153	for (c->tabindex = 0, c->bufindex = c->tablen * sizeof(UINT32); c->tabindex < c->tablen; c->tabindex++, c->bufindex+=4)	2,219✔
154	read4B(&c->lengthtab[c->tabindex], &ptr[c->bufindex]);	2,214✔
155
156	state->count += c->tablen * sizeof(UINT32) * 2;	5✔
157
158	/* read compressed rows */
159	for (c->rowno = 0; c->rowno < im->ysize; c->rowno++, state->y += state->ystep)	614✔
160	{
161	for (c->channo = 0; c->channo < im->bands; c->channo++)	2,441✔
162	{
163	c->rleoffset = c->starttab[c->rowno + c->channo * im->ysize];	1,832✔
164	c->rlelength = c->lengthtab[c->rowno + c->channo * im->ysize];	1,832✔
165	c->rleoffset -= SGI_HEADER_SIZE;	1,832✔
166
167	if (c->rleoffset + c->rlelength > c->bufsize) {	1,832✔
168	state->errcode = IMAGING_CODEC_OVERRUN;	1✔
169	return -1;	1✔
170	}
171
172	/* row decompression */
173	if (c->bpc ==1) {	1,831✔
174	status = expandrow(&state->buffer[c->channo], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);	390✔
175	}	390✔
176	else {
177	status = expandrow2(&state->buffer[c->channo * 2], &ptr[c->rleoffset], c->rlelength, im->bands, im->xsize);	1,441✔
178	}
179	if (status == -1) {	1,831✔
180	state->errcode = IMAGING_CODEC_OVERRUN;	2✔
181	return -1;	2✔
182	} else if (status == 1) {	1,829✔
183	goto sgi_finish_decode;
184	}
185
186	state->count += c->rlelength;	1,829✔
187	}
188
189	/* store decompressed data in image */
190	state->shuffle((UINT8*)im->image[state->y], state->buffer, im->xsize);	609✔
191
192	}
193
194	c->bufsize++;	2✔
195
196	sgi_finish_decode: ;
197
198	free(c->starttab);	2✔
199	free(c->lengthtab);	2✔
200	free(ptr);	2✔
201	if (err != 0){	2✔
202	return err;	×
203	}
204	return state->count - c->bufsize;	2✔
205	}	5✔

hugovk / Pillow / #2704

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous