多媒体技术项目实践
项目实践一 Huffman 编码
一、实验目的与要求
1、实验目的
（1）掌握哈夫曼编码原理。
（2）理解数据压缩的实现过程。
2、实验要求
根据哈夫曼编码算法，对下列信源实现哈夫曼编码。求出编码后的平均码长。
二、实验内容与步骤
1、实验内容
对上面信源进行哈夫曼编码。
显示出每个符号的分配代码及平均码长。
2、实验步骤
（1）初始化，根据符号概率的大小按由大到小顺序对符号进行排序。
（2）把概率最小的两个符号组成一个节点。
（3）重复步骤（1）（2），直到概率和为 1
（4）从根节点开始到相应于每个符号的“树叶”，概率大的标“0”，概率小的标“1”
（5）从根节点开始，对符号进行编码。
三、实验成果
1、哈夫曼编码程序。
2、实验报告。
,,,,,
6,5,4,3,2,1 XXXXXX
X
项目实践二 DCT 变换编码
一、实验目的与要求
1、实验目的
（1）掌握 DCT 变换编码原理。
（2）理解 DCT 变换的实现过程。
2、实验要求
现有一张 320×240 的图像一张，要求对其进行 DCT 变换。
二、实验内容与步骤
1、实验内容
对 320×240 的图像进行 DCT 变换
2、实验步骤
步骤一、分块
将每个分量图像分成许多 8×8=64 个样点组成的像块，并对其采样，得到在空域中的 8×
8 的样值矩阵。
步骤二、 变换
利用 FDCT 公式，将空域中的 8×8 样值矩阵，正向变换（FDCT）为频域中的 8×8 DCT
系数矩阵。
步骤三、 关于 FDCT 变换的几点说明
（1）f（x，y）为空域中位置为（x，y）点的样值函数（x，y=0，1,…,7）。
（2）F（u，v）为频率域中频率位置为（u，v）点的 DCT 系数（u，v=0，1,…,7）。
（3）沿 u，v 方向频率增加，但是 0～7 并不特指某一频率（可视为小的频率域）。
（4）F（0，0）对应直流分量，称为 DC 系数，其它 63 个对应交流分量的系数，称为
AC 系数。
（5）两个空间的同位置系数无对应关系。
（6）在频域中的右下角对应高频部分，而在左上角对应低频部分（特点，相关性）。
步骤四、讨论
（1） DC 系数的构成：
当 u，v＝0 时， C（U）=C（V）=1/√2 ， 有：
可见 DC 系数为空域中 64 个样值的平均值（对 8 的）。
（2） AC 系数的构成：
当 u，v≠0 时， C（U）=C（V）=1
每个 AC 系数为空域中 64 个样值分别乘以对应的余弦量后求和，再取平均。
（3）DCT 系数的取值范围：在视频数字化中，由于采用 8 位量化，在空域中的样值的
最大值应为 256，所以
F（0，0）MAX=DCMAX=256×64/8=2048
故：0≤DC≤2047 -1024≤AC≤1023
（4） DCT 系数规律：低频系数值大，高频系数值小。
7 7
0 0
1 (2 1) (2 1)
, ( , ) cos cos ]
4 16 16i j
i u j v
u v u v f i j
Ｆ（ ）= C( ) C( ) [
步骤五、 DCT 系数量化
(1)量化的原因： DCT 之后其系数矩阵中相关性不够明显，为进一步降低 DCT 系数矩
阵中非零系数的幅值，增加零系数的个数，使相关性表现的更明显，需要进一步量化。
(2)量化的依据
对失真的要求：量化是图像质量下降的重要原因，DCT 系数量化是基于限失真编码理
论进行的，容许有失真，但应在视觉容许的容限内。
对视觉的要求：亮度信号与色度信号的分辨能力不同; 对低频图像信号和高频图像信号
的分辨能力不同。
(3）量化的方法
区域滤波法：采用对 DCT 系数矩阵中的每一个值逐一量化 。
三、实验成果
1、写好实验报告。
项目实践三 词典编码
一、实验环境
Turbo C
二、实验目的与要求
1.实验目的
(1) 理解词典编码的思想。
(2) 了解 LZ77 算法。
(3) 掌握 LZW 算法。
2.实验要求
根据 LZW 算法原理对一段具体的字符进行编译。要求在编码过程中写出流程图,以便充
分理解 LZW 算法原理,最终达到熟练应用。
三、实验内容与步骤
1.实验内容
任意输入一段字符进行编码。
依据字典算法的步骤，写出字符编码的流程图。
2.实验步骤
进入 Tubor C 编译环境。
在编译环境下输入词典的编码算法。（参考程序）
#include <>
void copy1(char *prefix,char *s,int i,int j) /*拷贝字符串*/
{
int k;
for(k=0;k<20;k++) /*将前缀字符串清空*/
prefix[k]='';
for(k=i;k<i+j;k++)
{prefix[k-i]=s[k];
/* printf("aplght is:%d---%c\n",k-i,prefix[k-i]);*/}
}
main()
{ char s[30], prefix[30],dic[20][30]={"A","B","C"},c[20];
int i,j,k,n,t,m; /*k 指字典中的编号,m 指匹配号码，j 指截取字母的长度*/
k=3; m=0;j=1; i=0;
printf("please input string:\n");
gets(s);
while(i<strlen(s))
{
copy1(prefix,s,i,j); /*读取字符的长度*/
for(n=0;n<k;n++) /*查找字典中的编号*/
{
/* printf("prefix=%s ",prefix);
printf("dic[3]=%s ",dic[n]); */
if(strcmp(prefix,dic[n])==0)
{
j=j+1;
m=n;
if((i+j)<=strlen(s))
copy1(prefix,s,i,j);
else
strcpy(prefix,"");
}
}
printf("%d ",m);
if(strlen(prefix)!=0)
{strcpy(dic[k],prefix); /*写入字典*/
printf("%s \n",dic[k]);}
k=k+1;
i=i+j-1;
j=1;
}
}
运行该程序，根据其要求输入要编译的字符串“ABBABABAC”。
调试、观察运行结果，并与自己画的编译流程图相比较。
四、实验思考题
1. 字符流的输入如表 3-1 所示，使用 LZW 算法计算输出的码字流。请核对计算的输出
码字流是否为：
(1) (2) (4) (3) (5) (8) (1) (10) (11) …
并将码字流中的码字填入练习表 3-2 对应的位置。
表 3-1 输入字符流
输入位置 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ……
输入字符流 A B A B C B A B A B A A A A A ……
输出码子
表 3-2 编码表
步骤 位置 词典 输出码子
（1） a
（2） b
（3） c
1 1
2
…
9
…
项目实践四 声音录制、编辑和合成
一、实验目的
(1) 通过实验学习声音的数字化过程，了解计算机如何处理和存储声音。
(2) 掌握声音处理工具软件Cool Edit的用法，能够用Cool Edit进行录音并根据需要编辑
声音。
(3) 了解用Cake walk音乐大师制作MIDI音乐。
二、实验内容
(1)用Cool Edit 录音并去除声音文件中的噪音、添加混响效果、制作渐弱效果和自制卡
拉OK伴奏带。
(2) *Cake walk音乐大师制作MIDI音乐
三、实验要求
(1) 提交用Cool Edit录制的原文件。
(2) 提交用Cool Edit处理噪音、添加混向效果以及制作渐弱效果的最终作品。
(3) 尝试用Cake walk音乐大师制作MIDI音乐。
四、实验操作
用Cool Edit录音并去除声音文件中的噪音、添加混响效果、制作渐弱效果和自制卡拉OK
伴奏带。
1、录制背景音乐
背景音乐可由录音机、CD 唱机等输出的模拟音频获取。首先保证外界音源设备与声卡
的 Line In 接口正确相连。
步骤 1：选择【开始】/【程序】/【Cool Edit 2000】/【Cool Edit 2000】，打开 Cool Edit
2000；
步骤 2：单击工具栏的【Record】按钮．出现【New Waveform】对话框，分别选择【Sample
Rate】为 44100，【Channels】为【Stereo】，【Resolution】为【16-bits】，单击
【OK】按钮开始录音。
步骤 3：录音结束，单击工具栏的【Stop】按钮完成录音。
步骤 4：执行【File】/【Save As…】，打开保存对话框。选择好路径，文件名存为【背
景音乐】，保存类型选【Windows PCM（*.Wav）】，单击【保存】完成对音乐文件的录制。
2、去除声音文件中的噪音
步骤 1： 打开我们上面录制的【背景音乐】，执行【Effects】/【Noise Reduction】命令，
打开【Noise Reduction…】对话框
（1）在 Noise Reduction Settings 框中，【FFT Size】取值在 4 096～20 000 之间，在这里把
它设为 8192。其他各项就取 CE Pro 设好的默认值。
(2)在 Profiles 框中，单击【Get Pro Selection】按钮，CE Pro 就会把噪音轮廓记录在原先
为灰色的“Noise Profile”框中，水平方向表示频率，竖直方向表示噪音的量。
（3）按下【Noise Reduction…】对话框中的【Close】按钮关闭对话框，注意不要按下
【Cancel】按钮来关闭对话框。回到 CE Pro 的工作界面后，使用水平缩放工具使整个声音
波形都显示在波形显示区中，双击波形显示区选取整个波形，然后再次打开【Noise
Reduction…】对话框，会看到噪音轮廓还在那里，这时按下【OK】按钮，CE Pro 就开始自
动清除环境噪音了。
步骤 2：处理结束后，打开【File】/【Save As…】，选择好路径，文件名存为【无噪音
背景音乐】单击【保存】，完成去除声音文件中的噪音处理。
3、用 Cool Edit Pro 进行混音处理
步骤 1：打开另一个我们录制的【伴奏带】，执行【Edit】/【Mix paste…】命令，打开
【Mix paste】对话框
（1）在 Volume 框中，【Volume L，R】代表左右声道音量，若为单声道文件，则只有
一个声道音量调节，若选中【Invert】，则文件在被粘贴前声音数据将会颠倒。当【Lockleft/Right】
被选中时，左右声道调节钮将被锁定，调节时将一齐变化。
（2）在合成方式框中，选定【Insert】，则被粘贴的文件插入当前文件之中。选定
【Overlap】时，则被粘贴的文件不会取代当前文件中的选定部分，而是以选定的部分与当
前文件叠加。若被粘贴的文件比当前文件的选定部分长，则超出范围的部分将继续被粘贴。
选定【Replace】，则被粘贴的声音文件将覆盖源文件。选定【Modulate】则被粘贴的声音文
件与当前文件一起调制，即将每采样点的幅值相乘混合后输出。激活【Crossfade】，输入时
间(ms)，则在粘贴前后粘贴的文件有一定的淡入淡出。
（3）在选择被粘贴的文件来源框中，选中【From Clipboard】表示被粘贴的文件来源于
剪贴板。【From windows Clipboard】表示被粘贴的文件来源于 Windows 剪贴板。【From File】
表示被粘贴的文件来源于新文件，单击【Select File…】按钮可选择文件。
（4）【Looppast】指粘贴文件的次数。
在本实验中设置【Volume L，R】为 90，选中【Overlap】，设置【Crossfade】值为 50，
选中【From File】，单击【Select File…】选择作为背景音乐的文件【无噪音背景音乐】，
【Looppast】为 1，单击【OK】完成设置。
步骤2：处理结束后，打开【File】/【Save As…】，选择好路径，文件名存为【混合音
乐】单击【保存】，完成混音处理。
4、制作渐弱效果
步骤 1： 打开我们上面编辑的【混合音乐】，执行【Effects】/【Amplitude】命令，打
开【Amplify…】对话框，在该对话框中选中【Fade】对话框。
（1） 在 Initial Amplification 框中的上下两个滑块分别控制左右声道最初音量放大的倍
数， Fianl Amplification 框中的上下两个滑块则分别控制左右声道最终音量放大的倍数。100
％相当于音量没有改变，0％相当于音量被减小至无声。在此，我们选中【混合音乐】中需
要制作渐弱效果的一段音频，在【Initial Amplification】中左右声道放大倍数为 100％，在
【Fianl Amplification】中左右声道放大倍数为 50％。
（2）【Linear Fade】单选框是将最初和最终音量放大的倍数呈线性变化，而选中
【Logarithmic Fade】则是最初和最终音量放大的倍数呈对数变化。我们可以试听一下这两
种变化的效果。在这段音乐里，我们选择线性变化。
（3）【Lock Left/Right】用来控制左右声道是否作同样的变化，如果不选它，左右声道
音量放大的倍数就可以分别设置。我们不选择该复选框。
步骤 2：处理结束后，打开【File】/【Save As…】，选择好路径，文件名存为【混合音
乐】单击【保存】，完成渐弱效果的处理。
至此，具有一些效果的自制卡拉 OK 伴奏带就基本上完成了。
* Cake walk 音乐大师制作 MIDI 音乐
在这里我们尝试用 对一段音乐进行独奏处理。
步骤 1：选择【开始】/【程序】/【Cakewalk pro 】/【Cakewalk pro 】，
打开 ；
步骤 2：打开以前制作的 ，并把音轨窗口最大化。 窗口中显示了该曲
的音轨，音轨窗左半边每条音轨上都有三条颜色较深的竖栏，上面标有 M、S、R 字样，分
别是 MUTE、SOLO、ARM 的缩写。MUTE 键用来指定音轨为静音状态，SOLO 键用来指
定音轨为独奏状态，ARM 键用来指定音轨为录音状态。
步骤 3：点击打击乐器音轨（）的 M 键，这样就把该组打击乐器静音了。
该轨的 M 键变为黄色，并注意到下面音轨指示栏最左边一格显示出 MUTE 字样，并变为黄
色。
步骤 4：重复 3 的操作，把除了我们想单独听的声音以外的其它的节奏声都给静音了。
或者直接把我们想听的节奏声设为独奏（SOLO）状态，操作类似步骤 3。
步骤 5：处理结束后，打开【File】/【Save As…】，选择好路径，文件名存为【独奏】
单击【保存】，完成独奏效果的处理。
五、实验讨论
(1) 我们在前面实验中完成了声音文件中噪音的处理，那么如何去除出气声和清除呼吸
声和不重叠在有效语音上的杂音。
(2)在足球赛中，球迷的欢呼和解说词都是一个人录制的，如何使球迷的声音和解说词
的声音有较大的差别？
（3）在制作声音文件的过程中，如何把几个已经制作好的声音片段合并程一个声音片
段？
（4）在Cakewalk Pro 中，如何调出虚拟钢琴？
项目实践五 Photoshop 图像编辑、处理
一、实验目标
1．能够根据不同需要生成不同格式的图像文件。
2．掌握图层、通道的概念，能够应用图层、通道并使用 Photoshop 进行基本的图形图
像绘制。
3．能够应用 Photoshop 的滤镜制作出特殊效果的图像。
二、实验内容
在规定时间内，在教师的指导下，学习使用 Photoshop 进行数字图像的多种处理。
三、实践环境
1．多媒体计算机
2．Adobe Photoshop 软件.
四、实验步骤
1．运行 Photoshop 程序。
2．认识图像的属性。
（1）选取一张合适的 BMP 格式图片，用 Photoshop 打开。使用文件菜单下“另存为”命
令将该图片分别存为 GIF、JPG、TIFF、PNG 等不同格式。保存为 JPEG 格式时，在图像选
项中分别设置压缩品质为 10、8、5、3 后存储为不同名字的文件。
（2）使用 Photoshop 的“文件浏览器”面板查看新生成图像文件的属性值：文件存储大
小，图像尺寸( pixel 和 cm)、颜色数等。
（3）将相关文件全部打开，比较它们的显示效果。
3．制作“奥运五环”图像。
（1）新建一个背景色为白色的 RGB 文件。
（2）选择工具箱中的椭圆选框工具，结合选框选项面版中的相关设置，以及参考线等
工具的使用，在画布中圈选得到一个圆环选择区域。
（3）新建图层，使用油漆桶工具将之填充为蓝色。
（4）再重复步骤（3），新建图层分别填充圆环为黄色、黑色、绿色、红色。
（5）使用移动工具把各个图层中的圆环按照奥林匹克五环标志的形式摆放——第一行
中的蓝、黑、红三环互不相交，但第二行中的黄、绿环却要分别和蓝、黑环以及黑、红环相
交。
（6）按住 Ctrl 键并点击图层面版中图层 1，将蓝色圆环载入选择区域；使用选择工具
并按下 Shift 和 Alt 键，在蓝色和黄色圆环交集处圈选，以选出两环交集的区域，回到黄色
圆环所在的图层，按 DEL 键删除两个圆环重叠的地方。
（7）重复步骤（6），将其他圆环相交的地方也做同样处理。
（8）将五环所在的图层依次进行链接并“合并链接图层”，将合并得到的图层命名为五
环。在图层面版中的“五环”图层中点击鼠标右键，应用弹出菜单中的“效果”命令，为五环加
上阴影效果。
（9）合并所有图层，保存文件。
图 5-1 奥运五环制作效果图
4．应用滤镜制作艺术字。
（1）新建一个 RGB 模式的图像，将背景填充为黑色。
（2）用文本工具输入白色文字，将文字图层栅格化，然后拼合图层。
（3）执行图像(Image)/旋转画布(Rotata Canvas)/逆时针旋转 90 度(90°CCW)命令将整个
图像逆时针旋转 90 度，然后执行滤镜(Filter)/风格化(Stylize)/风(Wind)命令做出风的效果。
（4）执行图像(Image)/旋转画布(Rotata Canvas)/顺时针(90°CW)旋转 90 度将整个图像
顺时针旋转 90 度回复，然后执行滤镜(Filter)/扭曲(Distort)/波纹(Ripple)命令制出图像抖动效
果。
（5）执行图像(Image)/模式(Mode)/灰度模式(Grayscale)，然后执行图像(Image)/模式
(Mode)/索引模式(Indexed Color) 命令。
（6）执行图像(Image)/模式(Mode)/ 颜色表(Color Table)命令，选择黑体。
（7）最后将图像调整为 RGB 模式，制作完成。
图 5-2 火焰字制作效果图
五、实验结论及成果
1. 项目实践报告。
2. 提交制作的“奥运五环”、“火焰字”图像作品。
项目实践六 VC 实现图像压缩编码
一、实验目标
1． 掌握 BMP 位图以及 JPEG 文件结构。
2． 能够使用 VC 编程工具利用 JPEG 压缩编码算法实现 BMP 格式转换为 JPEG 格式
的程序。
二、实验内容
在规定时间内，在教师的指导下，使用 VC 实现将 BMP 格式转换为 JPEG 格式的程序。
三、实践环境
1．计算机
2．Visual C++ 软件.
四、实验步骤
1． 安装 Visual C++ 软件。
2． 参考以下程序编程。
---------------------------------------------------------------
//
#define BYTE unsigned char
#define SBYTE signed char
#define SWORD signed short int
#define WORD unsigned short int
#define DWORD unsigned long int
#define SDWORD signed long int
static struct APPOinfotype
{
WORD marker;//=0xFFE0
WORD length; // = 16 for usual JPEG, no thumbnail
BYTE JFIFsignature[5]; // = "JFIF Y \0'
BYTE versionhi; // 1
BYTE versionlo;//1
BYTE xyunits; // 0 = no units, normal density
WORD xdensity; // 1
WORD ydensity; // 1
BYTE thumbnwidth; // 0
BYTE thumbnheight; // 0
}APPOinfo={0XFFE0,16,'J','F','I','F',0,1,1,0,1,1,0,0};
static struct SOFOinfotype{
WORD marker; // = 0XFFCO
WORD length; // = 17 for a truecolor YCbCr JPG
BYTE precision;// Should be 8: 8 bits/sample
WORD height;
WORD width;
BYTE nrofcomponents;//Should be 3: We encode a truecolor JPG
BYTE IdY; // = 1
BYTE HVY; // sampling factors for Y (bit 0-3 vert., 4-7 hor.)
BYTE QTY; // Quantization Table number for Y = 0
BYTE IdCb; // = 2
BYTE HVCb;
BYTE QTCb; // 1
BYTE IdCr; // = 3
BYTE HVCr;
BYTE QTCr; // Normally equal to QTCb = 1
}SOFOinfo={0XFFC0,17,8,0,0,3,1,0X11,0,2,0X11,1,3,0X11,1};
// Default sampling factors are 1,1 for every image component: No downsampling
static struct DQTinfotype {
WORD marker; // = 0XFFDB
WORD length; // = 132
BYTE QTYinfo;// =0: bit 0..3: number of QT = 0 (table for Y)
// bit 4. .7: precision of QT, 0 = 8 bit
BYTE Ytable[64];
BYTE QTCbinfo; // = 1 (quantization table for }
BYTE Cbtable[64];
} DQTinfo;
// Ytable from DQTinfo should be equal to a scaled and zizag reordered version
// of the table which can be found in "tables, h": std_luminance_qt
// Cbtable , similar = std_chrominance_qt
// We' 11 init them in the program using set_DQTinfo function
static struct DHTinfotype {
WORD marker; // = 0XFFC4
WORD length; //0X01A2
BYTE HTYDCinfo; // bit 0. .3: number of KT (0. .3), for V =0
//bit 4 rlype of HT, 0 = DC table, 1 = AC table
//bit 5..7: not used, must be 0
BYTE YDC_nrcodes[16]; //at index i = nr of codes with length i
BYTE YDC_values[12];
BYTE HTYACinfo;// = 0x10
BYTE YAC_nrcodes[16];
BYTE YAC_values[162];//we'll use the standard Huffman tables
BYTE HTCbDCinfo; // = 1
BYTE CbDC_nrcodes[16];
BYTE CbDC_values[12];
BYTE HTCbACinfo; // = 0X11
BYTE CbAC_nrcodes[16];
BYTE CbAC_values[162];
}DHTinfo;
static struct SOSinfotype {
WORD marker; // = 0XFFDA
WORD length; // = 12
BYTE nrofcomponents; // Should be 3: truecolor JPG
BYTE IdY; //I
BYTE HTY; //O // bits 0. .3: AC table (0.. 3)
// bits 4.. 7: DC table (0..3)
BYTE IdCb; //2
BYTE HTCb; //0X11
BYTE IdCr; //3
BYTE HTCr; //0X11
BYTE Ss,Se,Bf; // not interesting, they should be 0,63,0
}SOSinfo={0XFFDA, 12, 3,1,0, 2, 0X11, 3, 0X11,0, 0X3F,0};
typedef struct { BYTE B, G, R; } colorRGB;
typedef struct {BYTE length;
WORD value;}bitstring;
#define Y(R,G,B) ((BYTE)((YRtab[(R)]+YGtab[(G)]+YBtab[(B)])>>16)-128)
#define Cb(R,G,B) ((BYTE)((CbRtab[(R)]+CbGtab[(G)]+CbBtab[(B)])>>16))
#define Cr(R,G,B) ((BYTE)((CrRtab[(R)]+CrGtab[(G)]+CrBtab[(B)])>>16))
#define writebyte(b) fputc((b),fp_jpeg_stream)
#define writeword(w) writebyte((w)/256) ;writebyte((w)%256) ;
---------------------------------------------------------------
//JGLOBALS. H
static BYTE bytenew=0; // The byte that will be written in the JPG file
static SBYTE bytepos=7; //bit position in the byte we write (bytenew)
//should be<=7 and >=0
static WORD mask[l6] = {l, 2, 4, 8, 16, 32, 64,128, 256, 512,1024, 2048, 40%, 8192,16384,
32768};
// The Huffman tables we'll use:
static bitstring YDC_HT[l2];
static bitstring CbDC_HT[l2];
static bitstring YAC_HT[256];
static bitstring CbACJtT[256];
static BYTE *category_alloc;
static BYTE *category; //Here we'll keep the category of the numbers in range: -32767.. 32767
static bitstring *bitcode_alloc;
static bitstring *bitcode; // their bitcoded representation
//Precalculated tables for a faster YCbCr- RSB transformation
// We use a SDWORD table because we*11 scale values by 2"16 and work with integers
static SDTORD YRtab[256],YGtab[256],YBtab[256];
static SDWORD CbRtab[256], CbGtab[256], CbBtab[256];
static SDWORD CrRtab[256], CrGtab[256], CrBtab[256];
static float fdtbl_Y[64];
static float fdtbl_Cb[64]; //the same with the fdtbl_Cr[64]
colorRGB *RGB_buffer; //image to be encoded
WORD Ximage, Yimage;// image dimensions divisible by 8
static SBYTE YOU[64]; // This is the Data Unit of Y after YCbCr->RGB transformation
static SBYTE CbDU[64];
static SBYTE CrDU[64];
static SWORD DU_DCT[64]; // Current DU (after DCT and quantization) which we'll zigzag
static SWORD DU[64]; //zigzag reordered DU which will be Huffman coded
FILE *fp_jpeg_stream;
---------------------------------------------------------------
// JTABLES. H
static BYTE zigzag[64] = { 0, 1, 5, 6,14,15,27,28,
2, 4, 7,13,16,26,29,42,
3, 8,12,17, 25, 30, 41,43,
9,11,18,24,31,40,44,53,
10, 19, 23, 32, 39, 45, 52, 54,
20. 22, 33, 38, 46, 51, 55, 60,
21. 34, 37, 47, 50, 56, 59, 61,
35, 36, 48, 49, 57, 58, 62, 63 };
/* These are the sample quantization tables given in JPEG spec section K. 1. The spec says that
the values given produce "good" quality, and when divided by 2, "very good" quality.*/
static BYTE std_luminance_qt[64] = {
16, 11, 10, 16, 24, 40, 51, 61,
12, 12, 14, 19, 26, 58, 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
};
static BYTE std_chrominance_qt [64] = {
17. 18, 24, 47, 99, 99, 99, 99,
18. 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99
};
// Standard Huffman tables (cf. JPEG standard section K. 3) */
static BYTE std_dc_luminance_nrcodes[l7]={0f 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0} ;
static BYTE std_dc_luminance_values [12] = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} ;
static BYTE std_dc_chrominance_nrcodes[l7] = {0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0} ;
static BYTE std_dc_chrominance_values[l2] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} ;
static BYTE std_ac_luminance_nrcodes[l7] = {0, 0, 2,1, 3, 3,2,4,3, 5, 5, 4, 4, 0, 0,1, Ox7d };
static BYTE std_ac_luminance_values[l62]= {
0x01, 0x02, 0x03, 0x00, 0x04, Oxll, 0x05, 0x12,
0x21,0x31,0x41,0x06,0x13,0x51,0x61, 0x07,
0x22,0x71,0x14,0x32,0x81,0x91,Oxal,0x08,
0x23,0x42,Oxbl,Oxcl,0x15,0x52,Oxdl,OxfO,
0x24,0x33,0x62,0x72,0x82,0x09,OxOa,0x16,
0x17,0x18,0x19,Oxla,0x25,0x26,0x27,0x28,
0x29,Ox2a,0x34,0x35,0x36,0x37,0x38,0x39,
Ox3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
Ox4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
Ox5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,
Ox6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,
Ox7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
Ox8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,
0x99,Ox9a,Oxa2,Oxa3,Oxa4,Oxa5,Oxa6,Oxa7,
Oxa8,Oxa9,Oxaa,Oxb2,Oxb3,Oxb4,Oxbo,Oxb6,
Oxb7,Oxb8,Oxb9,Oxba,Oxc2,Oxc3,Oxc4,Oxc5,
Oxc6,Oxcv,Oxc8,Oxc9,Oxca, Oxd2,Oxd3,Oxd4,
Oxdo,Oxd6,Oxd7,Oxd8,Oxd9,Oxda,Oxel,Oxe2,
Oxe3,Oxe4,Oxe5,Oxe6,Oxe7,Oxe8,Oxe9,Oxea,
Oxfl,Orf2,Oxf3,Oxf4,Oxf5,Oxf6,Oxf7,Oxf8,
Oxf9,Oxfa };
static BYTE std_ac_chrominance_nrcodes [17] = {0, 0,2,1,2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77} ;
static BYTE std_ac_chrominance_values[l62]={
0x00, 0x01, 0x02, 0x03, Oxll, 0x04, 0x05, 0x21,
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
Oxal, Oxbl, Oxcl, 0x09, 0x23, 0x33, 0x52, OxfO,
0x15, 0x62, 0x72, Oxdl, OxOa, 0x16, 0x24, 0x34,
Oxel, 0x25, Oxfl, 0x17, 0x18, 0x19, Oxla, 0x26,
0x27, 0x28, 0x29, Ox2a, 0x35, 0x36, 0x37, 0x38,
0x39, Ox3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, Ox4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, Ox5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, Ox6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
0x79, Ox7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, Ox8a, 0x92, 0x93, 0x94, 0x95, 0x96,
0x97, 0x98, 0x99, Ox9a, Oxa2, Oxa3, Oxa4, Oxa5,
Oxa6, Oxa7, Oxa8, Oxa9, Oxaa, Oxb2, Oxb3, Oxb4,
Oxb5, Oxb6, Oxb7, Oxb8, Oxb9, Oxba, Oxc2, Oxc3,
Oxc4, Oxc5, Oxc6, Oxc7, OxcS, Oxc9, Oxca, Oxd2,
Oxd3, Oxd4, Oxd5, Oxd6, Oxd7, OxdS, Oxd9, Oxda,
Oxe2, Oxe3, Oxe4, Oxe5, Oxe6, Oxe7, OxeS, Oxe9,
Oxea, Oxf2, Oxf3, Oxf4, Oxf5, Oxf6, Oxf7, Oxf8,
Oxf9, Oxfa };
---------------------------------------------------------------
//
// A BMP truecolor to JPEG encoder
// Copyright 1999 Cristi Cuturicu
#include <>
#include <>
#include <>
#include ""
#include ""
#include ""
void write_APPOinfo()
//Nothing to overwrite for APPOinfo
{
writeword();
writeword();
writebyte('J');
writebyte('F');
writebyte('I');
writebyte('F');
writebyte(0);
writebyte();
writebyte();
writebyte();
writeword();
writeword();
writebyte();
writebyte();
}
void write_SOFOinfo()
// We should overwrite width and height
{
writeword();
writeword();
writebyte();
writeword();writeword();
writebyte();
writebyte();writebyte();writebyte();
writebyte();writebyte();writebyte();
writebyte();writebyte();writebyte();
}
void write_DQTinfo()
{
BYTE i;
writeword();
writeword();
writebyte();for(i=0;i<64;i++)writebyte([i]);
writebyte();for(i=0;i<64;i++) writebyte([i]);
}
void set_quant_table(BYTE *basic_table, BYTE scale_factor,BYTE *newtable)
//Set quantization table and zigzag reorder it
{
BYTE i;
long temp;
for(i=0;i<64;i++){
temp=((long)basic_table[i]*scale_factor+50L)/100L;
/*limit the values to the valid range */
if(temp<=0L)temp=1L;
if(temp>255L) temp=255L;/*limit to baseline range if requested */
newtable[zigzag[i]]=(WORD)temp;
}
}
void set_DQTinfo()
{
BYTE scalefactor=50;// scalefactor controls the visual quality of the image
// the smaller is, the better image we'll get, and the smaller
// compression we'll achieve
=0xFFB;
=132;
=0;
=1;
set_quant_table(std_luminance_qt,scalefactor,);
set_quant_table(std_chrominance_qt,scalefactor,);
}
void write_DHTinfo()
{
BYTE i;
writeword();
writeword();
writebyte();
for(i=0;i<16;i++) writebyte(_nrcodes[i]);
for(i=0;i<=11;i++) writebyte(_values[i]);
writebyte();
for(i=0;i<16;i++) writebyte(_nrcodes[i]);
for(i=0;i<=161;i++) writebyte(_values[i]);
writebyte();
for(i=0;i<16;i++) writebyte(_nrcodes[i]);
for(i=0;i<=11;i++) writebyte(_values[i]);
writebyte();
for(i=0;i<16;i++) writebyte(_nrcodes[i]);
for(i=0;i<=161;i++) writebyte(_values[i]);
}
void set_DHTinfo()
{
BYTE i;
=0xFFC4;
=0x01A2;
=0;
for(i=0;i<16;i++) _nrcodes[i]=std_dc_luminance_nrcodes[i+1];
for(i=0;i<=11;i++) _values[i]=std_dc_luminance_values[i];
=0x10;
for(i=0;i<16;i++) _nrcodes[i]=std_ac_luminance_nrcodes[i+1];
for (i=0;i<=161;i++) _values[i]=std_ac_luminance_values[i];
=1;
for(i=0;i<16;i++) _nrcodes[i]=std_dc_chrominance_nrcodes[i+1];
for(i=0;i<=11;i++) _values[i]=std_dc_chrominance_values[i];
=0x11;
for(i=0;i<16;i++) _nrcodes[i]=std_ac_chrominance_nrcodes[i+1];
for(i=0;i<=161;i++) _values[i]=std_ac_chrominance_values[i];
}
void write_SOSinfo()
//Nothing to overwrite for SOSinfo
{writeword();
writeword();
writebyte();
writebyte();writebyte();
writebyte();writebyte();
writebyte();writebyte();
writebyte();writebyte();writebyte();
}
void writecomment(BYTE *comment)
{
WORD i,length;
writeword(0xFFFE);//The COM marker
length=strlen((const char *)comment);
writeword(length+2);
for(i=0;i<length;i++) writebyte(comment[i]);
}
void writebits(bitstring bs)
// A portable version; it should be done in assembler
{
WORD value;
SBYTE posval;//bit position in the bitstring we read, should be</=15 and >=0
value=;
posval=-1;
while(posval>=0)
{if(value & mask[posval]) bytenew|=mask[bytepos];
posval--;bytepos--;
if(bytepos<0){if(bytenew==0xFF) {writebyte(0xFF);writebyte(0);}
else{writebyte(bytenew);}
bytepos=7;bytenew=0;
}
}
}
void compute_Huffman_table(BYTE *nrcodes,BYTE *std_table,bitstring *HT)
{
BYTE k, j;
BYTE pos_in_table;
WORD codevalue;
codevalue=0;pos_in_table=0;
for(k=1;k<=16;k++)
{
for(j=1;j<=nrcodes[k];j++){HT[std_table[pos_in_table]].value=codevalue;
HT[std_table[pos_in_table]].length=k;
pos_in_table++;
codevalue++;
}
codevalue*=2;
}
}
void init_Huffman_tables()
{
compute_Huffman_table(std_dc_luminance_nrcodes,std_dc_luminance_values,YDC_HT);
compute_Huffman_table(std_dc_chrominance_nrcodes,std_dc_chrominance_values,CbDC_HT);
compute_Huffman_table(std_ac_luminance_nrcodes,std_ac_luminance_values,YAC_HT);
compute_Huffman_table(std_ac_chrominance_nrcodes,std_ac_chrominance_values,CbAC_HT);
}
void exitmessage(char *error_message)
{
printf("%s\n",error_message);exit(EXIT_FAILURE);
}
void set_numbers_category_and_bitcode()
{
SDWORD nr;
SDWORD nrlower,nrupper;
BYTE cat,value;
category_alloc=(BYTE*)malloc(65535*sizeof(BYTE));
if(category_alloc=NULL)exitmessage("Not enough memory.");
category=category_alloc+32767;//allow negative subscripts
bitcode_alloc=(bitstring *)malloc(65535*sizeof(bitstring));
if(bitcode_alloc==NULL) exitmessage("Not enough memory.");
bitcode=bitcode_alloc+32767;
nrlower=1;nrupper=2;
for(cat=1;cat<=15;cat++)
{
//Positive numbers
for(nr=nrlower;nr<nrupper;nr++)
{category[nr]=cat;
bitcode[nr].length=cat;bitcode[nr].value=(WORD)nr;
}
//Negative numbers
for(nr=-(nrupper-1);nr<=-nrlower;nr++)
{category[nr]=cat;
bitcode[nr].length=cat;
bitcode[nr].value=(WORD)(nrupper-1+nr);
}
nrlower<<=1;
nrupper<<=1;
}
}
void precalculate_YCbCr_tables()
{
WORD R,G,B;
for(R=0;R<=255;R++) {YRtab[R]=(SDWORD)(65536*+)*R;
CbRtab[R]=(SDWORD)(65536*+)*R;
CrRtab[R]=(SDWORD)(32768)*R ;
}
for(G=0;G<=255;G++) {YGtab[G]=(SDWORD)(65536*+)*G;
CbGtab[G]=(SDWORD)(65536*+)*G;
CrGtab[G]=(SDWORD)(65536*+)*G;
}
for(B=0;B<=255;B++) {YBtab[B]=(SDWORD)(65536*+)*B;
CbBtab[B]=(SDWORD)(32768)*B;
CrBtab[B]=(SDWORD)(65536*+)*B;
}
}
// Using a bit modified form of the FDCT routine from I JG' s C source:
// Forward DCT routine idea taken from Independent JPEG Group' s C source for
// JPEG encoders/decoders
/* For float AA&N IDCT method, divisors are equal to quantization coefficients scaled by
scalefactor[row]*scalefactor[col], where scalefactor[0] = 1
scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=l. .7 We apply a further scale factor of 8.
What's actually stored is I/divisor so that the inner loop can use a multiplication rather than a
division. */
void prepare_quant_tables()
{
double
aanscalefactor[8]={,,,,,,,0.
275899379};
BYTE row, col;
BYTE i=0;
for (row=0;row<8;row++)
{
for(col=0;col<8;col++)
{
fdtbl_Y[i]=(float)(
l]*));
fdtbl_Cb[i]=(float)(
col]*));
i++;
}
}
}
void fdct_and_quantization(SBYTE *data, float *fdtbl,SWORD *outdata)
{
float tmp0,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7;
float tmp10,tmp11,tmp12,tmp13;
float z1,z2,z3,z4,z5,z11,z13;
float *dataptr;
float datafloat[64];
float temp;
SBYTE ctr;
BYTE i;
for(i=0;i<64;i++) datafloat[i]=data[i];
/* Pass 1: process rows. */
dataptr=datafloat;
for(ctr=7;ctr>=0;ctr--){
tmp0=dataptr[0]+dataptr[7];
tmp7=dataptr[0]-dataptr[7];
tmp1=dataptr[1]+dataptr[6];
tmp6=dataptr[1]-dataptr[6];
tmp2=dataptr[2]+dataptr[5];
tmp5=dataptr[2]-dataptr[5];
tmp3=dataptr[3]+dataptr[4];
tmp4=dataptr[3]-dataptr[4];
/* Even part */
tmp10=tmp0+tmp3;/*phase 2 */
tmp13=tmp0-tmp3;
tmp11=tmp1+tmp2;
tmp12=tmp1-tmp2;
dataptr[0]=tmp10+tmp11;/* phase 3 */
dataptr[4]=tmp10-tmp11;
z1=(tmp12-tmp13)*((float));/* c4 */
dataptr[2]=tmp13+z1;/* phase 5 */
dataptr[6]=tmp13-z1;
/* Odd part */
tmp10=tmp4+tmp5; /* phase 2 */
tmp11=tmp5+tmp6;
tmp12=tmp6+tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
z5=(tmp10-tmp12)*((float));/* c6 */
z2=((float))*tmp10+z5;/* c2~c6 */
z4=((float))*tmp12+z5;/*c2+c6 */
z3=tmp11*((float));/* c4 */
z11=tmp7+z3;/* phase 5 */
z13=tmp7-z3;
dataptr[5]=z13+z2;/* phase 6 */
dataptr[3]=z13-z2;
dataptr[1]=z11+z4;
dataptr[7]=z11-z4;
dataptr+=8;/* advance pointer to next row */
}
/* Pass 2: process columns. */
dataptr=datafloat;
for(ctr=7;ctr>=0;ctr--){
tmp0=dataptr[0]+dataptr[56];
tmp7=dataptr[0]-dataptr[56];
tmp1=dataptr[8]+dataptr[48];
tmp6=dataptr[8]-dataptr[48];
tmp2=dataptr[16]+dataptr[40];
tmp5=dataptr[16]-dataptr[40];
tmp3=dataptr[24]+dataptr[32];
tmp4=dataptr[24]-dataptr[32];
/* Even part */
tmp10=tmp0+tmp3; /* phase 2 */
tmp13=tmp0-tmp3;
tmp11=tmp1+tmp2;
tmp12=tmp1-tmp2;
dataptr[0]=tmp10+tmp11; /* phase 3 */
dataptr[32]=tmp10-tmp11;
z1=(tmp12-tmp13)*((float));/*c4*/
dataptr[16]=tmp13+z1;/*phase 5*/
dataptr[48]=tmp13-z1;
/* Odd part */
tmp10=tmp4+tmp5;/* phase 2 */
tmp11=tmp5+tmp6;
tmp12=tmp6+tmp7;
/*The rotator is modified from fig 4-8 to avoid extra negations. */
z5=(tmp10-tmp12)*((float));/* c6 */
z2=((float))*tmp10+z5;/* c2-c6 */
z4=((float))*tmp12+z5;/* c2+c6 */
z3=tmp11*((float));/* c4 */
z11=tmp7+z3;/* phase 5 */
z13=tmp7-z3;
dataptr[40]=z13+z2;/* phase 6 */
dataptr[24]=z13-z2;
dataptr[8]=z11+z4;
dataptr[56]=z11-z4;
dataptr++; /* advance pointer to next column */
}
// Quantize/descale the coefficients, and store into output array
for(i=0;i<64;i++){
/* Apply the quantization and scaling factor */
temp=datafloat[i]*fdtbl[i];
/* Round to nearest integer.
Since C does not specify the direction of rounding for negative
quotients, we have to force the dividend positive for portability. The maximum coefficient size is
+-16K (for 12-bit data), so this code should work for either 16-bit or 32-bit ints.
*/
outdata[i]=(SWORD)((SWORD)(temp+)-16384);
}
}
void process_DU(SBYTE *ComponentDU,float *fdtbl,SWORD *DC,bitstring *HTDC,bitstring
*HTAC)
{
bitstring EOB=HTAC[0x00];
bitstring M16zeroes=HTAC[0xF0];
BYTE i;
BYTE startpos;
BYTE endOpos;
BYTE nrzeroes;
BYTE nrmarker;
SWORD Diff;
fdct_and_quantization(ComponentDU,fdtbl,DU_DCT);//zigzag reorder
for(i=0;i<=63;i++) DU[zigzag[i]]=DU_DCT[i];
Diff=DU[0]-*DC;
*DC=DU[0];
//Encode DC
if(Diff=0) writebits(HTDC[0]);//Diff might be 0
else{writebits(HTDC[category[Diff]]);
writebits(bitcode[Diff]);
}
//Encode ACs
for(endOpos=63;(endOpos>0)&&(DU[endOpos]==0);endOpos--);
//endOpos=first element in reverse order !=0
if(endOpos==0){writebits(EOB);return;}
i=1;
while(i<=endOpos)
{
startpos=i;
for(;(DU[i]==0)&&(i<=endOpos);i++);
nrzeroes=i-startpos;
if(nrzeroes>=16){
for(nrmarker=1;nrmarker<=nrzeroes/16;nrmarker++)
writebits(M16zeroes);
nrzeroes=nrzeroes%16;
}
writebits(HTAC[nrzeroes*16+category[DU[i]]]);
writebits(bitcode[DU[i]]);
}
if(endOpos!=63)
writebits(EOB);
}
void load_data_units_from_RGB_buffer(WORD xpos,WORD ypos)
{
BYTE x,y;
BYTE pos=0;
DWORD location;
BYTE R,G,B;
location=ypos*Ximage+xpos;
for(y=0;y<8;y++)
{
for(x=0;x<8;x++)
{
R=RGB_buffer[location].R;G=RGB_buffer[location].G;B=RGB_buffer[location].B;YDU[pos]=
Y(R,G,B);
CbDU[pos]=Cb(R,G,B);
CrDU[pos]=Cr(R,G,B);
location++;pos++;
}
location+=Ximage-8;
}
}
void main_encoder()
{
SWORD DCY=0,DCCb=0,DCCr=0;//DC coefficients used for differential encoding
WORD xpos,ypos;
for(ypos=0;ypos<Yimage;ypos+=8)
for(xpos=0;xpos<Ximage;xpos+=8)
{
load_data_units_from_RGB_buffer(xpos,ypos);
process_DU(YDU,fdtbl_Y,&DCY,YDC_HT,YAC_HT);
process_DU(CbDU,fdtbl_Cb,&DCCb,CbDC_HT,CbAC_HT);
process_DU(CrDU,fdtbl_Cb,&DCCr,CbDC_HT,CbAC_HT);
}
}
void load_bitmap(char *bitmap_name, WORD *Ximage_original,WORD *Yimage_original)
{
WORD Xdiv8,Ydiv8;
BYTE nr_fillingbytes;//The number of the filling bytes in the BMP file
// (the dimension in bytes of a BMP line on the disk is divisible by 4)
colorRGB lastcolor;
WORD column;
BYTE TMPBUF[256];
WORD nrline_up,nrline_dn,nrline;
WORD dimline;
colorRGB *tmpline;
FILE *fp_bitmap=fopen(bitmap_name,"rb");
if(fp_bitmap==NULL) exitmessage("Cannot open bitmap file. found ?");
if(fread(TMPBUF,1,54,fp_bitmap)!=54)
exitmessage("Need a truecolor BMP to encode.");
if ((TMPBUF[0]!='B')|(TMPBUF[1]!='M' || (TMPBUF[28]!=24)))
exitmessage("Need a truecolor BMP to encode.");
Ximage=(WORD)TMPBUF[19]*256^TMPBUF[18];
Yimage=(WORD)TMPBUF[23]*256+TMPBUF[22];*Ximage_original=Ximage;*Yimage_origin
al=Yimage;//Keep the old dimensions
// of the image
if(Ximage%8!=0)Xdiv8=(Ximage/8)*8*8;
else Xdiv8=Ximage;
if(Yimage%8!=0) Ydiv8=(Yimage/8)*8+8;
else Ydiv8=Yimage;
// The image we encode shall be filled with the last line and the last column // from the original
bitmap, until Ximage and Yimage are divisible by 8 // Load BMP image from disk and complete
X RGB_buffer=(colorRGB*) (malloc(3*Xdiv8*Ydiv8)) ;
if(RGB_buffer=NULL) exitmessage("Not enough memory for the bitmap image.");
if(Ximage%4!=0) nr_fillingbytes=4-(Ximage%4);
else nr_fillingbytes=0;
for(nrline=0;nrline<Yimage;nrline++)
{
fread(RGB_buffer+nrline*Xdiv8,1,Ximage*3,fp_bitmap);
fread(TMPBUF,1,nr_fillingbytes,fp_bitmap);
memcpy(&lastcolor,RGB_buffer+nrline*Xdiv8+Ximage-1,3);
for(column=Ximage;column<Xdiv8;column++)
{memcpy(RGB_buffer-nrline*Xdiv8+column,&lastcolor,3);}
}
Ximage=Xdiv8;
dimline=Ximage*3;tmpline=(colorRGB *)malloc(dimline);
if(tmpline==NULL)exitmessage("Not enough memory.");
//Reorder in memory the inversed bitmap
for(nrline_up=Yimage-1,nrline_dn=0;nrline_up>nrline_dn;nrline_up--,nrline_dn++)
{
memcpy(tmpline,RGB_buffer+nrline_up*Ximage,dimline);
memcpy(RGB_buffer-nrline_up*Ximage,RGB_buffer+nrline_dn*Ximage,dimline);
memcpy(RGB_buffer-nrline_dn*Ximage,tmpline,dimline);
}
// Y completion:
memcpy(tmpline,RGB_buffer-(Yimage-1)*Ximage,dimline);
for(nrline=Yimage;nrline<Ydiv8;nrline++)
{memcpy(RGB_buffer-nrline*Ximage,tmpline,dimline);}
Yimage=Ydiv8;free(tmpline);
fclose(fp_bitmap);
}
void init_all()
{
set_DQTinfo();
set_DHTinfo();
init_Huffman_tables();
set_numbers_category_and_bitcode();
precalculate_YCbCr_tables();
prepare_quant_tables();
}
void main(int argc, char *argv[])
{
char BMP_[64];
char JPG_[64];
WORD Ximage_original,Yimage_original;//the original image dimensions,
// before we made them divisible by 8
BYTE len_;
bitstring fillbits;//filling bitstring for the bit alignment of the EOI marker
if(argc>1)
{ strcpy(BMP_[1]);
if(argc>2)
strcpy(JPG_[2]);
else
{strcpy(JPG_);
len_(BMP_);
strcpy(JPG_(len_),"jpg");
}
}
else
exitmessage("Syntax:enc []");
load_bitmap(BMP_);
fp_jpeg_stream=fopen(JPG_,"wb");
init_all();
=Ximage_original;
=Yimage_original;
writeword(0xFFD8);//SOI
write_APPOinfo();
// write_comment (''Cris made this JPEG with his own encoder");
write_DQTinfo();
write_SOFOinfo();
write_DHTinfo();
write_SOSinfo();
bytenew=0;bytepos=7;
main_encoder();
//Do the bit alignment of the EOI marker
if (bytepos>=0){
=bytepos+1;
=(1<<(bytepos+1))-1;
writebits(fillbits);
}
writeword(0xFFD9);//EOI
free(RGB_buffer);free(category_alloc);free(bitcode_alloc);
fclose(fp_jpeg_stream);
}
五、实验总结
1． 项目实践报告。
2． 提交 BMP 转换 JPG 格式文件的程序清单。
注：参考程序摘自开发笔记下载&cate_id=11&flag=1（访问时间2006年1月）
项目实践七 Premiere 视频编辑
一、实验目标
1. 初步掌握视频编辑的基本方法
2．通过本实践项目的学习，我们来了解一下利用 Premiere 制作电影的基本过程。
二、实验内容
利用 Adobe Premiere 软件进行电视节目《祝贺申奥成功》的片头制作。
三、实验环境
1．计算机
2．Adobe Premiere 软件
四、实验步骤
电视节目《祝贺申奥成功》的片头制作效果如图 7-1 所示。在制作过程中将用到 Title
文件的编辑，过渡效果中的 Zoom、Non－additive Dissolve、Center Peel 换景片断，虚拟片
断，动画设置等。
图 7-1 实例效果
以下是该实例的制作步骤：
（1）选择→Title 命令或者使用快捷键直接在 Premiere 中按下 F9 键，弹出 Title 文
件的编辑器。选择 Title 文件编辑器工具箱中的 ，然后在编辑区内要写字的地方选择鼠
标左键，然后右击，在弹出的命令快捷菜单中选择 Font 命令，选择字体为楷体，大小 48，
选择 Style（风格）命令，选择方式为 Emboss，输入“更高”2 个字。在文本编辑区右击，选
择 Center Horizontally 选项，将写好的文字水平中间对齐，再选择右击 Center Vertically 选项，
将写好的文字上下中间对齐，将文字调到屏幕的中央，如图 7-2 所示。用同样的设置，再
创建如图 7-2 右上图所示的“更强”和“更快”的 Title 文件。然后创建一个“北京 2008”的 Title
文件，如图 7-2 的下图所示。字体用宋体，方式为 Plain，周围的框用 工具来画出。分
别把这 4 个文件保存为 、、、 文本文件。
图 7-2 编辑文字字幕
（2）创建片头中的运动的文字部分。
同步骤 1 中一样，用 工具，在编辑区中写入“祝贺”字，设置的字体风格方法和步
骤 1 一样，字体楷书，大小 72，方式为 Emboss，如图 7-3 左图所示。用同样的参数在创建
2 个文件“申奥”和“成功”，分别如图 7-3 中图和右图所示。并分别保存为 、、
文本文件。
图 7-3 编辑文字字幕
创建第 2 部分的文字，“新北京”，“新奥运”，“相约 2008”。设置的字体风格方法和步
骤 1 一样，字体使用行楷，大小 72，方式为 Emboss，如图 7-4 所示。分别保存为 、
、 文本文件。
图 7-4 编辑文字字幕
（3）下面将素材导入 Project 窗口中。
在制作影视节目时，首先得创建一个新电影剧本（ Project 或者快捷键方式 Ctrl＋N）。
从预设表框中选择 Multimedia Video for Windows 选项，单击 OK 按钮即可。
Adobe Premiere 通过组合素材的方法来制作电影。所谓“素材”，就是未经剪辑的视频、
音频片断。将视频图像采集到计算机中形成的视频文件，基本上都需要 2 次加工。动画
FLC、FLI 由于在制作时已经经过精心策划，基本上不需要进行 2 次加工。所谓“影片”，指
的是 Premiere 对素材加工后的成品，一般是较完整的片断，甚至是一个包含特技、字幕、
音频的完整文件，它一般先存在计算机的硬盘上，通过视频回放卡再录制到录像带上或者光
盘上。由于电视机和计算机视频表现模式有明显的差异，所以 Premiere 普通系统和桌面系
统所最终形成的影片文件，尽管通常都命名为 AVI，但却有很大的差别。一般普通系统制作
的影片只能在计算机上回放，不需额外的硬件支持。桌面系统制作的影片质量很高，画面质
量能达到电视台播出的广播级水准，当然其数据量和普通系统相比要大得多，需配合视频回
放卡才能实时在电视上播出。Premiere 同时有格式转换的功能，可以方便地将电视格式的
AVI 文件转换成计算机格式的 AVI 文件。
在 Premiere 里面创建的 Title 文件，在保存以后都会自动导入到 Project 窗口中。所以以
前创建的文件都不用再重新导入。
现在将另 3 个文件导入 Project 窗口。选择→Folder…命令，在例子所在的文件夹下选择
“素材”文件夹，这样就把要用的文件导入了 Project 窗口，如图 7-5 所示，有 2 个背景图片
文件和一个音频文件。
图 7-5 加入素材
（4）下面开始逐步将文件导入 Timeline 窗口中。
先在 Timeline 窗口中增加 3 条视频轨道。选择 Timeline 窗口右上角的 3 角形，或者在
视频轨道右边的 Video 字样附近右击鼠标，然后在弹出的菜单命令中选择 Add Video Track
选项，这样就在 Timeline 窗口中添加了 1 条视频轨道 Video 3。再重复 2 次同样的操作，就
可以再 Timeline 窗口中增加 Video 4 和 Video 5 两条轨道。将文件“北京 2008”拖入 Video 2
轨道中。将文件“更快”拖入 Video 3 轨道中。将文件“更强”拖入 Video 4 轨道中。将文件“更
高”拖入 Video 5 轨道中。接着设置这 4 个文件的延时都为 4 秒。
然后选择 Video 2 到 Video 5 这 4 个视频轨道前面的 ，将每个轨道都展开来设置它的
淡化线。设置刚才导入的 4 个文件的淡化器如图 7-6 所示。“北京 2008”文件渐渐淡去，其
他 3 个逐渐显现。
图 7-6 设置淡入、淡出效果
（5）设置“更高”，“更强”，“更快”3 个 Title 文件的动画效果。
设置文件“更高”的动画效果如图 7-7 所示。（起点：坐标 0，10； Zoom：0％
终点：坐标 0，10；Zoom：100％）
图 7-7 设置动画效果
设置文件“更强”的动画效果如图 7-8 所示。（起点：坐标 54，10；Zoom：100％
＃1 点：坐标 15，10；Zoom：100％；Time ：85％ 终点： 坐标 54，10；Zoom 100％）
图 7-8 设置动画效果
设置文件“更快”的动画效果同上（起点：坐标 54，10；Zoom：100％ ＃1 点：坐标
15，10；Zoom：100％；Time：85％ 终点： 坐标 54，10； Zoom：100％）。
（6）为了能利用换景片断的效果，对刚才所编辑的几个片断必须利用虚拟片断来将它
合成一个片断。在 Timeline 窗口的工具箱中选择 工具，然后在刚才几个片断的时间内，
圈出一个虚线框，在鼠标变成如图 7-9 所示的形状时，按住鼠标左键并拖动它，就会出现一
个片断随着鼠标移动。拖动这个片断放到想要放入的位置，如图 7-9 所示，将它放在 Video 1A
轨道上，时间上紧接刚才的片断。
图 7-9 制作虚拟片断
（7）然后在时间上紧接刚才的虚拟片断，分别在 Video 2，Video 3，Video4 轨道上拖
入“成功”，“申奥”，“祝贺”3 个文件。并且设置 3 个文件的延时为 9 秒，具体做法如下：选
中“成功”文件，然后右击，在弹出的快捷菜单命令中选择 Duration 命令，然后对片断的持续
时间进行修改，选择 OK 按钮确定。
如果这 3 个轨道没有展开，就选择轨道前面的 将轨道展开。调节“成功”，“申奥”，
“祝贺”3 个文件的淡化器。当鼠标指针在淡化线上的时候会变成手指的形状，这时选择一下
鼠标左键就可以在鼠标所在的位置增加一个关键点。在每个片断的中点处增加一个关键点，
然后设置淡化线如图 7-10 所示。
图 7-10 调整片断时间及设置淡化线
然后将 文件拖入 Video 1B 轨道中，设置它的延时为 11 秒。与前面 Video 1A
轨道中虚拟片断在时间上重合 1 秒。然后在重合部分的 Transition 轨道中拖入 Zoom 换景片
断。
（8）设置“祝贺”，“申奥”，“成功”3 个片断的动画。
设置文件“祝贺”的动画效果如图 7-11 所示。（起点：坐标 15，35；Zoom：100％
＃1 点：坐标 15，0；Zoom：100％；Time：75％ 终点：坐标 15，0 ；Zoom 100％）
设置文件“申奥”的动画效果如图 7-12 所示。（起点：坐标 50，0； Zoom：100％
＃1 点：坐标 15，0；Zoom：150％；Time：50％ 终点：坐标 15，0；Zoom：100％）
图 7-11 设置动画效果 图 7-12 设置动画效果
设置文件“成功”的动画效果如图 7-13 所示。（起点：坐标 15，35；Zoom：100％
＃1 点：坐标 15，18；Zoom：100％；Time：50％ 终点：坐标 15，0；Zoom：100％）
图 7-13 设置动画效果
（9）分别将“新北京”，“新奥运”和“相约 2008”3 个文件拖入 Video 2，Video 3 和 Video
4 3 个轨道中。并设置他们的延时都为 9 秒。在时间上落后刚才的“祝贺”，“申奥”，“成功”3
个文件 1 秒，并调整“新北京”，“新奥运”和“相约 2008”3 个文件的淡化器，如图 7-14 所示。
图 7-14 调整淡化器
将 文件拖入 Video 1A 轨道中，将其延时设置为 11 秒，并且在时间上紧接“祝
贺”，“申奥”，“成功”3 个文件，也就是与 在时间上重合 1 秒。然后在重合部分
的 Transition 轨道中加入 Non－additive Dissolve 换景片断。然后再将刚才的虚拟片断复制并
拖到 Video 1B 轨道中，时间上与 文件重合 1 秒。在它们重合部位的 Transition 轨
道中加入 Center Peel 换景片断。如图 7-15 所示。
图 7-15 设置淡化器
（10）设置“新北京”，“新奥运”，“相约 2008”3 个文件的动画。
①设置文件“新北京”的动画效果如图 7-16 所示。（起点：坐标 42，32；Zoom：100％
＃1 点：坐标 22，17；Zoom：150％；Time：50％ 终点： 坐标 0，0； Zoom：100％）
①设置文件“新奥运”的动画效果如图 7-17 所示。（起点：坐标 58，0；Zoom：100％
＃1 点：坐标 29，0；Zoom：50％；Time：50％ 终点： 坐标 0，0； Zoom：100％）
图 7-16 设置动画效果 图 7-17 设置动画效果
①设置文件“相约 2008”的动画效果如图 7-18 所示。（起点：坐标 49，35；Zoom：100％；＃
1 点：坐标 26，4；Zoom：150％；Time：50％ 终点： 坐标 0，0；Zoom：100％）
图 7-18 设置动画效果
（11）将“”文件拖入 Audio 3 轨道中，因为 Audio 1 和 Audio 2 已经被虚
拟的片断所占据。用 工具剪去前 50 秒的音频文件，然后拖动音频文件使它与第 1 个虚
拟片断对齐。再用 工具把它与第 2 个虚拟片断的末尾剪齐。再在音频片断的尾端设置
淡化。点击 Audio 1 和 Audio 2 轨道前端的 ，使它消失，就使这 2 个轨道失去了作用，如
图 7-19 所示。
（12）然后选择 Premiere 菜单窗口中的命令，保存电影剧本，按下 Enter 键进行节目预
览。在激活 Timeline 窗口的情况下，执行 Timeline→Movie 命令，把输出的节目命名为“北
京奥运.avi”，点击 Settings 按钮，打开 Export Movie Settings（输出电影设置）下拉列表框，
在对话框中可以改变制作电影的各个特性，在 General Settings 设置对话框中，File 选项中选
择 Microsoft AVI、Range 选项中再选择 Work Area（工作区域）、再选择 Export Video（输
出视频）、Export Audio（输出音频）和 Open When Finished（完成后输出），选择“保存”
按钮就会出现 Exporting 程序处理条，输出节目，如图 7-20 所示。等待几分钟后，会出现播
放“北京奥运.avi”节目的 Clip 窗口，选择播放按钮或循环播放按钮就可以看到最后的编辑效
果了。
图 7-19 设置音频淡化线
图 7-20 保存电影
五、实验结论与成果
1. 项目实践报告。
2. 提交项目制作的成果。
项目实践八 VCD 光盘的制作
一、实验目的
(1) 通过实验学习视频信号的捕捉和压缩方法，了解计算机捕捉和压缩的主要原理。
(2) 掌握在 Premiere Pro 中调用 MPGator 压缩卡对 AVI 文件进行高效率的硬件压缩编
辑的方法，能够用 Premiere Pro 进行视频图象的非线性编辑。
(3) 掌握用 Video Pack 刻录制作 Video CD 视频光盘。
二、实验内容
(1)利用 MPEGator 对视频信号进行捕捉和压缩
(2)利用 Premiere Pro 完成视频图象的编辑
(3)Video CD 视频光盘的刻录制作
三、实验要求
(1) 提交利用 MPEGator 捕捉和压缩到的视频信号数据。
(2) 提交利用 Premiere Pro 编辑后的视频 MPG 文件。
(3) 提交最后刻录完成的 Video CD 视频光盘作品。
四、实验操作
视频图象的压缩编辑及 Video CD 视频光盘的刻录制作
1、视频信号的捕捉/压缩
制作 VCD 视频光盘的首要环节就是通过视频捕捉卡（压缩卡）从录象机、影碟机、电
视等视频信号源采集我们需要的视频信号。我们一般都通过压缩卡来完成,并使用压缩卡相
应的视频捕捉应用程序来完成图象采集。下面,我们以 MPEGator 压缩卡为例，来完成视频
信号的捕捉/压缩. 首先,我们必须保证我们的计算机具备相应的压缩卡并连接正确。
步骤 1：连接压缩卡与录象机.
我们把视频信号源(录象机、影碟机、电视等)的视频输出（Video Out）与压缩卡的视频
输入（Video In）用视频信号线连接起来；然后用音频信号线分别连接视频信号源(录象机、
影碟机、电视等) 的音频输出（Audio Out)与压缩卡和音频输入（AudioIn)。
步骤 2：打开视频捕捉应用程序
选择【开始】/【程序】/【MPEGator】，打开 M-Coder 应用程序。我们在操作界面上可
以看到目标文件名及路径、已捕捉时间、总帧数及文件的大小等项目。
步骤 3：设置相关视频捕捉参数
单击界面右侧有刻度尺标记的按钮，会出现 MPEGator 的控制参数设置框。
(1)首先,我们选择制作 PAL 制式的 Video CD，则相应视频流的值将自动定为 1124KB/sec，
画面尺寸被定义为 352*288；相应的音频流被固定在于 224kb/sec、 采样频率、joint st
ereo 立体声模式（VCD 白皮书标准）。
(2)接着,在【Video】项中，我们再对亮度、对比度、饱和度等参数进行一定的设置,使
之符合我们的要求。
(3)最后，我们对画面的垂直及水平偏移量也进行调节。
步骤 4：开始捕捉
(1)我们已经对视频捕捉参数进行了设置，下面,我们首先设定目标文件名，然后按下红
色的【捕捉（Capture）】按钮，就可以边预览边捕捉了。遇到不想截取的内容按下暂停键跳
过，可以对视频信号进行简单的实时编辑.
(2)接着,我们对捕捉下来的视频图象进行存取。一般情况下,可以分别存为 MPG 文件或.
AVI 文件。在这里我们把它存为.AVI 文件,以便我们接下来用 Premiere Pro 软件对它进行编
辑。
2、视频图象的编辑
Premiere Pro 的主编辑界面主要由两条视频轨道、一条切换轨道，一条附加轨道和三条
音频轨道及底部工具栏构成。下面我们在 Premiere Pro 中调用 MPGator 压缩卡对 AVI 文件
进行高效率的硬件压缩编辑。
步骤 1： 对 Premiere Pro 的音、视频参数进行设置
(1)首先, 选择【开始】/【程序】/【Premiere Pro】，打开 Premiere Pro,在弹出的 New Project
setting 窗口（如图 8-1）中选择【General settings】,在编辑模式里选【Video for window】，
其下的两个选项均选 25。
图 8-1 项目设置窗口
(2)然后,打开【Video settings】,在【压缩器（Compressor）】这一项中选【DVMPEG Video
(hardware)】，即选用硬件压缩；分辨率设为 352*288，帧率设为 25；在【Audio settings】里
(如图 2)，我们在【Type(类型）】中选择【DVMPEG Audio】从而指定用硬件进行音频压缩；
采样频率设为 ，格式设为 16bit--Stereo。
图 8-2 声音参数设置
步骤 2：输入影、音文件
选择【File】/【Import】/【Folder】，我们把已经准备好的 AVI 文件及背景音乐文件输
入进来，在【Project】窗口下双击刚才输入的文件夹，我们可以查看文件夹中的各文件的具
体信息，双击该文件则可对它进行预览。
步骤 3：编排影、音文件
(1)首先,我们将第一个 AVI 文件拖到视频剪辑轨道 Video 1A 中。然后把其它需要编辑
的 AVI 文件依次拖入 Video1 的 A、B 栏，我们需要将每个 AVI 文件的结尾部分与下一个 A
VI 文件的开始部分留有重叠部份，重叠部份的时间长短依实际需要而定。
(2)接着,把背景音乐（最好为 WAV 文件）拖到音频轨道 Audio 1，点击旁边的小三角
符号后可以看到该 WAV 文件的左右声道的波形情况，拖动红色调节线，可实现声音的淡入
淡出效果(如图 3)。
图 8-3 淡入淡出效果设置
(3)最后，我们用鼠标把【Timeline】上方的浅蓝色横杠拉至最后一个 AVI 文件的末端，
从而设定 Premiere 将处理的视频片段的区域。
步骤 4：设定视频切换特效
首先我们打开【Transition】/【Commands】命令窗口，其中共有许多种切换特效可供选
择。我们可以按自己的需要进行设置。接着,我们将选中的切换特效用鼠标拖到 Video 1 窗
口的 Transition 中两个 AVI 文件相重叠的部分，其长度应为两个 AVI 文件相重叠的长度。
步骤 5：生成 MPG 文件
我们选择菜单栏里的【File】/【Export】/【Movie】,为即将生成的 MPG 文件取一个文
件名，然后按下【保存】按钮，Premiere Pro 就会把刚才编辑好的影、音文件合成并输出为
可以直接用于 VCD 光盘刻录的标准 MPG 文件了。
3、Video CD 视频光盘的刻录
在这里,我们选择 Cequadrat 公司出品的一套功能强大的 Video CD 刻录软件 Video Pack
。Video Pack 的界面分为上下两个部份共三个视窗。其中，上左为源文件目录列表
窗；上右为源文件列表窗。在源文件视窗中选中的文件，可用鼠标拖到下方的目标视窗中。
我们现在就可以开始制作一张 Video CD 光盘。
步骤 1：增加一个主菜单节点。
通常情况下,主菜单只作一个，用于存放影片标题及制作公司等信息。我们用鼠标单击主
菜单按钮，然后将鼠标移至目标视窗中的适当位置后按一下左键，一个空白主菜单图标就出
现了。
步骤 2：增加一个播放节点（容器）。
我们编辑制作 VCD 时，一般是先将整部影视作品分解为几大部份，每个部分制作完成
后再最后合成。一个容器就是容纳了其中一个部份所有内容的一个播放节点.我们点击【Cont
ainer】键，其余操作与步骤 1 相同。
步骤 3：建立各容器（播放要素）之间的联系（如图 4）。
当容器确定之后，我们就可以用鼠标在这些播放元素之间拖动连线来建立播放关系。我
们把源文件拖到目标视窗后，变成了一个个上下各有一三角形缺口的图标。而这些三角形缺
口正是 Video Pack 用来连接各源文件并确定其播放顺序的。通过连线，我们就确定了
一张 Video CD 光盘的播放蓝图。
图 8-4 容器之间的关系设置
步骤 4：最后,我们按下红色【Make CD】按钮，系统就会自动把 MPEG 文件转换成 Video
CD 的标准数据格式，然后再控制光盘刻录机开始对 CD-R 光盘进行刻录。
至此,我们就完成了视频图象的压缩编辑及 Video CD 视频光盘的制作。
五、实验讨论
(1) 在前面实验中,我们用 MPEGator 压缩卡完成了对视频信号的捕捉和压缩，那么如何
在这个过程中对对亮度、对比度、饱和度进行有效的调节?
(2) 在实验中,我们使用了 Adobe 公司的非线性数字视频编辑软件 Premiere Pro,请你谈
谈 Premiere Pro 的主要优点
（3）在 Video Pack 的目标视窗的底部分布着一排重要的工具按钮,请你例举一下并
说出他们的各自功能？
项目实践九 利用 制作多媒体课件
一、实验目的
1、 初步学会利用 制作简单的多媒体课件。
2、 掌握制作课件的一般过程和技巧。
二、实验器材
计算机、Windows98\2000\2003\XP 操作系统（推荐使用 Windows XP）、、
制作课件所需的图像、声音、电影、动画等相关素材。
三、实验原理
是 Microsoft 公司于 2003 年 6 月发行的最新版本。与以前的版本相比，
它有提供高效率的开发工具、全面支持 32 位的应用、可以导入 Microsoft PowerPoint 演示
文稿等很多方面的新特性。它提供了完全可视化的设计环境以及先进的基于设计图标和流
程图的程序设计方法，并且支持一些最热门的技术，比如 ActiveX、交互式三维动画等技
术，使用它可以开发出很好的演示程序，以及高度交互的在线学习和训练程序。现在已经
成为一种课件制作领域中的标准开发工具。
四、实验步骤
1、 开机启动 。
2、 在弹出的对话框中单击“Cancel”,即可以进入 的主操作界面。
3、 提供了“显示”设计图标、“移动”设计图标、“擦除”设计图标、“声音”设计
图标、“数字化电影”设计图标等多种设计图标。选择“显示”设计图标，拖动一个“显
示”设计图标到流程线上，双击该图标打开“演示”窗口。
4、若需在课件中有文本内容，只需单击“绘图工具箱”中的“文本”工具，将指针移动到
“演示”窗口。在需要文本的地方单击鼠标左键，“演示”窗口中就会出现文本标尺和文
本插入点光标，输入文本就可以了。如果想使文本更加美观，达到自己想要的风格，
可以改变文本的颜色、字号、样式等来实现。
5、若在课件中需要图形，单击“绘图工具箱”中的工具，将指针移动到“演示”窗口，在
“演示”窗口中按下鼠标左键并拖动鼠标就可以绘制简单的图形。对于绘制好的这些
图形，单击“指针”工具，选中对象，然后用鼠标拖动周围的控点，可以改变大小和
形状。
6、若需插入图片，首先在设计窗口将手形插入指针定位到插入图像的位置，然后单击
“导入文件”按钮，出现一个对话框，在其中选择所需的文件，最后按下“Import”按钮
就可以把图像文件导入到程序文件中。通常，所有的图像都位于“演示窗口”的中央，
当然也可以对图像文件进行移动、缩放等操作，达到自己满意的效果。如果已经导入
了多个图像文件，后导入的文件就会覆盖原来的图像，此时可以按照需要在“覆盖模
式”选择板中灵活选择可行的覆盖模式，对图像文件进行处理。
7、若需制造出丰富的动画效果，可以利用“移动”设计图标可以按照多种方式移动“演示”
窗口中的各种显示对象，并且可以对移动过程进行灵活的控制。
8、若需插入其它对象，如 ActiveX 控件、Flash Movie 文件、Quick Time 文件等，可以
利用“Insert”菜单进行插入，并对其属性进行设置。
9、既然是多媒体课件，声音或数字化电影当然必不可少，声音或数字化电影是除文字
和图像之外又一种传递信息的重要工具，利用“声音”设计图标或“数字化电影”设计图
标可以加载和播放声音或电影文件，可以很好的丰富多多媒体程序的表现力。这样，
在观看文本和图像的同时便可以听到相关的解说。
10、对于各种设计图标，为了达到很好的效果，可以在相应的设计图标的属性检查器中
进行属性设置。另外，对于一些不必要的对象，可以在适当的地方利用“擦除”设计图
标进行擦除以及擦除效果的设置。
11、当素材基本调入后，可以运行程序来进行整体调试，直到调试满意，然后存盘。
五、注意的问题
1、课件要重点突出，要结合具体的设计目标进行设计，不要主次颠倒。
2、合理地运用声音、电影、动画等外部素材，通常运用这些素材可以增强课件的表现
力，但是，不恰当的运用会使主题变得不鲜明。
