jdmaster.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	/* Initialize my private state */
	master->pass_number = 0;
	master->using_merged_upsample = use_merged_upsample(cinfo);

	/* Color quantizer selection */
	master->quantizer_1pass = NULL;
	master->quantizer_2pass = NULL;
	/* No mode changes if not using buffered-image mode. */
	if (!cinfo->quantize_colors || !cinfo->buffered_image)
	{
		cinfo->enable_1pass_quant = FALSE;
		cinfo->enable_external_quant = FALSE;
		cinfo->enable_2pass_quant = FALSE;
	}
	if (cinfo->quantize_colors)
	{
		if (cinfo->raw_data_out)
		{
			ERREXIT(cinfo, JERR_NOTIMPL);
		}
		/* 2-pass quantizer only works in 3-component color space. */
		if (cinfo->out_color_components != 3)
		{
			cinfo->enable_1pass_quant = TRUE;
			cinfo->enable_external_quant = FALSE;
			cinfo->enable_2pass_quant = FALSE;
			cinfo->colormap = NULL;
		}
		else if (cinfo->colormap != NULL)
		{
			cinfo->enable_external_quant = TRUE;
		}
		else if (cinfo->two_pass_quantize)
		{
			cinfo->enable_2pass_quant = TRUE;
		}
		else
		{
			cinfo->enable_1pass_quant = TRUE;
		}

		if (cinfo->enable_1pass_quant)
		{
#ifdef QUANT_1PASS_SUPPORTED
			jinit_1pass_quantizer(cinfo);
			master->quantizer_1pass = cinfo->cquantize;
#else
			ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
		}

		/* We use the 2-pass code to map to external colormaps. */
		if (cinfo->enable_2pass_quant || cinfo->enable_external_quant)
		{
#ifdef QUANT_2PASS_SUPPORTED
			jinit_2pass_quantizer(cinfo);
			master->quantizer_2pass = cinfo->cquantize;
#else
			ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
		}
		/* If both quantizers are initialized, the 2-pass one is left active;
		 * this is necessary for starting with quantization to an external map.
		 */
	}

	/* Post-processing: in particular, color conversion first */
	if (!cinfo->raw_data_out)
	{
		if (master->using_merged_upsample)
		{
#ifdef UPSAMPLE_MERGING_SUPPORTED
			jinit_merged_upsampler(cinfo); /* does color conversion too */
#else
			ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
		}
		else
		{
			jinit_color_deconverter(cinfo);
			jinit_upsampler(cinfo);
		}
		jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
	}
	/* Inverse DCT */
	jinit_inverse_dct(cinfo);
	/* Entropy decoding: either Huffman or arithmetic coding. */
	if (cinfo->arith_code)
	{
		ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
	}
	else
	{
		if (cinfo->progressive_mode)
		{
#ifdef D_PROGRESSIVE_SUPPORTED
			jinit_phuff_decoder(cinfo);
#else
			ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif
		}
		else
		{
			jinit_huff_decoder(cinfo);
		}
	}

	/* Initialize principal buffer controllers. */
	use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
	jinit_d_coef_controller(cinfo, use_c_buffer);

	if (!cinfo->raw_data_out)
	{
		jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
	}

	/* We can now tell the memory manager to allocate virtual arrays. */
	(*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

	/* Initialize input side of decompressor to consume first scan. */
	(*cinfo->inputctl->start_input_pass) (cinfo);

#ifdef D_MULTISCAN_FILES_SUPPORTED
	/* If jpeg_start_decompress will read the whole file, initialize
	 * progress monitoring appropriately.  The input step is counted
	 * as one pass.
	 */
	if (cinfo->progress != NULL && !cinfo->buffered_image && cinfo->inputctl->has_multiple_scans)
	{
		int nscans;
		/* Estimate number of scans to set pass_limit. */
		if (cinfo->progressive_mode)
		{
			/* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
			nscans = 2 + 3 * cinfo->num_components;
		}
		else
		{
			/* For a nonprogressive multiscan file, estimate 1 scan per component. */
			nscans = cinfo->num_components;
		}
		cinfo->progress->pass_counter = 0L;
		cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
		cinfo->progress->completed_passes = 0;
		cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
		/* Count the input pass as done */
		master->pass_number++;
	}
#endif /* D_MULTISCAN_FILES_SUPPORTED */
}


/*
 * Per-pass setup.
 * This is called at the beginning of each output pass.  We determine which
 * modules will be active during this pass and give them appropriate
 * start_pass calls.  We also set is_dummy_pass to indicate whether this
 * is a "real" output pass or a dummy pass for color quantization.
 * (In the latter case, jdapistd.c will crank the pass to completion.)
 */

METHODDEF(void)
prepare_for_output_pass(j_decompress_ptr cinfo)
{
	my_master_ptr master = (my_master_ptr) cinfo->master;

	if (master->pub.is_dummy_pass)
	{
#ifdef QUANT_2PASS_SUPPORTED
		/* Final pass of 2-pass quantization */
		master->pub.is_dummy_pass = FALSE;
		(*cinfo->cquantize->start_pass) (cinfo, FALSE);
		(*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
		(*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
#else
		ERREXIT(cinfo, JERR_NOT_COMPILED);
#endif /* QUANT_2PASS_SUPPORTED */
	}
	else
	{
		if (cinfo->quantize_colors && cinfo->colormap == NULL)
		{
			/* Select new quantization method */
			if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant)
			{
				cinfo->cquantize = master->quantizer_2pass;
				master->pub.is_dummy_pass = TRUE;
			}
			else if (cinfo->enable_1pass_quant)
			{
				cinfo->cquantize = master->quantizer_1pass;
			}
			else
			{
				ERREXIT(cinfo, JERR_MODE_CHANGE);
			}
		}
		(*cinfo->idct->start_pass) (cinfo);
		(*cinfo->coef->start_output_pass) (cinfo);
		if (!cinfo->raw_data_out)
		{
			if (!master->using_merged_upsample)
			{
				(*cinfo->cconvert->start_pass) (cinfo);
			}
			(*cinfo->upsample->start_pass) (cinfo);
			if (cinfo->quantize_colors)
			{
				(*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
			}
			(*cinfo->post->start_pass) (cinfo, (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
			(*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
		}
	}

	/* Set up progress monitor's pass info if present */
	if (cinfo->progress != NULL)
	{
		cinfo->progress->completed_passes = master->pass_number;
		cinfo->progress->total_passes = master->pass_number + (master->pub.is_dummy_pass ? 2 : 1);
		/* In buffered-image mode, we assume one more output pass if EOI not
		 * yet reached, but no more passes if EOI has been reached.
		 */
		if (cinfo->buffered_image && !cinfo->inputctl->eoi_reached)
		{
			cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
		}
	}
}


/*
 * Finish up at end of an output pass.
 */

METHODDEF(void)
finish_output_pass(j_decompress_ptr cinfo)
{
	my_master_ptr master = (my_master_ptr) cinfo->master;

	if (cinfo->quantize_colors)
	{
		(*cinfo->cquantize->finish_pass) (cinfo);
	}
	master->pass_number++;
}


#ifdef D_MULTISCAN_FILES_SUPPORTED

/*
 * Switch to a new external colormap between output passes.
 */

GLOBAL(void)
jpeg_new_colormap(j_decompress_ptr cinfo)
{
	my_master_ptr master = (my_master_ptr) cinfo->master;

	/* Prevent application from calling me at wrong times */
	if (cinfo->global_state != DSTATE_BUFIMAGE)
	{
		ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
	}

	if (cinfo->quantize_colors && cinfo->enable_external_quant && cinfo->colormap != NULL)
	{
		/* Select 2-pass quantizer for external colormap use */
		cinfo->cquantize = master->quantizer_2pass;
		/* Notify quantizer of colormap change */
		(*cinfo->cquantize->new_color_map) (cinfo);
		master->pub.is_dummy_pass = FALSE; /* just in case */
	}
	else
	{
		ERREXIT(cinfo, JERR_MODE_CHANGE);
	}
}

#endif /* D_MULTISCAN_FILES_SUPPORTED */


/*
 * Initialize master decompression control and select active modules.
 * This is performed at the start of jpeg_start_decompress.
 */

GLOBAL(void)
jinit_master_decompress(j_decompress_ptr cinfo)
{
	my_master_ptr master;

	master = (my_master_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_decomp_master));
	cinfo->master = (struct jpeg_decomp_master *) master;
	master->pub.prepare_for_output_pass = prepare_for_output_pass;
	master->pub.finish_output_pass = finish_output_pass;

	master->pub.is_dummy_pass = FALSE;

	master_selection(cinfo);
}