How to extract JPEG decoder source code from stb_image.h?

[alanccw]

Hi,

I want to study and modify the JPEG decoder in stb_image.h. However, currently stb_image.h contains 9 decoders so it is a bit hard to find and study the JPEG decoder only. So how to extract the JPEG decoder source code only from stb_image.h?

There is a macro STBI_ONLY_JPEG to only include the JPEG decoder, so I try to use the following preprocessor:

cl /P /EP /C /DSTBI_ONLY_JPEG stb_image.h

But that will produce a file with all macros applied, not just STBI_ONLY_JPEG.

[nothings]

It's not quite enough to be runnable and modifiable, but for study, you primarily want two sections, code common to all decoders, and the jpeg decoder code. Those sections happen to be adjacent in the source file, so most of the JPEG decoder is just lines 1585-4081 of the current version: https://github.com/nothings/stb/blob/master/stb_image.h#L1585-L4081

[nothings]

Also, that's quite a lot of code because of optimizations and other improvements in the 16 years since it was first released. You will have an easier time with oldest version in github from 10 years ago, which is only 1250 lines instead of 2500:

stb/stb_image.h

Lines 729 to 1971 in 236004f

	//////////////////////////////////////////////////////////////////////////////
	//
	// Common code used by all image loaders
	//
	enum
	{
	SCAN_load=0,
	SCAN_type,
	SCAN_header
	};
	static void stbi__refill_buffer(stbi__context *s)
	{
	int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
	if (n == 0) {
	// at end of file, treat same as if from memory, but need to handle case
	// where s->img_buffer isn't pointing to safe memory, stbi__err.g. 0-byte file
	s->read_from_callbacks = 0;
	s->img_buffer = s->buffer_start;
	s->img_buffer_end = s->buffer_start+1;
	*s->img_buffer = 0;
	} else {
	s->img_buffer = s->buffer_start;
	s->img_buffer_end = s->buffer_start + n;
	}
	}
	stbi_inline static int stbi__get8(stbi__context *s)
	{
	if (s->img_buffer < s->img_buffer_end)
	return *s->img_buffer++;
	if (s->read_from_callbacks) {
	stbi__refill_buffer(s);
	return *s->img_buffer++;
	}
	return 0;
	}
	stbi_inline static int stbi__at_eof(stbi__context *s)
	{
	if (s->io.read) {
	if (!(s->io.eof)(s->io_user_data)) return 0;
	// if feof() is true, check if buffer = end
	// special case: we've only got the special 0 character at the end
	if (s->read_from_callbacks == 0) return 1;
	}
	return s->img_buffer >= s->img_buffer_end;
	}
	stbi_inline static stbi_uc stbi__get8u(stbi__context *s)
	{
	return (stbi_uc) stbi__get8(s);
	}
	static void stbi__skip(stbi__context *s, int n)
	{
	if (s->io.read) {
	int blen = (int) (s->img_buffer_end - s->img_buffer);
	if (blen < n) {
	s->img_buffer = s->img_buffer_end;
	(s->io.stbi__skip)(s->io_user_data, n - blen);
	return;
	}
	}
	s->img_buffer += n;
	}
	static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
	{
	if (s->io.read) {
	int blen = (int) (s->img_buffer_end - s->img_buffer);
	if (blen < n) {
	int res, count;
	memcpy(buffer, s->img_buffer, blen);
	count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
	res = (count == (n-blen));
	s->img_buffer = s->img_buffer_end;
	return res;
	}
	}
	if (s->img_buffer+n <= s->img_buffer_end) {
	memcpy(buffer, s->img_buffer, n);
	s->img_buffer += n;
	return 1;
	} else
	return 0;
	}
	static int stbi__get16be(stbi__context *s)
	{
	int z = stbi__get8(s);
	return (z << 8) + stbi__get8(s);
	}
	static stbi__uint32 stbi__get32be(stbi__context *s)
	{
	stbi__uint32 z = stbi__get16be(s);
	return (z << 16) + stbi__get16be(s);
	}
	static int stbi__get16le(stbi__context *s)
	{
	int z = stbi__get8(s);
	return z + (stbi__get8(s) << 8);
	}
	static stbi__uint32 stbi__get32le(stbi__context *s)
	{
	stbi__uint32 z = stbi__get16le(s);
	return z + (stbi__get16le(s) << 16);
	}
	//////////////////////////////////////////////////////////////////////////////
	//
	// generic converter from built-in img_n to req_comp
	// individual types do this automatically as much as possible (stbi__err.g. jpeg
	// does all cases internally since it needs to colorspace convert anyway,
	// and it never has alpha, so very few cases ). png can automatically
	// interleave an alpha=255 channel, but falls back to this for other cases
	//
	// assume data buffer is malloced, so malloc a new one and free that one
	// only failure mode is malloc failing
	static stbi_uc stbi__compute_y(int r, int g, int b)
	{
	return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);
	}
	static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
	{
	int i,j;
	unsigned char *good;
	if (req_comp == img_n) return data;
	assert(req_comp >= 1 && req_comp <= 4);
	good = (unsigned char *) malloc(req_comp * x * y);
	if (good == NULL) {
	free(data);
	return stbi__errpuc("outofmem", "Out of memory");
	}
	for (j=0; j < (int) y; ++j) {
	unsigned char *src = data + j * x * img_n ;
	unsigned char *dest = good + j * x * req_comp;
	#define COMBO(a,b) ((a)*8+(b))
	#define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
	// convert source image with img_n components to one with req_comp components;
	// avoid switch per pixel, so use switch per scanline and massive macros
	switch (COMBO(img_n, req_comp)) {
	CASE(1,2) dest[0]=src[0], dest[1]=255; break;
	CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
	CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
	CASE(2,1) dest[0]=src[0]; break;
	CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
	CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
	CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
	CASE(3,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
	CASE(3,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
	CASE(4,1) dest[0]=stbi__compute_y(src[0],src[1],src[2]); break;
	CASE(4,2) dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
	CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
	default: assert(0);
	}
	#undef CASE
	}
	free(data);
	return good;
	}
	#ifndef STBI_NO_HDR
	static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
	{
	int i,k,n;
	float *output = (float *) malloc(x * y * comp * sizeof(float));
	if (output == NULL) { free(data); return stbi__errpf("outofmem", "Out of memory"); }
	// compute number of non-alpha components
	if (comp & 1) n = comp; else n = comp-1;
	for (i=0; i < x*y; ++i) {
	for (k=0; k < n; ++k) {
	output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale;
	}
	if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
	}
	free(data);
	return output;
	}
	#define stbi__float2int(x) ((int) (x))
	static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)
	{
	int i,k,n;
	stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
	if (output == NULL) { free(data); return stbi__errpuc("outofmem", "Out of memory"); }
	// compute number of non-alpha components
	if (comp & 1) n = comp; else n = comp-1;
	for (i=0; i < x*y; ++i) {
	for (k=0; k < n; ++k) {
	float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
	if (z < 0) z = 0;
	if (z > 255) z = 255;
	output[i*comp + k] = (stbi_uc) stbi__float2int(z);
	}
	if (k < comp) {
	float z = data[i*comp+k] * 255 + 0.5f;
	if (z < 0) z = 0;
	if (z > 255) z = 255;
	output[i*comp + k] = (stbi_uc) stbi__float2int(z);
	}
	}
	free(data);
	return output;
	}
	#endif
	//////////////////////////////////////////////////////////////////////////////
	//
	// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
	//
	// simple implementation
	// - channel subsampling of at most 2 in each dimension
	// - doesn't support delayed output of y-dimension
	// - simple interface (only one output format: 8-bit interleaved RGB)
	// - doesn't try to recover corrupt jpegs
	// - doesn't allow partial loading, loading multiple at once
	// - still fast on x86 (copying globals into locals doesn't help x86)
	// - allocates lots of intermediate memory (full size of all components)
	// - non-interleaved case requires this anyway
	// - allows good upsampling (see next)
	// high-quality
	// - upsampled channels are bilinearly interpolated, even across blocks
	// - quality integer IDCT derived from IJG's 'slow'
	// performance
	// - fast huffman; reasonable integer IDCT
	// - uses a lot of intermediate memory, could cache poorly
	// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
	// stb_jpeg: 1.34 seconds (MSVC6, default release build)
	// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro)
	// IJL11.dll: 1.08 seconds (compiled by intel)
	// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG)
	// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro)
	// huffman decoding acceleration
	#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache
	typedef struct
	{
	stbi_uc fast[1 << FAST_BITS];
	// weirdly, repacking this into AoS is a 10% speed loss, instead of a win
	stbi__uint16 code[256];
	stbi_uc values[256];
	stbi_uc size[257];
	unsigned int maxcode[18];
	int delta[17]; // old 'firstsymbol' - old 'firstcode'
	} stbi__huffman;
	typedef struct
	{
	#ifdef STBI_SIMD
	unsigned short dequant2[4][64];
	#endif
	stbi__context *s;
	stbi__huffman huff_dc[4];
	stbi__huffman huff_ac[4];
	stbi_uc dequant[4][64];
	// sizes for components, interleaved MCUs
	int img_h_max, img_v_max;
	int img_mcu_x, img_mcu_y;
	int img_mcu_w, img_mcu_h;
	// definition of jpeg image component
	struct
	{
	int id;
	int h,v;
	int tq;
	int hd,ha;
	int dc_pred;
	int x,y,w2,h2;
	stbi_uc *data;
	void *raw_data;
	stbi_uc *linebuf;
	} img_comp[4];
	stbi__uint32 code_buffer; // jpeg entropy-coded buffer
	int code_bits; // number of valid bits
	unsigned char marker; // marker seen while filling entropy buffer
	int nomore; // flag if we saw a marker so must stop
	int scan_n, order[4];
	int restart_interval, todo;
	} stbi__jpeg;
	static int stbi__build_huffman(stbi__huffman *h, int *count)
	{
	int i,j,k=0,code;
	// build size list for each symbol (from JPEG spec)
	for (i=0; i < 16; ++i)
	for (j=0; j < count[i]; ++j)
	h->size[k++] = (stbi_uc) (i+1);
	h->size[k] = 0;
	// compute actual symbols (from jpeg spec)
	code = 0;
	k = 0;
	for(j=1; j <= 16; ++j) {
	// compute delta to add to code to compute symbol id
	h->delta[j] = k - code;
	if (h->size[k] == j) {
	while (h->size[k] == j)
	h->code[k++] = (stbi__uint16) (code++);
	if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG");
	}
	// compute largest code + 1 for this size, preshifted as needed later
	h->maxcode[j] = code << (16-j);
	code <<= 1;
	}
	h->maxcode[j] = 0xffffffff;
	// build non-spec acceleration table; 255 is flag for not-accelerated
	memset(h->fast, 255, 1 << FAST_BITS);
	for (i=0; i < k; ++i) {
	int s = h->size[i];
	if (s <= FAST_BITS) {
	int c = h->code[i] << (FAST_BITS-s);
	int m = 1 << (FAST_BITS-s);
	for (j=0; j < m; ++j) {
	h->fast[c+j] = (stbi_uc) i;
	}
	}
	}
	return 1;
	}
	static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
	{
	do {
	int b = j->nomore ? 0 : stbi__get8(j->s);
	if (b == 0xff) {
	int c = stbi__get8(j->s);
	if (c != 0) {
	j->marker = (unsigned char) c;
	j->nomore = 1;
	return;
	}
	}
	j->code_buffer |= b << (24 - j->code_bits);
	j->code_bits += 8;
	} while (j->code_bits <= 24);
	}
	// (1 << n) - 1
	static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
	// stbi__jpeg_huff_decode a jpeg huffman value from the bitstream
	stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
	{
	unsigned int temp;
	int c,k;
	if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
	// look at the top FAST_BITS and determine what symbol ID it is,
	// if the code is <= FAST_BITS
	c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
	k = h->fast[c];
	if (k < 255) {
	int s = h->size[k];
	if (s > j->code_bits)
	return -1;
	j->code_buffer <<= s;
	j->code_bits -= s;
	return h->values[k];
	}
	// naive test is to shift the code_buffer down so k bits are
	// valid, then test against maxcode. To speed this up, we've
	// preshifted maxcode left so that it has (16-k) 0s at the
	// end; in other words, regardless of the number of bits, it
	// wants to be compared against something shifted to have 16;
	// that way we don't need to shift inside the loop.
	temp = j->code_buffer >> 16;
	for (k=FAST_BITS+1 ; ; ++k)
	if (temp < h->maxcode[k])
	break;
	if (k == 17) {
	// error! code not found
	j->code_bits -= 16;
	return -1;
	}
	if (k > j->code_bits)
	return -1;
	// convert the huffman code to the symbol id
	c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
	assert((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
	// convert the id to a symbol
	j->code_bits -= k;
	j->code_buffer <<= k;
	return h->values[c];
	}
	// combined JPEG 'receive' and JPEG 'extend', since baseline
	// always extends everything it receives.
	stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
	{
	unsigned int m = 1 << (n-1);
	unsigned int k;
	if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
	#if 1
	k = stbi_lrot(j->code_buffer, n);
	j->code_buffer = k & ~stbi__bmask[n];
	k &= stbi__bmask[n];
	j->code_bits -= n;
	#else
	k = (j->code_buffer >> (32 - n)) & stbi__bmask[n];
	j->code_bits -= n;
	j->code_buffer <<= n;
	#endif
	// the following test is probably a random branch that won't
	// predict well. I tried to table accelerate it but failed.
	// maybe it's compiling as a conditional move?
	if (k < m)
	return (-1 << n) + k + 1;
	else
	return k;
	}
	// given a value that's at position X in the zigzag stream,
	// where does it appear in the 8x8 matrix coded as row-major?
	static stbi_uc stbi__jpeg_dezigzag[64+15] =
	{
	0, 1, 8, 16, 9, 2, 3, 10,
	17, 24, 32, 25, 18, 11, 4, 5,
	12, 19, 26, 33, 40, 48, 41, 34,
	27, 20, 13, 6, 7, 14, 21, 28,
	35, 42, 49, 56, 57, 50, 43, 36,
	29, 22, 15, 23, 30, 37, 44, 51,
	58, 59, 52, 45, 38, 31, 39, 46,
	53, 60, 61, 54, 47, 55, 62, 63,
	// let corrupt input sample past end
	63, 63, 63, 63, 63, 63, 63, 63,
	63, 63, 63, 63, 63, 63, 63
	};
	// stbi__jpeg_huff_decode one 64-entry block--
	static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, int b)
	{
	int diff,dc,k;
	int t = stbi__jpeg_huff_decode(j, hdc);
	if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG");
	// 0 all the ac values now so we can do it 32-bits at a time
	memset(data,0,64*sizeof(data[0]));
	diff = t ? stbi__extend_receive(j, t) : 0;
	dc = j->img_comp[b].dc_pred + diff;
	j->img_comp[b].dc_pred = dc;
	data[0] = (short) dc;
	// stbi__jpeg_huff_decode AC components, see JPEG spec
	k = 1;
	do {
	int r,s;
	int rs = stbi__jpeg_huff_decode(j, hac);
	if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
	s = rs & 15;
	r = rs >> 4;
	if (s == 0) {
	if (rs != 0xf0) break; // end block
	k += 16;
	} else {
	k += r;
	// stbi__jpeg_huff_decode into unzigzag'd location
	data[stbi__jpeg_dezigzag[k++]] = (short) stbi__extend_receive(j,s);
	}
	} while (k < 64);
	return 1;
	}
	// take a -128..127 value and stbi__clamp it and convert to 0..255
	stbi_inline static stbi_uc stbi__clamp(int x)
	{
	// trick to use a single test to catch both cases
	if ((unsigned int) x > 255) {
	if (x < 0) return 0;
	if (x > 255) return 255;
	}
	return (stbi_uc) x;
	}
	#define stbi__f2f(x) (int) (((x) * 4096 + 0.5))
	#define stbi__fsh(x) ((x) << 12)
	// derived from jidctint -- DCT_ISLOW
	#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
	int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
	p2 = s2; \
	p3 = s6; \
	p1 = (p2+p3) * stbi__f2f(0.5411961f); \
	t2 = p1 + p3*stbi__f2f(-1.847759065f); \
	t3 = p1 + p2*stbi__f2f( 0.765366865f); \
	p2 = s0; \
	p3 = s4; \
	t0 = stbi__fsh(p2+p3); \
	t1 = stbi__fsh(p2-p3); \
	x0 = t0+t3; \
	x3 = t0-t3; \
	x1 = t1+t2; \
	x2 = t1-t2; \
	t0 = s7; \
	t1 = s5; \
	t2 = s3; \
	t3 = s1; \
	p3 = t0+t2; \
	p4 = t1+t3; \
	p1 = t0+t3; \
	p2 = t1+t2; \
	p5 = (p3+p4)*stbi__f2f( 1.175875602f); \
	t0 = t0*stbi__f2f( 0.298631336f); \
	t1 = t1*stbi__f2f( 2.053119869f); \
	t2 = t2*stbi__f2f( 3.072711026f); \
	t3 = t3*stbi__f2f( 1.501321110f); \
	p1 = p5 + p1*stbi__f2f(-0.899976223f); \
	p2 = p5 + p2*stbi__f2f(-2.562915447f); \
	p3 = p3*stbi__f2f(-1.961570560f); \
	p4 = p4*stbi__f2f(-0.390180644f); \
	t3 += p1+p4; \
	t2 += p2+p3; \
	t1 += p2+p4; \
	t0 += p1+p3;
	#ifdef STBI_SIMD
	typedef unsigned short stbi_dequantize_t;
	#else
	typedef stbi_uc stbi_dequantize_t;
	#endif
	// .344 seconds on 3*anemones.jpg
	static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64], stbi_dequantize_t *dequantize)
	{
	int i,val[64],*v=val;
	stbi_dequantize_t *dq = dequantize;
	stbi_uc *o;
	short *d = data;
	// columns
	for (i=0; i < 8; ++i,++d,++dq, ++v) {
	// if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
	if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
	&& d[40]==0 && d[48]==0 && d[56]==0) {
	// no shortcut 0 seconds
	// (1|2|3|4|5|6|7)==0 0 seconds
	// all separate -0.047 seconds
	// 1 && 2|3 && 4|5 && 6|7: -0.047 seconds
	int dcterm = d[0] * dq[0] << 2;
	v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
	} else {
	STBI__IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
	d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56])
	// constants scaled things up by 1<<12; let's bring them back
	// down, but keep 2 extra bits of precision
	x0 += 512; x1 += 512; x2 += 512; x3 += 512;
	v[ 0] = (x0+t3) >> 10;
	v[56] = (x0-t3) >> 10;
	v[ 8] = (x1+t2) >> 10;
	v[48] = (x1-t2) >> 10;
	v[16] = (x2+t1) >> 10;
	v[40] = (x2-t1) >> 10;
	v[24] = (x3+t0) >> 10;
	v[32] = (x3-t0) >> 10;
	}
	}
	for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
	// no fast case since the first 1D IDCT spread components out
	STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
	// constants scaled things up by 1<<12, plus we had 1<<2 from first
	// loop, plus horizontal and vertical each scale by sqrt(8) so together
	// we've got an extra 1<<3, so 1<<17 total we need to remove.
	// so we want to round that, which means adding 0.5 * 1<<17,
	// aka 65536. Also, we'll end up with -128 to 127 that we want
	// to encode as 0..255 by adding 128, so we'll add that before the shift
	x0 += 65536 + (128<<17);
	x1 += 65536 + (128<<17);
	x2 += 65536 + (128<<17);
	x3 += 65536 + (128<<17);
	// tried computing the shifts into temps, or'ing the temps to see
	// if any were out of range, but that was slower
	o[0] = stbi__clamp((x0+t3) >> 17);
	o[7] = stbi__clamp((x0-t3) >> 17);
	o[1] = stbi__clamp((x1+t2) >> 17);
	o[6] = stbi__clamp((x1-t2) >> 17);
	o[2] = stbi__clamp((x2+t1) >> 17);
	o[5] = stbi__clamp((x2-t1) >> 17);
	o[3] = stbi__clamp((x3+t0) >> 17);
	o[4] = stbi__clamp((x3-t0) >> 17);
	}
	}
	#ifdef STBI_SIMD
	static stbi_idct_8x8 stbi__idct_installed = stbi__idct_block;
	STBIDEF void stbi_install_idct(stbi_idct_8x8 func)
	{
	stbi__idct_installed = func;
	}
	#endif
	#define STBI__MARKER_none 0xff
	// if there's a pending marker from the entropy stream, return that
	// otherwise, fetch from the stream and get a marker. if there's no
	// marker, return 0xff, which is never a valid marker value
	static stbi_uc stbi__get_marker(stbi__jpeg *j)
	{
	stbi_uc x;
	if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
	x = stbi__get8u(j->s);
	if (x != 0xff) return STBI__MARKER_none;
	while (x == 0xff)
	x = stbi__get8u(j->s);
	return x;
	}
	// in each scan, we'll have scan_n components, and the order
	// of the components is specified by order[]
	#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
	// after a restart interval, stbi__jpeg_reset the entropy decoder and
	// the dc prediction
	static void stbi__jpeg_reset(stbi__jpeg *j)
	{
	j->code_bits = 0;
	j->code_buffer = 0;
	j->nomore = 0;
	j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
	j->marker = STBI__MARKER_none;
	j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
	// no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
	// since we don't even allow 1<<30 pixels
	}
	static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
	{
	stbi__jpeg_reset(z);
	if (z->scan_n == 1) {
	int i,j;
	#ifdef STBI_SIMD
	__declspec(align(16))
	#endif
	short data[64];
	int n = z->order[0];
	// non-interleaved data, we just need to process one block at a time,
	// in trivial scanline order
	// number of blocks to do just depends on how many actual "pixels" this
	// component has, independent of interleaved MCU blocking and such
	int w = (z->img_comp[n].x+7) >> 3;
	int h = (z->img_comp[n].y+7) >> 3;
	for (j=0; j < h; ++j) {
	for (i=0; i < w; ++i) {
	if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
	#ifdef STBI_SIMD
	stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
	#else
	stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
	#endif
	// every data block is an MCU, so countdown the restart interval
	if (--z->todo <= 0) {
	if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
	// if it's NOT a restart, then just bail, so we get corrupt data
	// rather than no data
	if (!STBI__RESTART(z->marker)) return 1;
	stbi__jpeg_reset(z);
	}
	}
	}
	} else { // interleaved!
	int i,j,k,x,y;
	short data[64];
	for (j=0; j < z->img_mcu_y; ++j) {
	for (i=0; i < z->img_mcu_x; ++i) {
	// scan an interleaved mcu... process scan_n components in order
	for (k=0; k < z->scan_n; ++k) {
	int n = z->order[k];
	// scan out an mcu's worth of this component; that's just determined
	// by the basic H and V specified for the component
	for (y=0; y < z->img_comp[n].v; ++y) {
	for (x=0; x < z->img_comp[n].h; ++x) {
	int x2 = (i*z->img_comp[n].h + x)*8;
	int y2 = (j*z->img_comp[n].v + y)*8;
	if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
	#ifdef STBI_SIMD
	stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
	#else
	stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
	#endif
	}
	}
	}
	// after all interleaved components, that's an interleaved MCU,
	// so now count down the restart interval
	if (--z->todo <= 0) {
	if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
	// if it's NOT a restart, then just bail, so we get corrupt data
	// rather than no data
	if (!STBI__RESTART(z->marker)) return 1;
	stbi__jpeg_reset(z);
	}
	}
	}
	}
	return 1;
	}
	static int stbi__process_marker(stbi__jpeg *z, int m)
	{
	int L;
	switch (m) {
	case STBI__MARKER_none: // no marker found
	return stbi__err("expected marker","Corrupt JPEG");
	case 0xC2: // stbi__SOF - progressive
	return stbi__err("progressive jpeg","JPEG format not supported (progressive)");
	case 0xDD: // DRI - specify restart interval
	if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
	z->restart_interval = stbi__get16be(z->s);
	return 1;
	case 0xDB: // DQT - define quantization table
	L = stbi__get16be(z->s)-2;
	while (L > 0) {
	int q = stbi__get8(z->s);
	int p = q >> 4;
	int t = q & 15,i;
	if (p != 0) return stbi__err("bad DQT type","Corrupt JPEG");
	if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
	for (i=0; i < 64; ++i)
	z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8u(z->s);
	#ifdef STBI_SIMD
	for (i=0; i < 64; ++i)
	z->dequant2[t][i] = z->dequant[t][i];
	#endif
	L -= 65;
	}
	return L==0;
	case 0xC4: // DHT - define huffman table
	L = stbi__get16be(z->s)-2;
	while (L > 0) {
	stbi_uc *v;
	int sizes[16],i,n=0;
	int q = stbi__get8(z->s);
	int tc = q >> 4;
	int th = q & 15;
	if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
	for (i=0; i < 16; ++i) {
	sizes[i] = stbi__get8(z->s);
	n += sizes[i];
	}
	L -= 17;
	if (tc == 0) {
	if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
	v = z->huff_dc[th].values;
	} else {
	if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
	v = z->huff_ac[th].values;
	}
	for (i=0; i < n; ++i)
	v[i] = stbi__get8u(z->s);
	L -= n;
	}
	return L==0;
	}
	// check for comment block or APP blocks
	if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
	stbi__skip(z->s, stbi__get16be(z->s)-2);
	return 1;
	}
	return 0;
	}
	// after we see stbi__SOS
	static int stbi__process_scan_header(stbi__jpeg *z)
	{
	int i;
	int Ls = stbi__get16be(z->s);
	z->scan_n = stbi__get8(z->s);
	if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad stbi__SOS component count","Corrupt JPEG");
	if (Ls != 6+2*z->scan_n) return stbi__err("bad stbi__SOS len","Corrupt JPEG");
	for (i=0; i < z->scan_n; ++i) {
	int id = stbi__get8(z->s), which;
	int q = stbi__get8(z->s);
	for (which = 0; which < z->s->img_n; ++which)
	if (z->img_comp[which].id == id)
	break;
	if (which == z->s->img_n) return 0;
	z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
	z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
	z->order[i] = which;
	}
	if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG");
	stbi__get8(z->s); // should be 63, but might be 0
	if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG");
	return 1;
	}
	static int stbi__process_frame_header(stbi__jpeg *z, int scan)
	{
	stbi__context *s = z->s;
	int Lf,p,i,q, h_max=1,v_max=1,c;
	Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad stbi__SOF len","Corrupt JPEG"); // JPEG
	p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
	s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
	s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
	c = stbi__get8(s);
	if (c != 3 && c != 1) return stbi__err("bad component count","Corrupt JPEG"); // JFIF requires
	s->img_n = c;
	for (i=0; i < c; ++i) {
	z->img_comp[i].data = NULL;
	z->img_comp[i].linebuf = NULL;
	}
	if (Lf != 8+3*s->img_n) return stbi__err("bad stbi__SOF len","Corrupt JPEG");
	for (i=0; i < s->img_n; ++i) {
	z->img_comp[i].id = stbi__get8(s);
	if (z->img_comp[i].id != i+1) // JFIF requires
	if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files!
	return stbi__err("bad component ID","Corrupt JPEG");
	q = stbi__get8(s);
	z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
	z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
	z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
	}
	if (scan != SCAN_load) return 1;
	if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to stbi__jpeg_huff_decode");
	for (i=0; i < s->img_n; ++i) {
	if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
	if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
	}
	// compute interleaved mcu info
	z->img_h_max = h_max;
	z->img_v_max = v_max;
	z->img_mcu_w = h_max * 8;
	z->img_mcu_h = v_max * 8;
	z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
	z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
	for (i=0; i < s->img_n; ++i) {
	// number of effective pixels (stbi__err.g. for non-interleaved MCU)
	z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
	z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
	// to simplify generation, we'll allocate enough memory to stbi__jpeg_huff_decode
	// the bogus oversized data from using interleaved MCUs and their
	// big blocks (stbi__err.g. a 16x16 iMCU on an image of width 33); we won't
	// discard the extra data until colorspace conversion
	z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
	z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
	z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
	if (z->img_comp[i].raw_data == NULL) {
	for(--i; i >= 0; --i) {
	free(z->img_comp[i].raw_data);
	z->img_comp[i].data = NULL;
	}
	return stbi__err("outofmem", "Out of memory");
	}
	// align blocks for installable-idct using mmx/sse
	z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
	z->img_comp[i].linebuf = NULL;
	}
	return 1;
	}
	// use comparisons since in some cases we handle more than one case (stbi__err.g. stbi__SOF)
	#define stbi__DNL(x) ((x) == 0xdc)
	#define stbi__SOI(x) ((x) == 0xd8)
	#define stbi__EOI(x) ((x) == 0xd9)
	#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1)
	#define stbi__SOS(x) ((x) == 0xda)
	static int decode_jpeg_header(stbi__jpeg *z, int scan)
	{
	int m;
	z->marker = STBI__MARKER_none; // initialize cached marker to empty
	m = stbi__get_marker(z);
	if (!stbi__SOI(m)) return stbi__err("no stbi__SOI","Corrupt JPEG");
	if (scan == SCAN_type) return 1;
	m = stbi__get_marker(z);
	while (!stbi__SOF(m)) {
	if (!stbi__process_marker(z,m)) return 0;
	m = stbi__get_marker(z);
	while (m == STBI__MARKER_none) {
	// some files have extra padding after their blocks, so ok, we'll scan
	if (stbi__at_eof(z->s)) return stbi__err("no stbi__SOF", "Corrupt JPEG");
	m = stbi__get_marker(z);
	}
	}
	if (!stbi__process_frame_header(z, scan)) return 0;
	return 1;
	}
	static int decode_jpeg_image(stbi__jpeg *j)
	{
	int m;
	j->restart_interval = 0;
	if (!decode_jpeg_header(j, SCAN_load)) return 0;
	m = stbi__get_marker(j);
	while (!stbi__EOI(m)) {
	if (stbi__SOS(m)) {
	if (!stbi__process_scan_header(j)) return 0;
	if (!stbi__parse_entropy_coded_data(j)) return 0;
	if (j->marker == STBI__MARKER_none ) {
	// handle 0s at the end of image data from IP Kamera 9060
	while (!stbi__at_eof(j->s)) {
	int x = stbi__get8(j->s);
	if (x == 255) {
	j->marker = stbi__get8u(j->s);
	break;
	} else if (x != 0) {
	return 0;
	}
	}
	// if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
	}
	} else {
	if (!stbi__process_marker(j, m)) return 0;
	}
	m = stbi__get_marker(j);
	}
	return 1;
	}
	// static jfif-centered resampling (across block boundaries)
	typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
	int w, int hs);
	#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
	static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
	{
	STBI_NOTUSED(out);
	STBI_NOTUSED(in_far);
	STBI_NOTUSED(w);
	STBI_NOTUSED(hs);
	return in_near;
	}
	static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
	{
	// need to generate two samples vertically for every one in input
	int i;
	STBI_NOTUSED(hs);
	for (i=0; i < w; ++i)
	out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
	return out;
	}
	static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
	{
	// need to generate two samples horizontally for every one in input
	int i;
	stbi_uc *input = in_near;
	if (w == 1) {
	// if only one sample, can't do any interpolation
	out[0] = out[1] = input[0];
	return out;
	}
	out[0] = input[0];
	out[1] = stbi__div4(input[0]*3 + input[1] + 2);
	for (i=1; i < w-1; ++i) {
	int n = 3*input[i]+2;
	out[i*2+0] = stbi__div4(n+input[i-1]);
	out[i*2+1] = stbi__div4(n+input[i+1]);
	}
	out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
	out[i*2+1] = input[w-1];
	STBI_NOTUSED(in_far);
	STBI_NOTUSED(hs);
	return out;
	}
	#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
	static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
	{
	// need to generate 2x2 samples for every one in input
	int i,t0,t1;
	if (w == 1) {
	out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
	return out;
	}
	t1 = 3*in_near[0] + in_far[0];
	out[0] = stbi__div4(t1+2);
	for (i=1; i < w; ++i) {
	t0 = t1;
	t1 = 3*in_near[i]+in_far[i];
	out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
	out[i*2 ] = stbi__div16(3*t1 + t0 + 8);
	}
	out[w*2-1] = stbi__div4(t1+2);
	STBI_NOTUSED(hs);
	return out;
	}
	static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
	{
	// resample with nearest-neighbor
	int i,j;
	STBI_NOTUSED(in_far);
	for (i=0; i < w; ++i)
	for (j=0; j < hs; ++j)
	out[i*hs+j] = in_near[i];
	return out;
	}
	#define float2fixed(x) ((int) ((x) * 65536 + 0.5))
	// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro)
	// VC6 without processor=Pro is generating multiple LEAs per multiply!
	static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
	{
	int i;
	for (i=0; i < count; ++i) {
	int y_fixed = (y[i] << 16) + 32768; // rounding
	int r,g,b;
	int cr = pcr[i] - 128;
	int cb = pcb[i] - 128;
	r = y_fixed + cr*float2fixed(1.40200f);
	g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
	b = y_fixed + cb*float2fixed(1.77200f);
	r >>= 16;
	g >>= 16;
	b >>= 16;
	if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
	if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
	if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
	out[0] = (stbi_uc)r;
	out[1] = (stbi_uc)g;
	out[2] = (stbi_uc)b;
	out[3] = 255;
	out += step;
	}
	}
	#ifdef STBI_SIMD
	static stbi_YCbCr_to_RGB_run stbi__YCbCr_installed = stbi__YCbCr_to_RGB_row;
	STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
	{
	stbi__YCbCr_installed = func;
	}
	#endif
	// clean up the temporary component buffers
	static void stbi__cleanup_jpeg(stbi__jpeg *j)
	{
	int i;
	for (i=0; i < j->s->img_n; ++i) {
	if (j->img_comp[i].data) {
	free(j->img_comp[i].raw_data);
	j->img_comp[i].data = NULL;
	}
	if (j->img_comp[i].linebuf) {
	free(j->img_comp[i].linebuf);
	j->img_comp[i].linebuf = NULL;
	}
	}
	}
	typedef struct
	{
	resample_row_func resample;
	stbi_uc *line0,*line1;
	int hs,vs; // expansion factor in each axis
	int w_lores; // horizontal pixels pre-expansion
	int ystep; // how far through vertical expansion we are
	int ypos; // which pre-expansion row we're on
	} stbi__resample;
	static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
	{
	int n, decode_n;
	// validate req_comp
	if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
	z->s->img_n = 0;
	// load a jpeg image from whichever source
	if (!decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
	// determine actual number of components to generate
	n = req_comp ? req_comp : z->s->img_n;
	if (z->s->img_n == 3 && n < 3)
	decode_n = 1;
	else
	decode_n = z->s->img_n;
	// resample and color-convert
	{
	int k;
	unsigned int i,j;
	stbi_uc *output;
	stbi_uc *coutput[4];
	stbi__resample res_comp[4];
	for (k=0; k < decode_n; ++k) {
	stbi__resample *r = &res_comp[k];
	// allocate line buffer big enough for upsampling off the edges
	// with upsample factor of 4
	z->img_comp[k].linebuf = (stbi_uc *) malloc(z->s->img_x + 3);
	if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
	r->hs = z->img_h_max / z->img_comp[k].h;
	r->vs = z->img_v_max / z->img_comp[k].v;
	r->ystep = r->vs >> 1;
	r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
	r->ypos = 0;
	r->line0 = r->line1 = z->img_comp[k].data;
	if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
	else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
	else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
	else if (r->hs == 2 && r->vs == 2) r->resample = stbi__resample_row_hv_2;
	else r->resample = stbi__resample_row_generic;
	}
	// can't error after this so, this is safe
	output = (stbi_uc *) malloc(n * z->s->img_x * z->s->img_y + 1);
	if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
	// now go ahead and resample
	for (j=0; j < z->s->img_y; ++j) {
	stbi_uc *out = output + n * z->s->img_x * j;
	for (k=0; k < decode_n; ++k) {
	stbi__resample *r = &res_comp[k];
	int y_bot = r->ystep >= (r->vs >> 1);
	coutput[k] = r->resample(z->img_comp[k].linebuf,
	y_bot ? r->line1 : r->line0,
	y_bot ? r->line0 : r->line1,
	r->w_lores, r->hs);
	if (++r->ystep >= r->vs) {
	r->ystep = 0;
	r->line0 = r->line1;
	if (++r->ypos < z->img_comp[k].y)
	r->line1 += z->img_comp[k].w2;
	}
	}
	if (n >= 3) {
	stbi_uc *y = coutput[0];
	if (z->s->img_n == 3) {
	#ifdef STBI_SIMD
	stbi__YCbCr_installed(out, y, coutput[1], coutput[2], z->s->img_x, n);
	#else
	stbi__YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n);
	#endif
	} else
	for (i=0; i < z->s->img_x; ++i) {
	out[0] = out[1] = out[2] = y[i];
	out[3] = 255; // not used if n==3
	out += n;
	}
	} else {
	stbi_uc *y = coutput[0];
	if (n == 1)
	for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
	else
	for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
	}
	}
	stbi__cleanup_jpeg(z);
	*out_x = z->s->img_x;
	*out_y = z->s->img_y;
	if (comp) *comp = z->s->img_n; // report original components, not output
	return output;
	}
	}
	static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
	{
	stbi__jpeg j;
	j.s = s;
	return load_jpeg_image(&j, x,y,comp,req_comp);
	}
	static int stbi__jpeg_test(stbi__context *s)
	{
	int r;
	stbi__jpeg j;
	j.s = s;
	r = decode_jpeg_header(&j, SCAN_type);
	stbi__rewind(s);
	return r;
	}
	static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
	{
	if (!decode_jpeg_header(j, SCAN_header)) {
	stbi__rewind( j->s );
	return 0;
	}
	if (x) *x = j->s->img_x;
	if (y) *y = j->s->img_y;
	if (comp) *comp = j->s->img_n;
	return 1;
	}
	static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
	{
	stbi__jpeg j;
	j.s = s;
	return stbi__jpeg_info_raw(&j, x, y, comp);
	}