void transfer_bytes(kdu_byte *dest, kdu_line_buf &src, int gap, int precision)
/* Transfers source samples from the supplied line buffer into the output
byte buffer, spacing successive output samples apart by `gap' bytes
(to allow for interleaving of colour components).  The function performs
all necessary level shifting, type conversion, rounding and truncation. */
{
	int width = src.get_width();
	if (src.get_buf32() != NULL)
	{ // Decompressed samples have a 32-bit representation (integer or float)
		assert(precision >= 8); // Else would have used 16 bit representation
		kdu_sample32 *sp = src.get_buf32();
		if (!src.is_absolute())
		{ // Transferring normalized floating point data.
			float scale16 = (float)(1<<16);
			kdu_int32 val;

			for (; width > 0; width--, sp++, dest+=gap)
			{
				val = (kdu_int32)(sp->fval*scale16);
				val = (val+128)>>8; // May be faster than true rounding
				val += 128;
				if (val & ((-1)<<8))
				{
					val = (val < 0 ? 0 : 255);
				}
				*dest = (kdu_byte) val;
			}
		}
Exemplo n.º 2
0
bool LLKDUMemIn::get(int comp_idx, kdu_line_buf &line, int x_tnum)
{
	int idx = comp_idx - this->first_comp_idx;
	assert((idx >= 0) && (idx < num_components));
	x_tnum = x_tnum*num_components+idx;
	image_line_buf *scan, *prev=NULL;
	for (scan = incomplete_lines; scan != NULL; prev = scan, scan = scan->next)
	{
		assert(scan->next_x_tnum >= x_tnum);
		if (scan->next_x_tnum == x_tnum)
		{
			break;
		}
	}
	if (scan == NULL)
	{ // Need to read a new image line.
		assert(x_tnum == 0); // Must consume in very specific order.
		if (num_unread_rows == 0)
		{
	        return false;
		}
		if ((scan = free_lines) == NULL)
		{
			scan = new image_line_buf(cols+3,num_components);
		}
		free_lines = scan->next;
		if (prev == NULL)
		{
	        incomplete_lines = scan;
		}
		else
		{
			prev->next = scan;
		}

		// Copy from image buffer into scan.
		memcpy(scan->buf, mData+mCurPos, cols*num_components);
		mCurPos += cols*num_components;

		num_unread_rows--;
		scan->accessed_samples = 0;
		scan->next_x_tnum = 0;
	}

	assert((cols-scan->accessed_samples) >= line.get_width());

	int comp_offset = idx;
	kdu_byte *sp = scan->buf+num_components*scan->accessed_samples + comp_offset;
	int n=line.get_width();

	if (line.get_buf32() != NULL)
	{
		kdu_sample32 *dp = line.get_buf32();
		if (line.is_absolute())
		{ // 32-bit absolute integers
			for (; n > 0; n--, sp+=num_components, dp++)
			{
				dp->ival = ((kdu_int32)(*sp)) - 128;
			}
		}
		else
		{ // true 32-bit floats
			for (; n > 0; n--, sp+=num_components, dp++)
			{
				dp->fval = (((float)(*sp)) / 256.0F) - 0.5F;
			}
		}
	}
	else
	{
		kdu_sample16 *dp = line.get_buf16();
		if (line.is_absolute())
		{ // 16-bit absolute integers
			for (; n > 0; n--, sp+=num_components, dp++)
			{
				dp->ival = ((kdu_int16)(*sp)) - 128;
			}
		}
		else
		{ // 16-bit normalized representation.
			for (; n > 0; n--, sp+=num_components, dp++)
			{
				dp->ival = (((kdu_int16)(*sp)) - 128) << (KDU_FIX_POINT-8);
			}
		}
	}

	scan->next_x_tnum++;
	if (idx == (num_components-1))
	{
		scan->accessed_samples += line.get_width();
	}
	if (scan->accessed_samples == cols)
	{ // Send empty line to free list.
		assert(scan == incomplete_lines);
		incomplete_lines = scan->next;
		scan->next = free_lines;
		free_lines = scan;
	}

  return true;
}