jdphuff.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	return TRUE;
}


/*
 * MCU decoding for AC initial scan (either spectral selection,
 * or first pass of successive approximation).
 */

METHODDEF(boolean)
decode_mcu_AC_first(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
	phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
	int Se = cinfo->Se;
	int Al = cinfo->Al;
	register int s, k, r;
	unsigned int EOBRUN;
	JBLOCKROW block;
	BITREAD_STATE_VARS;
	d_derived_tbl * tbl;

	/* Process restart marker if needed; may have to suspend */
	if (cinfo->restart_interval)
	{
		if (entropy->restarts_to_go == 0)
		{
			if (!process_restart(cinfo))
			{
				return FALSE;
			}
		}
	}

	/* If we've run out of data, just leave the MCU set to zeroes.
	 * This way, we return uniform gray for the remainder of the segment.
	 */
	if (!entropy->pub.insufficient_data)
	{
		/* Load up working state.
		 * We can avoid loading/saving bitread state if in an EOB run.
		 */
		EOBRUN = entropy->saved.EOBRUN;	/* only part of saved state we need */

		/* There is always only one block per MCU */

		if (EOBRUN > 0)		/* if it's a band of zeroes... */
		{
			EOBRUN--;
		}			/* ...process it now (we do nothing) */
		else
		{
			BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
			block = MCU_data[0];
			tbl = entropy->ac_derived_tbl;

			for (k = cinfo->Ss; k <= Se; k++)
			{
				HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
				r = s >> 4;
				s &= 15;
				if (s)
				{
					k += r;
					CHECK_BIT_BUFFER(br_state, s, return FALSE);
					r = GET_BITS(s);
					s = HUFF_EXTEND(r, s);
					/* Scale and output coefficient in natural (dezigzagged) order */
					(*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
				}
				else
				{
					if (r == 15)
					{
						/* ZRL */
						k += 15;		/* skip 15 zeroes in band */
					}
					else
					{
						/* EOBr, run length is 2^r + appended bits */
						EOBRUN = 1 << r;
						if (r)
						{
							/* EOBr, r > 0 */
							CHECK_BIT_BUFFER(br_state, r, return FALSE);
							r = GET_BITS(r);
							EOBRUN += r;
						}
						EOBRUN--;		/* this band is processed at this moment */
						break;		/* force end-of-band */
					}
				}
			}

			BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
		}

		/* Completed MCU, so update state */
		entropy->saved.EOBRUN = EOBRUN;	/* only part of saved state we need */
	}

	/* Account for restart interval (no-op if not using restarts) */
	entropy->restarts_to_go--;

	return TRUE;
}


/*
 * MCU decoding for DC successive approximation refinement scan.
 * Note: we assume such scans can be multi-component, although the spec
 * is not very clear on the point.
 */

METHODDEF(boolean)
decode_mcu_DC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
	phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
	int p1 = 1 << cinfo->Al;	/* 1 in the bit position being coded */
	int blkn;
	JBLOCKROW block;
	BITREAD_STATE_VARS;

	/* Process restart marker if needed; may have to suspend */
	if (cinfo->restart_interval)
	{
		if (entropy->restarts_to_go == 0)
		{
			if (!process_restart(cinfo))
			{
				return FALSE;
			}
		}
	}

	/* Not worth the cycles to check insufficient_data here,
	 * since we will not change the data anyway if we read zeroes.
	 */

	/* Load up working state */
	BITREAD_LOAD_STATE(cinfo, entropy->bitstate);

	/* Outer loop handles each block in the MCU */

	for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++)
	{
		block = MCU_data[blkn];

		/* Encoded data is simply the next bit of the two's-complement DC value */
		CHECK_BIT_BUFFER(br_state, 1, return FALSE);
		if (GET_BITS(1))
		{
			(*block)[0] |= p1;
		}
		/* Note: since we use |=, repeating the assignment later is safe */
	}

	/* Completed MCU, so update state */
	BITREAD_SAVE_STATE(cinfo, entropy->bitstate);

	/* Account for restart interval (no-op if not using restarts) */
	entropy->restarts_to_go--;

	return TRUE;
}


/*
 * MCU decoding for AC successive approximation refinement scan.
 */

METHODDEF(boolean)
decode_mcu_AC_refine(j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
{
	phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
	int Se = cinfo->Se;
	int p1 = 1 << cinfo->Al;	/* 1 in the bit position being coded */
	int m1 = (-1) << cinfo->Al;	/* -1 in the bit position being coded */
	register int s, k, r;
	unsigned int EOBRUN;
	JBLOCKROW block;
	JCOEFPTR thiscoef;
	BITREAD_STATE_VARS;
	d_derived_tbl * tbl;
	int num_newnz;
	int newnz_pos[DCTSIZE2];

	/* Process restart marker if needed; may have to suspend */
	if (cinfo->restart_interval)
	{
		if (entropy->restarts_to_go == 0)
		{
			if (!process_restart(cinfo))
			{
				return FALSE;
			}
		}
	}

	/* If we've run out of data, don't modify the MCU.
	 */
	if (!entropy->pub.insufficient_data)
	{
		/* Load up working state */
		BITREAD_LOAD_STATE(cinfo, entropy->bitstate);
		EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */

		/* There is always only one block per MCU */
		block = MCU_data[0];
		tbl = entropy->ac_derived_tbl;

		/* If we are forced to suspend, we must undo the assignments to any newly
		 * nonzero coefficients in the block, because otherwise we'd get confused
		 * next time about which coefficients were already nonzero.
		 * But we need not undo addition of bits to already-nonzero coefficients;
		 * instead, we can test the current bit to see if we already did it.
		 */
		num_newnz = 0;

		/* initialize coefficient loop counter to start of band */
		k = cinfo->Ss;

		if (EOBRUN == 0)
		{
			for (; k <= Se; k++)
			{
				HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
				r = s >> 4;
				s &= 15;
				if (s)
				{
					if (s != 1)		/* size of new coef should always be 1 */
					{
						WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
					}
					CHECK_BIT_BUFFER(br_state, 1, goto undoit);
					if (GET_BITS(1))
					{
						s = p1;
					}		/* newly nonzero coef is positive */
					else
					{
						s = m1;
					}		/* newly nonzero coef is negative */
				}
				else
				{
					if (r != 15)
					{
						EOBRUN = 1 << r;	/* EOBr, run length is 2^r + appended bits */
						if (r)
						{
							CHECK_BIT_BUFFER(br_state, r, goto undoit);
							r = GET_BITS(r);
							EOBRUN += r;
						}
						break;		/* rest of block is handled by EOB logic */
					}
					/* note s = 0 for processing ZRL */
				}
				/* Advance over already-nonzero coefs and r still-zero coefs,
				 * appending correction bits to the nonzeroes.  A correction bit is 1
				 * if the absolute value of the coefficient must be increased.
				 */
				do
				{
					thiscoef = *block + jpeg_natural_order[k];
					if (*thiscoef != 0)
					{
						CHECK_BIT_BUFFER(br_state, 1, goto undoit);
						if (GET_BITS(1))
						{
							if ((*thiscoef & p1) == 0)
							{
								/* do nothing if already set it */
								if (*thiscoef >= 0)
								{
									*thiscoef += p1;
								}
								else
								{
									*thiscoef += m1;
								}
							}
						}
					}
					else
					{
						if (--r < 0)
						{
							break;
						}		/* reached target zero coefficient */
					}
					k++;
				}
				while (k <= Se);
				if (s)
				{
					int pos = jpeg_natural_order[k];
					/* Output newly nonzero coefficient */
					(*block)[pos] = (JCOEF) s;
					/* Remember its position in case we have to suspend */
					newnz_pos[num_newnz++] = pos;
				}
			}
		}

		if (EOBRUN > 0)
		{
			/* Scan any remaining coefficient positions after the end-of-band
			 * (the last newly nonzero coefficient, if any).  Append a correction
			 * bit to each already-nonzero coefficient.  A correction bit is 1
			 * if the absolute value of the coefficient must be increased.
			 */
			for (; k <= Se; k++)
			{
				thiscoef = *block + jpeg_natural_order[k];
				if (*thiscoef != 0)
				{
					CHECK_BIT_BUFFER(br_state, 1, goto undoit);
					if (GET_BITS(1))
					{
						if ((*thiscoef & p1) == 0)
						{
							/* do nothing if already changed it */
							if (*thiscoef >= 0)
							{
								*thiscoef += p1;
							}
							else
							{
								*thiscoef += m1;
							}
						}
					}
				}
			}
			/* Count one block completed in EOB run */
			EOBRUN--;
		}

		/* Completed MCU, so update state */
		BITREAD_SAVE_STATE(cinfo, entropy->bitstate);
		entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
	}

	/* Account for restart interval (no-op if not using restarts) */
	entropy->restarts_to_go--;

	return TRUE;

	undoit:
	/* Re-zero any output coefficients that we made newly nonzero */
	while (num_newnz > 0)
	{
		(*block)[newnz_pos[--num_newnz]] = 0;
	}

	return FALSE;
}


/*
 * Module initialization routine for progressive Huffman entropy decoding.
 */

GLOBAL(void)
jinit_phuff_decoder(j_decompress_ptr cinfo)
{
	phuff_entropy_ptr entropy;
	int *coef_bit_ptr;
	int ci, i;

	entropy = (phuff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(phuff_entropy_decoder));
	cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
	entropy->pub.start_pass = start_pass_phuff_decoder;

	/* Mark derived tables unallocated */
	for (i = 0; i < NUM_HUFF_TBLS; i++)
	{
		entropy->derived_tbls[i] = NULL;
	}

	/* Create progression status table */
	cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->num_components * DCTSIZE2 * SIZEOF(int));
	coef_bit_ptr = &cinfo->coef_bits[0][0];
	for (ci = 0; ci < cinfo->num_components; ci++)
	{
		for (i = 0; i < DCTSIZE2; i++)
		{
			*coef_bit_ptr++ = -1;
		}
	}
}

#endif /* D_PROGRESSIVE_SUPPORTED */