Discrete Cosine Transform Sample

Discrete Cosine Transform(DCT) and Quantization are the first two steps in JPEG compression standard. This sample demonstrates how DCT and Quantizing stages can be implemented to run faster using Intel® Cilk™ Plus. In order to see the effect of quantization on the image, the output of Quantization phase is passed on to the de-quantizer followed by Inverse DCT and stored as an output image file. DCT is a lossy compression algorithm which is used to represent every data point value using infinite sum of cosine functions which are linearly orthogonal to each other. DCT is the first step of compression in the JPEG standard. The program shows the possible effect of quality reduction in the image when we do DCT followed by quantization like in JPEG compression. To visibly see the effects if any, the inverse operations (Dequantization and Inverse Discrete Cosine Transform (IDCT)) are done and output is saved as bitmap image. This sample uses a serial implementation of the 2D-DCT (Two Dimensional DCT) algorithm, Array Notation(AN) version of the algorithm for explicit vectorization and finally the cilk_for +Array Notation version which includes both threading and vectorization solution

Code Change Highlights:

for(int i = 0; i < (size_of_image)/64; i++)
{
	startindex = (i * 64);
	process_image_serial(indata, outdata, startindex);
}

cilk_for(int i = 0; i < (size_of_image)/64; i++)
{
	startindex = (i * 64);
	process_image_serial(indata, outdata, startindex);
}

matrix_serial matrix_serial::operator*(matrix_serial &y){
	int size = y.row_size;
	matrix_serial temp(size);
	for(int i = 0; i < size; i++)
	{
		for(int j = 0; j < size; j++)
		{
			temp.ptr[(i * size) + j] = 0;
			for(int k = 0; k < size; k++)
				temp.ptr[(i * size) + j] += (ptr[(i * size) + k] * y.ptr[(k * size) + j]);
		}
	}
	return temp;
}

matrix_AN matrix_AN::operator*(matrix_AN &y){
	int size = row_size;
	matrix_AN temp(size);
	for(int i = 0; i < size; i++)
	{
		temp.ptr[(i * size):size] = 0;
		for(int j = 0; j < size; j++)
		{
			temp.ptr[(i * size):size] = temp.ptr[(i * size):size] + (ptr[(i * size) + j] * y.ptr[(j * size):size]);
		}
	}
	return temp;
}

Performance Data:

Note: Modified Speedup shows performance speedup with respect to serial implementation.

Build Instructions: