lossless_d.c

实现了JPEG-LS的标准算法

	}
	else
	/***********************************************/
	/* Do for all pixels in the row in 16-bit mode */
	/***********************************************/
	{

		Rc = ENDIAN16(psl[0]);
		Rb = ENDIAN16(psl[1]);
		Ra = ENDIAN16(sl[0]);

		i = 1;
		do {

			pixel Px;

			Rd = ENDIAN16(psl[i + 1]);

			/* Quantize the gradient */
			{
				register int diff;

				/* Following segment assumes that T3 <= LUTMAX16 */
				/* This condition should have been checked when the
					lookup tables were built */
				diff = Rd - Rb;
				if (diff < 0)
					cont = (diff > -LUTMAX16) ? vLUT[0][diff + LUTMAX16] : 7*CREGIONS*CREGIONS;
				else 
					cont = (diff < LUTMAX16) ? vLUT[0][diff + LUTMAX16] : 8*CREGIONS*CREGIONS;

				diff = Rb - Rc;
				if (diff < 0)
					cont += (diff > -LUTMAX16) ? vLUT[1][diff + LUTMAX16] : 7*CREGIONS;
				else 
					cont += (diff < LUTMAX16) ? vLUT[1][diff + LUTMAX16] : 8*CREGIONS;
				
				diff = Rc - Ra;
				if (diff < 0)
					cont += (diff > -LUTMAX16) ? vLUT[2][diff + LUTMAX16] : 7;
				else 
					cont += (diff < LUTMAX16) ? vLUT[2][diff + LUTMAX16] : 8;
			}

			if ( cont == 0 ) {

		    /********** RUN STATE **********/

				register int n, m;

				/* get length of the run */
				/* arg is # of pixels left */
				m = n = process_run_dec(no-i+1, color); 

				if ( m > 0 )  {  /* run of nonzero length, otherwise
									we go directly to the end-of-run 
									state */
					do {
						sl[i++] = ENDIAN16(Ra);
					}	while(--n > 0);

					if (i > no)
						/* end of line */
						return 0;

					/* update context pixels */
				    Rb = ENDIAN16(psl[i]);
				    Rd = ENDIAN16(psl[i + 1]);
				}

			
				/* Do end of run encoding for LOSSLESS images */
				Ra = lossless_end_of_run_d(Ra, Rb, (Ra==Rb));
	
			}
			else 
			{
			/********** REGULAR CONTEXT **********/

				predict(Rb, Ra, Rc);

				/* map symmetric contexts */
				cont = classmap[cont];

				if (cont < 0) 
				{
					SIGN = -1;
					cont = -cont;
				}
				else
					SIGN = +1;

				/* decode a Rice code of a given context */
				Ra = lossless_regular_mode_d(cont, SIGN, Px);

			}

			sl[i] = ENDIAN16(Ra);
			Rc = Rb;
			Rb = Rd;
			++i;

		} while (i <= no);

	} /* End "if 8/16 bit" */

	return 0;
}







/* For DEOCODING pixel interleavde mode for LOSSLESS images */

int lossless_undoscanline_pixel(pixel *psl,		/* previous scanline */
								pixel *sl,		/* current scanline */
								int no)			/* number of values in it */
/*** watch it! actual pixels in the scan line are numbered 1 to no .
     pixels with indices < 1 or > no are dummy "border" pixels  */
{
	int i, psfix, n_c, color, enter_run=0, break_run, was_in_run = 0,
	    test_run;
	pixel Ra, Rb, Rc, Rd;
	pixel c_aa[MAX_COMPONENTS],
	      c_bb[MAX_COMPONENTS],
	      c_cc[MAX_COMPONENTS],
	      c_dd[MAX_COMPONENTS],
	      c_xx[MAX_COMPONENTS];


	int	SIGN;
	int cont,c_cont[MAX_COMPONENTS];

	psfix = 0;

	/**********************************************/
	/* Do for all pixels in the row in 8-bit mode */
	/**********************************************/
	if (bpp16==FALSE)
	{

		for (n_c=0; n_c<components; n_c++) {
			c_cc[n_c] = psl[n_c];
			c_bb[n_c] = psl[components+n_c];
			c_aa[n_c] = sl[n_c];
		}

		i = components;
		color = -1;

		do {
			pixel Px;

			if (!was_in_run) color = (color+1)%components;
			else color = 0;

			if (color == 0)

				for (n_c=0;n_c<components;n_c++) {
					c_dd[n_c] = psl[i + components + n_c];

					/* Quantize the gradient */		   
					c_cont[n_c] =	vLUT[0][c_dd[n_c] - c_bb[n_c] + LUTMAX8] +
									vLUT[1][c_bb[n_c] - c_cc[n_c] + LUTMAX8] +
									vLUT[2][c_cc[n_c] - c_aa[n_c] + LUTMAX8];
				}

			Ra=c_aa[color];
			Rb=c_bb[color];
			Rc=c_cc[color];
			Rd=c_dd[color];
			cont=c_cont[color];

			enter_run = was_in_run = test_run = 0;
		
			if (color == 0) {
				test_run = 1;
				for (n_c=0;n_c<components;n_c++)
					if (c_cont[n_c]!=0) {
						test_run=0;
						break;
					}
			}

			if ( test_run ) {

		    /********** RUN STATE *********/

				register int n, m;

				enter_run = was_in_run = 1;

				/* get length of the run */
				/* arg is # of pixels left */
				m = n = process_run_dec((no+components-1-i+1)/components, 0); 

				if ( m > 0 )  {  /* run of nonzero length, otherwise
									we go directly to the end-of-run 
									state */
					do {
						for (n_c=0;n_c<components;n_c++) {
							sl[i++] = c_aa[n_c];
						}
					} while(--n > 0);

					if (i > no+components-1)
					    /* end of line */
					    return 0;

					/* update context pixels */
					for (n_c=0;n_c<components;n_c++) {
			    		c_bb[n_c] = psl[i+n_c];
			    		c_dd[n_c] = psl[i+components+n_c];
					}
				}

				/* here we handle the "end-of-run" stat */

				for (n_c=0;n_c<components;n_c++) {
				/* The end of run is processed for each component */
					Ra = c_aa[n_c];
					Rb = c_bb[n_c];
					c_aa[n_c] = c_xx[n_c] = lossless_end_of_run_d(Ra, Rb, 0);
				}       /* Components loop */

			}       /* Run state block */
			else {

			/******* REGULAR CONTEXT *******/

				predict(Rb, Ra, Rc);
		
			    cont = classmap[cont];
				if (cont < 0) 
				{
					SIGN = -1;
					cont = -cont;
				}
				else
					SIGN = +1;

				/* decode a Rice code of a given context */
				c_aa[color] = Ra = lossless_regular_mode_d(cont, SIGN, Px);
			}

			if (!was_in_run) {
				sl[i] = Ra;
				c_cc[color] = Rb;
				c_bb[color] = Rd;
				i++;
			}
			else {
				for (n_c=0;n_c<components;n_c++) {
					sl[i+n_c] = c_aa[n_c];
					c_cc[n_c] = c_bb[n_c];
					c_bb[n_c] = c_dd[n_c];
				}
				i+=components;
			}
			
		} while (i <= (no+components-1));

	}
	else
	/***********************************************/
	/* Do for all pixels in the row in 16-bit mode */
	/***********************************************/
	{

		for (n_c=0; n_c<components; n_c++) {
			c_cc[n_c] = ENDIAN16(psl[n_c]);
			c_bb[n_c] = ENDIAN16(psl[components+n_c]);
			c_aa[n_c] = ENDIAN16(sl[n_c]);
		}

		i = components;
		color = -1;

		do {
			pixel Px;

			if (!was_in_run) color = (color+1)%components;
			else color = 0;

			if (color == 0)
				for (n_c=0;n_c<components;n_c++) {

					c_dd[n_c] = ENDIAN16(psl[i + components + n_c]);

					/* Quantize the gradient */
					{
						register int diff;

						/* Following segment assumes that T3 <= LUTMAX16 */
						/* This condition should have been checked when the
						lookup tables were built */
						diff = c_dd[n_c] - c_bb[n_c];
						if (diff < 0)
							c_cont[n_c] = (diff > -LUTMAX16) ? vLUT[0][diff + LUTMAX16] : 7*CREGIONS*CREGIONS;
						else 
							c_cont[n_c] = (diff < LUTMAX16) ? vLUT[0][diff + LUTMAX16] : 8*CREGIONS*CREGIONS;

						diff = c_bb[n_c] - c_cc[n_c];
						if (diff < 0)
							c_cont[n_c] += (diff > -LUTMAX16) ? vLUT[1][diff + LUTMAX16] : 7*CREGIONS;
						else 
							c_cont[n_c] += (diff < LUTMAX16) ? vLUT[1][diff + LUTMAX16] : 8*CREGIONS;

						diff = c_cc[n_c] - c_aa[n_c];
						if (diff < 0)
							c_cont[n_c] += (diff > -LUTMAX16) ? vLUT[2][diff + LUTMAX16] : 7;
						else 
							c_cont[n_c] += (diff < LUTMAX16) ? vLUT[2][diff + LUTMAX16] : 8;
					}
				}

			Ra=c_aa[color];
			Rb=c_bb[color];
			Rc=c_cc[color];
			Rd=c_dd[color];
			cont=c_cont[color];

			enter_run = was_in_run = test_run = 0;
		
			if (color == 0) {
				test_run = 1;
				for (n_c=0;n_c<components;n_c++)
					if (c_cont[n_c]!=0) {
						test_run=0;
						break;
					}
			}

			if ( test_run ) {

		    /********* RUN STATE *********/

				register int n, m;

				enter_run = was_in_run = 1;

				/* get length of the run */
				/* arg is # of pixels left */
				m = n = process_run_dec((no+components-1-i+1)/components, 0); 

				if ( m > 0 )  {  /* run of nonzero length, otherwise
									we go directly to the end-of-run 
									state */
					do {
						for (n_c=0;n_c<components;n_c++) {
							sl[i++] = ENDIAN16(c_aa[n_c]);
						}
					} while(--n > 0);

					if (i > no+components-1)
						/* end of line */
						return 0;

					/* update context pixels */
					for (n_c=0;n_c<components;n_c++) {
			    		c_bb[n_c] = ENDIAN16(psl[i+n_c]);
			    		c_dd[n_c] = ENDIAN16(psl[i+components+n_c]);
					}
				}

				/* here we handle the "end-of-run" state */
				for (n_c=0;n_c<components;n_c++) {
					/* The end of run is processed for each component */
					Ra = c_aa[n_c];
					Rb = c_bb[n_c];

					c_aa[n_c] = c_xx[n_c] = lossless_end_of_run_d(Ra, Rb, 0);
				}       /* Components loop */

			}       /* Run state block */
			else {

			/******** REGULAR CONTEXT ********/

				predict(Rb, Ra, Rc);
			
				cont = classmap[cont];
			
				if (cont < 0) 
				{
					SIGN = -1;
					cont = -cont;
				}
				else
					SIGN = +1;

				/* decode a Rice code of a given context */
				c_aa[color] = Ra = lossless_regular_mode_d(cont, SIGN, Px);

			}

			if (!was_in_run) {
				sl[i] = ENDIAN16(Ra);
				c_cc[color] = Rb;
				c_bb[color] = Rd;
				i++;
			}
			else {
				for (n_c=0;n_c<components;n_c++) {
				sl[i+n_c] = ENDIAN16(c_aa[n_c]);
				c_cc[n_c] = c_bb[n_c];
				c_bb[n_c] = c_dd[n_c];
				}
				i+=components;
			}

		} while (i <= (no+components-1));

	} /* ends "if 8/16 bit */

	return 0;
}