一、绪论
数字图像处理（Digital Image Processing）是指将图像信号转换成数字信号并利用计算机对其进行处理的过程。图像处理中，输入的是质量低的图像，输出的是改善质量后的图像。图像处理方法有图像增强、复原、编码、压缩等。
随着计算机技术、电子技术、和通信技术的发展，数字图像压缩在计算机和便携式系统中的应用越来越广泛。数字化图像使得图像信号可以高质量地传输，并便于图像的检索、分析、处理和存储。但是数字图像的表示需要大量的数据，由于存储空间和网络带宽的限制,对图像进行存储，处理和传输之前先要对图像进行压缩。数字图像压缩是减小图像数据量，方便图像的传输、存储和处理的有效手段，研究图像压缩的实现有着其重要的现实意义。数字信号处理器（DSP）有其独特的硬件结构特别适合于数字信号处理领域，大量地使用在各种便携式、实时信号处理场合。它的高速度和良好的运算性能特别适合于图像处理。
二、设计总体思路
本实验利用达盛DSP试验箱设计实现静态图像的离散余弦变换（DCT）和IDCT算法。通过读入一幅标准灰色的Lena（64×64）图像，然后对其图像数据进行8×8分块，接着对每块分别进行二维离散余弦变换（DCT），并经量化后通过反变换（IDCT）把数据块重新还原组合，先通过Matlab进行仿真，显示DCT、IDCT和压缩图象，再通过CCS软件的Image 显示功能，显示出原图像和经处理后的图像。比较原图像数据和处理后的图像数据，并分别比较在Matlab中和CCS软件中的原图像和处理后的图像。
具体的设计首先进行初始化，调用DCT变换子程序输出变换结果。然后调用DCT逆变换子程序输出重构信号。设计总流程图如下：
图2-1 DCT程序流程图
三、离散余弦函数的DSP实现
3.1 DSP的简介
DSP有两种解释:其一是Digital Signal Processing的缩写，即数字信号处理，是指数字信号处理是利用计算机或专用处理设备，以数字的形式对信号进行采集、变换、滤波、估值、增强、压缩、识别等处理，以得到符合人们需要的信号形式。其二是Digital Signal Processor即数字信号处理器的意思，是指数字信号处理器是用来完成数字信号处理要求的具有特殊结构的一种微处理器，即我们经常所说的DSP器件。近年来，DSP作为一种新型的微处理器在各种消费类、通信、医疗和工业产品中得到了非常广泛的应用。DSP处理器是一类针对数字信号处理领域进行了优化的微处理器。和普通的微处理器相比，它们具有特殊的硬件结构特别适合各类数字信号处理算法的实现，从而使得产品易于实现和维护。
3.2 图象的量化
所谓量化就是将离散图像的值表示为与其幅度成比例的整数，就是将DCT系数按比例缩小，并取其最接近的整数值的处理过程。量化的作用是在保证一定的图像质量前提下，丢掉那些对视觉效果影响不大的信息。
在JPEG中，量化就是将DCT变换后系数矩阵的各个系数f(u,v)除以量化表中对应的且量化阶距m(u,v)。量化过程在DSP的实现，是先将各量化表分别存放在DSP的存储器中，然后将DCT变换得到的数据与量化表各个元素做乘法运算，我们使用的是C54xDSP中的MPYR指令，这样可以得到乘法结构的同时对量化值进行四舍五入运算。
3.3 熵编码
数据压缩技术的理论基础是信息论。根据信息论的原理，可以找到最佳数据压缩编码方法，数据压缩的理论极限是信息熵。如果要求在编码过程中不丢失信息量，即要求保存信息熵，这种信息保持编码又叫做熵保存编码，或者叫熵编码。熵编码把一系列用来表示视频序列的元素符号转变为一个用来传输或是存储的压缩码流。
熵编码是无失真数据压缩，用这种编码结果经解码后可无失真地恢复出原图像。当考虑到人眼对失真不易觉察的生理特征时，有些图像编码不严格要求熵保存，信息可允许部分损失以换取高的数据压缩比，这种编码是有失真数据压缩，通常运动图像的数据压缩是有失真编码。
JPEG压缩算法使用了两种熵编码方法：哈夫曼编码和算术编码。在此我们只介绍哈夫曼编码。哈夫曼编码Huffman方法于1952年问世，迄今为止仍经久不衰，广泛应用于各种数据压缩技术中，且仍不失为熵编码中的最佳编码方法。
哈夫曼编码的理论依据是变字长编码理论。在变字长编码中，编码器的编码输出码字是字长不等的码字，按编码输入信息符号出现的统计概率，给输出码字分配以不同的字长。对于编码输入中，出现大概率的信息符号，赋以短字长的输出码字；对于编码输入中，出现小概率的信息符号，赋以长字长的输出码字。可以证明，按照概率出现大小的顺序，对输出码字分配不同码字长度的变字长编码方法，其输出码字的平均码长最短，与信源熵值最接近，编码方法最佳。
3.4 在DSP上实现的DCT与IDCT变换
实验中取一个8×8的图象距阵块为例，首先是变换、量化、熵编码的编码过程，然后是逆变换、逆量化、逆熵编码的解码过程。本实验程序应用了均匀量化。
实验程序：
#include <stdio.h>
unsigned char imageBlock[64]={
55, 60, 55, 54, 60, 68, 81, 114,
116, 62, 52, 49, 53, 96, 132, 102,
146, 144, 141, 141, 146, 151, 154, 162, %读入图象数据
207, 213,214, 130, 94, 114, 131, 139,
159, 223,166, 101, 95, 88, 100, 96,
118, 164, 77, 139, 181, 180, 165, 95,
55, 60,55, 54, 60, 68, 81, 114,
62, 69, 53, 74, 123, 124, 87, 132,
};
%均匀量化距阵
short Q_table[64]={ 16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 59, 60, 55,
14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62,
18, 22, 37, 56, 68, 109, 103, 77,
24, 35, 55, 64, 81, 104, 113, 92,
49, 64, 78, 87, 103, 121, 120, 101,
72, 92, 95, 98, 112, 100, 103, 99};
int Dct( unsigned char *block, short *coeff);
%进行DCT和IDCT变换
int Dct( unsigned char *block, short *coeff);
int Idct(short *coeff,unsigned char *block);
void main()
{short interBuffer[64];
unsigned char imageBlock2[64];
Dct(imageBlock, interBuffer);
%量化
for(i=0;i<64;i++)
{ interBuffer[i] =interBuffer[i]/Q_table[i];}
for(i=0;i<64;i++)
{ interBuffer[i] =interBuffer[i]*Q_table[i];}
Idct(interBuffer,imageBlock2);
}
%DCT算法程序
int Dct( unsigned char *block, short *coeff)
{
int j1, i, j, k;
float b[8];
float b1[8];
float d[8][8];
float f0=(float).7071068;
float f1=(float).4903926;
float f2=(float).4619398;
float f3=(float).4157348;
float f4=(float).3535534;
float f5=(float).2777851;
float f6=(float).1913417;
float f7=(float).0975452;
for (i = 0, k = 0; i < 8; i++, k += 8) {
for (j = 0; j < 8; j++) {
b[j] = (float)block[k+j];
}
/* Horizontal transform */
for (j = 0; j < 4; j++) {
j1 = 7 - j;
b1[j] = b[j] + b[j1];
b1[j1] = b[j] - b[j1];
}
b[0] = b1[0] + b1[3];
b[1] = b1[1] + b1[2];
b[2] = b1[1] - b1[2];
b[3] = b1[0] - b1[3];
b[4] = b1[4];
b[5] = (b1[6] - b1[5]) * f0;
b[6] = (b1[6] + b1[5]) * f0;
b[7] = b1[7];
d[i][0] = (b[0] + b[1]) * f4;
d[i][4] = (b[0] - b[1]) * f4;
d[i][2] = b[2] * f6 + b[3] * f2;
d[i][6] = b[3] * f6 - b[2] * f2;
b1[4] = b[4] + b[5];
b1[7] = b[7] + b[6];
b1[5] = b[4] - b[5];
b1[6] = b[7] - b[6];
d[i][1] = b1[4] * f7 + b1[7] * f1;
d[i][5] = b1[5] * f3 + b1[6] * f5;
d[i][7] = b1[7] * f7 - b1[4] * f1;
d[i][3] = b1[6] * f3 - b1[5] * f5;
}
/* Vertical transform */
for (i = 0; i < 8; i++) {
for (j = 0; j < 4; j++) {
j1 = 7 - j;
b1[j] = d[j][i] + d[j1][i];
b1[j1] = d[j][i] - d[j1][i];
}
b[0] = b1[0] + b1[3];
b[1] = b1[1] + b1[2];
b[2] = b1[1] - b1[2];
b[3] = b1[0] - b1[3];
b[4] = b1[4];
b[5] = (b1[6] - b1[5]) * f0;
b[6] = (b1[6] + b1[5]) * f0;
b[7] = b1[7];
d[0][i] = (b[0] + b[1]) * f4;
d[4][i] = (b[0] - b[1]) * f4;
d[2][i] = b[2] * f6 + b[3] * f2;
d[6][i] = b[3] * f6 - b[2] * f2;
b1[4] = b[4] + b[5];
b1[7] = b[7] + b[6];
b1[5] = b[4] - b[5];
b1[6] = b[7] - b[6];
d[1][i] = b1[4] * f7 + b1[7] * f1;
d[5][i] = b1[5] * f3 + b1[6] * f5;
d[7][i] = b1[7] * f7 - b1[4] * f1;
d[3][i] = b1[6] * f3 - b1[5] * f5;
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
*(coeff+j*8+i) =(short) d[i][j];
//d[i][j];
}
}
return 0;
}
%IDCT算法程序
int Idct(short *coeff,unsigned char *block)
{
int j1, i, j;
float b[8], b1[8], d[8][8];
float f0=.7071068;
float f1=.4903926;
float f2=.4619398;
float f3=.4157348;
float f4=.3535534;
float f5=.2777851;
float f6=.1913417;
float f7=.0975452;
float e, f, g, h;
/* Horizontal */
/* Descan coefficients first */
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
b[j] = *( coeff + j*8+i);
}
e = b[1] * f7 - b[7] * f1;
h = b[7] * f7 + b[1] * f1;
f = b[5] * f3 - b[3] * f5;
g = b[3] * f3 + b[5] * f5;
b1[0] = (b[0] + b[4]) * f4;
b1[1] = (b[0] - b[4]) * f4;
b1[2] = b[2] * f6 - b[6] * f2;
b1[3] = b[6] * f6 + b[2] * f2;
b[4] = e + f;
b1[5] = e - f;
b1[6] = h - g;
b[7] = h + g;
b[5] = (b1[6] - b1[5]) * f0;
b[6] = (b1[6] + b1[5]) * f0;
b[0] = b1[0] + b1[3];
b[1] = b1[1] + b1[2];
b[2] = b1[1] - b1[2];
b[3] = b1[0] - b1[3];
for (j = 0; j < 4; j++) {
j1 = 7 - j;
d[i][j] = b[j] + b[j1];
d[i][j1] = b[j] - b[j1];
}
}
/* Vertical */
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
b[j] = d[j][i];
}
e = b[1] * f7 - b[7] * f1;
h = b[7] * f7 + b[1] * f1;
f = b[5] * f3 - b[3] * f5;
g = b[3] * f3 + b[5] * f5;
b1[0] = (b[0] + b[4]) * f4;
b1[1] = (b[0] - b[4]) * f4;
b1[2] = b[2] * f6 - b[6] * f2;
b1[3] = b[6] * f6 + b[2] * f2;
b[4] = e + f;
b1[5] = e - f;
b1[6] = h - g;
b[7] = h + g;
b[5] = (b1[6] - b1[5]) * f0;
b[6] = (b1[6] + b1[5]) * f0;
b[0] = b1[0] + b1[3];
b[1] = b1[1] + b1[2];
b[2] = b1[1] - b1[2];
b[3] = b1[0] - b1[3];
for (j = 0; j < 4; j++) {
j1 = 7 - j;
d[j][i] = b[j] + b[j1];
d[j1][i] = b[j] - b[j1];
}
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
*(block + i * 8 + j) = (unsigned char)(d[i][j]);
}
}
return 0;
}
程序数据：
原始数列矩阵：
进行DCT变换结果：
进行DCT逆变换结果：
四、离散余弦变换的Matlab实现
4.1离散余弦变换
离散余弦变换(DCT for Discrete Cosine Transform)是与傅里叶变换相关的一种变换，它类似于离散傅里叶变换(DFT for Discrete Fourier Transform),但是只使用实数。离散余弦变换相当于一个长度大概是它两倍的离散傅里叶变换，这个离散傅里叶变换是对一个实偶函数进行的(因为一个实偶函数的傅里叶变换仍然是一个实偶函数)，在有些变形里面需要将输入或者输出的位置移动半个单位。
离散余弦变换经常被信号处理和图像处理使用，用于对信号和图像(包括静止图像和运动图像)进行有损数据压缩。在静止图像编码标准JPEG中，在运动图像编码标准MJPEG和MPEG的各个标准中都使用了离散余弦变换。在这些标准制中都使用了二维的第二种类型离散余弦变换，并将结果进行量化之后进行熵编码。这时对应第二种类型离散余弦变换中的n通常是8，并用该公式对每个8x8块的每行进行变换，然后每列进行变换。得到的是一个8x8的变换系数矩阵。其中(0,0)位置的元素就是直流分量，矩阵中的其他元素根据其位置表示不同频率的交流分类。这是由于离散余弦变换具有很强的"能量集中"特性:大多数的自然信号(包括声音和图像)的能量都集中在离散余弦变换后的低频部分，而且当信号具有接近马尔科夫过程(Markov processes)的统计特性时，离散余弦变换的去相关性接近于K-L变换(Karhunen-Loève 变换--它具有最优的去相关性)的性能。
二维DCT正变换和逆变换公式如下（8×8）：
，
(u,v=0) (其他情况,
)
4.2 Matlab仿真
Matlab提供了dct2函数和idct2函数用于进行二维DCT和二维IDCT的计算，由于时间紧迫，用Matlab实现此仿真比较简单，而且我对Matlab比较熟悉，故用Matlab对离散余弦变换和压缩这块进行仿真。
4.2.1 DCT与IDCT变换程序：
RGB=imread('Lena64.bmp'); %读入64×64Lena图象
figure(1);
imshow(RGB);
DCT=dct2(RGB); %进行DCT变换
figure(2);
imshow(log(abs(DCT)),[]);
IDCT=idct2(DCT); %进行IDCT变换
figure(3);
imshow(abs(IDCT),[])
仿真结果:
图1-2原图象 图1-3 DCT变换 图1-4 IDCT图象
结果分析：
经过DCT变换后的图象完全离散，再经过IDCT还原后，图象基本复原，但也存在差别。
五、心得体会
如果说任何机会都是需要去创造出来的话，那么那个创造者，其实就是你自己。时间过得真快，转眼间已经有两个星期了，现在回想起来，往事还历历在目。但是不可否认的却是这些经历将会是我人生当中不可多得的财富和经验的累积。
这两周的课程设计实习周终于结束了，通过两周以来同学和老师的共同努力，我们终于完成了设计要求。但大家脸上的表情都是欣慰和欢喜的，到底工夫不负有心人。回想过去两周，这里面的辛苦只有做是课程设计的人才明白，才能体会。通过这种综合性训练，要学生达到以下的目的和要求：
1．结合课程中所学的理论知识，独立设计方案。达到学有所用的目的。
2．学会查阅相关手册与资料，通过查阅手册和文献资料，并掌握合理选用的原则，培养独立分析与解决问题的能力。
这次设计我们学到了很多东西，虽然作出来的东西很基础，但是我们加深了对知识的理解和掌握。作为一名大四的学生，我觉得能做类似的课程设计是十分有意义的。同时这是一次团队合作开发过程，一次难得的经历。通过此次设计试验也着重能够学到许多东西。
机会谁都有，关键在于自己怎么利用一些外部条件去创造。与其等待机会的来临，还不如自己去创造机会，变被动为主动，事情才能成功。过去在自己的心里，老是有种恐惧的心理在作祟，怀疑自己的能力，认为自己不能胜任某件事情，甚至连尝试的胆量都没有。通过在保险公司的实习，我也明白了只有抛弃心中的恐惧，拿掉不可能，不断培养自己锻炼自己，才能在这个行业中走得更远。自己本身还是存在着很大的欠缺，这样才能不断地提升自身的素质、素养，不断地改进自己的知识结构水平，让自己投入到理论学习中，好好积累基础理论知识，方能厚积薄发。也将随着自身能力水平和环境的不断变化而更加完善。最后感谢李老师的热心指导和帮助。
六、参考文献
1．邹彦主编. DSP原理及应用，电子工业出版社。
2．谭浩强编 C语言程序设计 清华大学出版社。
3．TMS320C54x DSP Reference Set, Volume 1: CPU TI Coperation
4．TMS320C54x Code Composer Studio Tutorial
5．TMS320C54x DSP Reference Set, Volume 3: Algebraic Instruction Set
6．TMS320C54x Optimizing C Compiler User’s Guide
目录
一、绪论. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
二、设计总体思路. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
三、离散余弦函数的DSP实现 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3.1 DSP的简介. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
3.2 图象的量化 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
3.3 熵编码 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3
3.4 在DSP上实现的DCT与IDCT变换............. . . . . . . . . . . . . . . .4
四、离散余弦变换的Matlab实现. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.1离散余弦变换. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2Matlab仿真 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
五、心得体会. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
六、参考文献. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13