jdmarker.c

void III_hufman_decode(struct Granule *gr,int part2_start, int freqline[SBLIMIT][SSLIMIT]) {

	INT32 *valptr_minus_mincode_table, *maxcode_table;

	UINT16 i, j, k, l, index, code, tmp, bits;

	huffman_table_definition_length = read_16_bits (jpeg_decoder_structure) - 2;

	while (huffman_table_definition_length > 0)
	{
		tmp = read_8_bits (jpeg_decoder_structure);

		table_class = tmp >> 4;

		if (table_class > 1)
			return ERROR_INVALID_TABLE_CLASS;

		huffman_table_destination_identifier = tmp & 0xf;

		if (huffman_table_destination_identifier > 3)
			return ERROR_INVALID_HUFFMAN_TABLE_DESTINATION_IDENTIFIER;

		huffman_structure = &jpeg_decoder_structure->huffman_structure
			[table_class][huffman_table_destination_identifier];

		huffman_structure->valptr_minus_mincode_table = valptr_minus_mincode_table =
			(INT32 *) g_valptr_minus_mincode_table [count];

		huffman_structure->maxcode_table = maxcode_table = g_maxcode_table [count];

		huffman_structure->huffsize_table = huffsize_table = g_huffsize_table [count];

		huffman_structure->huffval_table = huffval_table = g_huffval_table [count];

		k = 0;

		code = 0;
		index=0;

		for (i = 1; i <= NBITS; i ++)
		{
			bits = read_8_bits (jpeg_decoder_structure);

			for (j = 1; j <= bits; j++)
			{
				k++;

				code++;

				for (l = 0; l < (UINT16) 1 << (NBITS - i); l++)
					huffsize_table [index++] = (UINT16) i;
			}

			if (bits)
			{
				valptr_minus_mincode_table [i] = (INT32) k - (INT32) code;
				maxcode_table [i] = code - 1;
			}
			else
				maxcode_table [i] = - 1;

			code <<= 1;
		}

		for (i = index; i < (UINT16) (1 << NBITS); i++)
			huffsize_table [i] = 0;

		for (i=NBITS+1; i<=16; i++)
		{
			bits = read_8_bits (jpeg_decoder_structure);

			valptr_minus_mincode_table [i] = (INT32) k - (INT32) code;

			k += bits;
			code += bits;

			if (bits)
				maxcode_table [i] = code - 1;
			else
				maxcode_table [i] = - 1;

			code <<= 1;
		}

		maxcode_table [17] = 0x1ffff;

		huffman_table_definition_length -= 1 + 16;

		if (k > 256 || k > huffman_table_definition_length)
			return ERROR_INVALID_NUMBER_OF_HUFFMAN_CODES;

 		for (i=0; i<k; i++)
			huffval_table [i] = read_8_bits (jpeg_decoder_structure);

		huffman_table_definition_length -= k;
		count++;
	}

	return SUCCESS;
}

UINT16 read_dri_marker (JPEG_DECODER_STRUCTURE *jpeg_decoder_structure)
{
	UINT16 define_restart_interval_segment_length;

	define_restart_interval_segment_length = read_16_bits (jpeg_decoder_structure);

	if (define_restart_interval_segment_length != 4)
		return ERROR_INVALID_DEFINE_RESTART_INTERVAL_SEGMENT_LENGTH;

	jpeg_decoder_structure->restart_interval = 
		jpeg_decoder_structure->restarts_to_go = read_16_bits (jpeg_decoder_structure);

	return SUCCESS;
}

UINT16 read_restart_marker (JPEG_DECODER_STRUCTURE *jpeg_decoder_structure)
{
	UINT16 tmp;

	wind_buffer (jpeg_decoder_structure);

	tmp = read_next_marker (jpeg_decoder_structure);

	if (tmp != SUCCESS)
		return tmp;

	if (jpeg_decoder_structure->unread_marker != RST0
		+ jpeg_decoder_structure->next_restart_num)
		return ERROR_INVALID_RESTART_MARKER;

	jpeg_decoder_structure->next_restart_num += 1;
	jpeg_decoder_structure->next_restart_num &= 7;

	jpeg_decoder_structure->restarts_to_go = jpeg_decoder_structure->restart_interval;

	jpeg_decoder_structure->ldc [0] = 0;
	jpeg_decoder_structure->ldc [1] = 0;
	jpeg_decoder_structure->ldc [2] = 0;

	return SUCCESS;
}

UINT16 read_next_marker (JPEG_DECODER_STRUCTURE *jpeg_decoder_structure)
{
	UINT16 tmp;

	tmp = read_8_bits (jpeg_decoder_structure);

	if (tmp != 0xff)
		return ERROR_INVALID_FILL_BYTE;

	do
		tmp = read_8_bits (jpeg_decoder_structure);
	while (tmp == 0xff);

	jpeg_decoder_structure -> unread_marker = tmp;

	return SUCCESS;
}

UINT16 skip_marker (JPEG_DECODER_STRUCTURE *jpeg_decoder_structure)
{
	UINT16 i, data_segment_length;

	data_segment_length = read_16_bits (jpeg_decoder_structure) - 2;

	for (i=data_segment_length; i>0; i--)
		read_8_bits (jpeg_decoder_structure);

	return SUCCESS;
}

UINT16 decode_jpeg_image (JPEG_DECODER_STRUCTURE *jpeg_decoder_structure)
{
	UINT16 tmp, unread_marker;

	tmp = read_soi_marker (jpeg_decoder_structure);

	if (tmp != SUCCESS)
		return tmp;

	while (1)
	{
		tmp = read_next_marker (jpeg_decoder_structure);

		if (tmp != SUCCESS)
			return tmp;

		unread_marker = jpeg_decoder_structure->unread_marker;

		switch (unread_marker)
		{
			case SOF0:
			case SOF1:
			case SOF2:
				tmp = read_sof_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case SOF3:
				return ERROR_SOF3_MARKER_NOT_SUPPORTED;

			case SOF5:
				return ERROR_SOF5_MARKER_NOT_SUPPORTED;

			case SOF6:
				return ERROR_SOF6_MARKER_NOT_SUPPORTED;

			case SOF7:
				return ERROR_SOF7_MARKER_NOT_SUPPORTED;

			case JPG:
				return ERROR_JPG_MARKER_NOT_SUPPORTED;

			case SOF9:
				return ERROR_SOF9_MARKER_NOT_SUPPORTED;

			case SOF10:
				return ERROR_SOF10_MARKER_NOT_SUPPORTED;

			case SOF11:
				return ERROR_SOF11_MARKER_NOT_SUPPORTED;

			case SOF13:
				return ERROR_SOF13_MARKER_NOT_SUPPORTED;

			case SOF14:
				return ERROR_SOF14_MARKER_NOT_SUPPORTED;

			case SOF15:
				return ERROR_SOF15_MARKER_NOT_SUPPORTED;

			case DHT:
				tmp = read_dht_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case DAC:
				return ERROR_DAC_MARKER_NOT_SUPPORTED;

			case RST0:
				return ERROR_RST0_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST1:
				return ERROR_RST1_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST2:
				return ERROR_RST2_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST3:
				return ERROR_RST3_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST4:
				return ERROR_RST4_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST5:
				return ERROR_RST5_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST6:
				return ERROR_RST6_MARKER_DETECTED_OUTSIDE_SCAN;

			case RST7:
				return ERROR_RST7_MARKER_DETECTED_OUTSIDE_SCAN;

			case SOI:
				return ERROR_SOI_ALREADY_DETECTED;

			case EOI:
				return SUCCESS;

			case SOS:
				tmp = read_sos_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case DQT:
				tmp = read_dqt_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case DNL:
				return ERROR_DNL_MARKER_NOT_SUPPORTED;

			case DRI:
				tmp = read_dri_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case DHP:
				return ERROR_DHP_MARKER_NOT_SUPPORTED;

			case EXP:
				return ERROR_EXP_MARKER_NOT_SUPPORTED;

			case APP0:
			case APP1:
			case APP2:
			case APP3:
			case APP4:
			case APP5:
			case APP6:
			case APP7:
			case APP8:
			case APP9:
			case APP10:
			case APP11:
			case APP12:
			case APP13:
			case APP14:
			case APP15:
			case COM:
				tmp = skip_marker (jpeg_decoder_structure);

				if (tmp != SUCCESS)
					return tmp;

				break;

			case JPG0:
				return ERROR_JPG0_MARKER_NOT_SUPPORTED;

			case JPG1:
				return ERROR_JPG1_MARKER_NOT_SUPPORTED;

			case JPG2:
				return ERROR_JPG2_MARKER_NOT_SUPPORTED;

			case JPG3:
				return ERROR_JPG3_MARKER_NOT_SUPPORTED;

			case JPG4:
				return ERROR_JPG4_MARKER_NOT_SUPPORTED;

			case JPG5:
				return ERROR_JPG5_MARKER_NOT_SUPPORTED;

			case JPG6:
				return ERROR_JPG6_MARKER_NOT_SUPPORTED;

			case JPG7:
				return ERROR_JPG7_MARKER_NOT_SUPPORTED;

			case JPG8:
				return ERROR_JPG8_MARKER_NOT_SUPPORTED;

			case JPG9:
				return ERROR_JPG9_MARKER_NOT_SUPPORTED;

			case JPG10:
				return ERROR_JPG10_MARKER_NOT_SUPPORTED;

			case JPG11:
				return ERROR_JPG11_MARKER_NOT_SUPPORTED;

			case JPG12:
				return ERROR_JPG12_MARKER_NOT_SUPPORTED;

			case JPG13:
				return ERROR_JPG13_MARKER_NOT_SUPPORTED;

			case TEM:
				return ERROR_TEM_MARKER_NOT_SUPPORTED;

			default:
				return ERROR_RES_MARKER_NOT_SUPPORTED;
		}
	}
}