先取yuv 文件中一个16×8的块，跑通全流程
理解与思路：
1.块分割
YUV 文件分为：YUV444 YUV 422 YUV420。444:就是：12个char 有4个Y，4个U，4个 U，422：8个char 中有4个Y ，U,V各两个，420：意思就是8char里有6个Y，1个U，1个V。444与422 中的三分量多是交错存储的，420则是先存储Y，再存储U,V。
YUV存储也是线型存储的，不是平面块存储的。
对应到jpeg，也要按YUV的三种格式分别分块。jpeg协议中有一概念MCU：最小编码块。jpeg就是按MCU 为单位循环存储的。MCU中又有若干8×8 的block。这些block 就是Y ，U ，V 分量的8×8 块。
我理解：对应YUV444, 一行内取24字节（这是指水平行，程序处理同时要取8个水平行，意思MCU=8×24字节）。含有Y，U,V各8个字节。也就是说：程序一次读取8行24个char ，处理成3张8×8的表，直到读完整个yuv文件
YUV422：一行 8个char中有4个Y，UV各2个。必须把Y凑成8那就要乘2。那就是一行为16个字节，MCU=16×8，取8行生成一张8×8的Y，UV 各半张，UV要补0成为8×8。
YUV420：一行8个字节中有6个Y，UV各一个，Y×8成为8的倍数水平要取64字节，所以，MCU=8×8×8，意思就是有6张Y表，UV 各一张。
离散余弦变换
找了一组数据来验证，发现余弦转换除了直流分量外都正确，DC不正确，也就是转换后第一个数不正确，才想到第一个数的取值应该超出了char的取值范围-128<char<127,所以换用int存储所以数值
2.量化
Jpeg几乎对Y分量不压缩处理，只压缩UV彩色分量。把几个Y拼在一起余弦处理因为余弦转化是没有损失的，也不会让数据失真。真正让数据失真是量化这个环节，如果量化表全为1，则是无损量化。
下面的程序为借用成品图片的量化表。
3. Z形排序
采用查表法，先按Z顺序生成一个表，读数时按表的数值作为读取位置。
4. 去0
64个数中按位读取每一个数有4种情况：
a) 本为是0,下一位也是0,但下一位不是数据结尾
b）本位是0,下一位是0,但下一位是结尾
c）本位是0,下一位不是0
d）本位不是0
判断生成的结果存储到2位数组中，第一位存储非0数字，第二位存储0的个数
5. 规范RLC 格式：去0后的数如中间有超过15个0,必须拆分; 结尾如有多个0改写为（0,0）
Z 型排序这理还有一个细节错误，应该把直流DC 分出来，只排63个交流系数。
等霍夫曼编码时再修改过来
6. 范式霍夫曼编码
准备借用成品jpeg图片的霍夫曼表来编码。
这里还有几个问题没有搞明白，编码是变长度的比特流不是字节，而c操作的最小单位是字节char, 是怎样把比特流写入内存甚至文件的，难道是以比特流按8个比特为一个单位组成一个字节再写入？
从网上下载了一数据表验证本程序，从余弦转换开始到霍夫曼编码环节止数据只有4舍5入造成的微小差别。
7. 统计Z 排序后（a,b)对中 b的值与b使用的频率，为霍夫曼编码作准备。这里有两种方案，一种每次8×8 后就统计，一种是全帧排序后再统计，但两种情况每次都要存储Z变换的排序数据，待全部统计后生成范式霍夫曼码后再转换这些Z型数据。 霍夫曼码转换是分两次完成的，一次是用自己统计的数据生成的码转换b，生成位数加C的格式。一次是霍夫曼官网的0个数/二进制位数表转换一次。就是（a,b)中的a 与b的位数组成的字节（AAAABBBB）。aaaa就是a，BBBB是b的位数。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/videodev2.h> //v4l2 头文件
#include <string.h>
#include <sys/mman.h>
#include <linux/fb.h>
#include <math.h>
#define PI 3.1415926
#define pic_width 1280 //1280*720 640*360 960*540 320*240 424*240 848*480 640*480
#define pic_heigth 720
#define filename "/home/wjs/Pictures/1.yuv"
#define file1 "/home/wjs/Pictures/1.jpg" //借用成品图片的量化表
//int fdct(char (*i)[8], char (*o)[8] );
int main(void) {
//-----------FDCT()函数------------------------------------
int fdct(char (*i)[8], int(*o)[8] ) { //i 为输入 o 为参数传入的输出转换后的数据
double s;
double au;
double av;
for (int u = 0; u < 8; u++) {
for (int v = 0; v < 8; v++) {
for (int y = 0; y < 8; y++) {
for (int x = 0; x < 8; x++) {
s = s + (1.0 / 4) * i[y][x] * cos((2 * y + 1) * u * PI / 16) * cos((2 * x + 1) * v * PI / 16);
}
}
if (u == 0) {
au = 1.0 / sqrt(2);
} else {
au = 1.0;
}
if (v == 0) {
av = 1.0 / sqrt(2);
} else {
av = 1.0;
}
s = s * au * av; //-30.1856
int s1 = round(s * 100); //-3019
s = s1 / 100.0; //-30.19
o[u][v] = s; //double 转为char 类型
s = 0;
}
}
return 0;
}
//-----------规范RLC格式---------------------
int zl(int len,int (*i)[2],int (*o)[2]){
int t=0; //如果中间有一次超过15个0，o的下标要加一，因为增加了（15,0）
for(int a=0;a<len;a++){
if((a<len)&&(i[a][1]>=16)&&(i[a][0]!=0)){
o[a+t][0]=0;
o[a+t][1]=15;
o[a+1+t][0]=i[a][0];
o[a+1+t][1]=i[a][1]-15;
t++;
}
if((a<len)&&(i[a][1]<16)){
memcpy(&(o[a+t][0]),&(i[a][0]),8); //一行为单位复制
}
if((a==len)&&(i[a][0]==0)){
o[a+t][0]=0;
o[a+t][1]=0;
break;
}
}
return len+t;
}
//-----------去0-----------------------------
int q0(int i[64], int (*o)[2]) {
int t = 0; //输出数组序号
int z = 0; //计算连续的0
for (int a = 0; a < 64; a++) { // a
if ((i[a] == 0) && (i[a + 1] == 0) && ((a + 1) < 63)) { //000001
z++;
} // a
if ((i[a] == 0) && (i[a + 1] == 0) && ((a + 1) == 63)){ //0000结束
z++; //本次的0
o[t][0] =0;
o[t][1] = z+1; //加a+1的0
break; //判断完成
} // a
if ((i[a] == 0) && (i[a + 1] != 0)) { //000100
z++; //加上本次的一个0
o[t][0] = i[a + 1];
o[t][1] = z;
z = 0; //清0,计算下次的连续0
t++;
a = a + 1;
}
if ((i[a] != 0)&&(a==0)) { //第一个数非0
o[t][0] = i[a];
o[t][1] = 0;
t++;
}
if ((a>0)&&(i[a] != 0)&&(i[a-1]!=0)) { //防止第3种重复读取，这种是读取连续的非0
o[t][0] = i[a];
o[t][1] = 0;
t++;
}
}
return t+1;
}
//--------Z 排序--------------------------------
int zz(int (*i)[8], int o[64]) {
int zb[64] = {0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,12,19,26,33,40,48,41,34,27,20,13,6,
7,14,21,28,35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,58,59,52,45,38,31,39,46,53,60,61,54,47,
55,62,63
};
int *p = (int *)i;
for (int a = 0; a < 64; a++) {
int c = zb[a];
o[a] = p[c];
}
return 0;
}
// -----量化函数---------------
int lh(int (*i)[8], char (*lhb)[8], int (*o)[8]) {
for (int a = 0; a < 8; a++) {
for (int b = 0; b < 8; b++) {
o[a][b] = round((i[a][b]) / (lhb[a][b]));
}
}
return 0;
}
FILE *f1 = fopen(file1, "rb"); //如用mmap 必须以读写方式打开文件
if (f1 == NULL) {
puts("filename error");
exit(-1);
}
fseek(f1, 0, SEEK_END);
int len1 = ftell(f1);
fseek(f1, 0, SEEK_SET);
int fd1 = fileno(f1);
unsigned char *mp1 = mmap(NULL, len1, PROT_READ, MAP_SHARED, fd1, 0); //必须要读，写
//---------读量化表-------------------------------
char lh00[64] = {}; //提取量化表
char lh10[64] = {};
for (int a = 0; a < len1; a++) {
if ((mp1[a] == 0xff) && (mp1[a + 1] == 0xdb) && (mp1[a + 2] == 0)) {
for (int b = 0; b < 65; b++) {
if (mp1[a + b + 4] == 0) {
memcpy(lh00, &(mp1[a + b + 5]), 64);
}
if (mp1[a + b + 4] == 1) {
memcpy(lh10, &(mp1[a + b + 5]), 64);
}
}
// printf("\n");
}
}
//---------------------------------------------------------------------------
FILE *f = fopen(filename, "rb"); //如用mmap 必须以读写方式打开文件
if (f == NULL) {
puts("filename error");
exit(-1);
}
fseek(f, 0, SEEK_END);
int len_file = ftell(f);
fseek(f, 0, SEEK_SET);
int fd = fileno(f);
unsigned char *mp = mmap(NULL, len_file, PROT_READ, MAP_SHARED, fd, 0); //必须要读，写
int width_pic = 1280;
int heigth_pic = 720;
//out：1.文件总长度 len_file
// 2.图片宽度 1280 width_pic
// 3.图片高度 720 heigth_pic
// 4.图片数据 *mp
//--------------------------------------------------------
//因为yuv422数据是4个字节生成2个像素点，所以图片的width*heigth*2=len_file
//摄像头输出的分辨率图片宽度×2都是8的倍数，高度X2也是8的倍数。所以yuv数据都不用补列。最多补文件末尾的空字节
//摄像头的分辨率末尾数X2=0,8,6,4,2,就是8的倍数
// 1.----------检查yuv文件长度末尾是否有空字节，有，补0-------------------
if ((width_pic * heigth_pic * 2) != len_file) {
memset(&mp[len_file], 0, (width_pic * heigth_pic * 2 - len_file));
}
// 2.----------取16*8--------------------------------------
//YUV422 字节排列：[0]=Y0 [1]=U0 [2]=Y1 [3]=V0 [4]=Y2 [5]=U1 [6]=Y3 [7]=V1 4个Y 2个U 2个V
//所以取16个字节的yuv 数据，含8个y ，4个u，4个v
unsigned char (*i_mp)[width_pic] = (unsigned char (*)[width_pic])mp;
int m = 0; // 行 取1个（0,0）开始的16×8 块
int n = 0; //列
int heigth = heigth_pic; //行
int width = width_pic; //列
int fheigth = 8;
int fwidth = 16;
unsigned char o[8][16] = {}; //取出16×8的块
if ((m + fheigth) > heigth) {
puts("fheigth error");
exit(-1);
}
if ((n + fwidth) > width) {
puts("fwidth error");
exit(-1);
}
for (int a = 0; a < fheigth; a++) {
for (int b = 0; b < fwidth; b++) {
o[a][b] = i_mp[a + m][b + n];
}
}
munmap(mp, len_file);
//----------分离Y---------------------
char y[8][8] = {};
for (int a = 0; a < 8; a++) {
for (int b = 0; b < 8; b++) {
y[a][b] = o[a][2*b]-128;
}
}
/* char y1[8][8]={
{140,144,147,140,140,155,179,179},//验证程序数据
{144,152,140,147,140,148,167,179},
{152,155,136,167,163,162,152,172},
{168,145,156,160,152,155,136,160},
{162,148,156,148,140,136,147,162},
{147,167,140,155,155,140,136,162},
{136,156,123,167,162,144,140,147},
{148,155,136,155,152,147,147,136}
};
char y[8][8]={};
for(int a=0;a<8;a++){
for(int b=0;b<8;b++){
y[b][a]=y1[b][a]-128;
}
}*/
//----------分离U-----------------
char u[8][8] = {};
memset(&u, 0, 64); //补0
for (int a = 0; a < 8; a++) {
for (int b = 0; b < 8; b++) {
if ((4 * b + 1) <= 16) {
u[a][b] = o[a][4 * b + 1] - 128;
}
}
}
//-----------分离v-----------------
char v[8][8] = {};
memset(&v, 0, 64); //补0
for (int a = 0; a < 8; a++) {
for (int b = 0; b < 8; b++) {
if ((4 * b + 3) <= 16) {
v[a][b] = o[a][4 * b + 3] - 128;
}
}
}
//--------------FDCY Y- U V----------------------------
int y_fdct[8][8] = {};
fdct(y,y_fdct);
int u_fdct[8][8] = {};
fdct(u, u_fdct);
int v_fdct[8][8] = {};
fdct(v, v_fdct);
//----------------量化 Y U V -----------------------------------
//借用成品jpg图片量化表，lh0,lh1
char (*lh0)[8] = (char (*)[8])lh00;
char (*lh1)[8] = (char (*)[8])lh10;
/* char lh0[8][8]={ // 验证数据用量化表
{3,5,7,9,11,13,15,17},
{5,7,9,11,13,15,17,19},
{7,9,11,13,15,17,19,21},
{9,11,13,15,17,19,21,23},
{11,13,15,17,19,21,23,25},
{13,15,17,19,21,23,25,27},
{15,17,19,21,23,25,27,29},
{17,19,21,23,25,27,29,31}
};*/
int y_lh[8][8] = {};
int u_lh[8][8] = {};
int v_lh[8][8] = {};
lh(y_fdct, lh0, y_lh);
lh(u_fdct, lh1, u_lh);
lh(v_fdct, lh1, v_lh);
//---------Z排序--------------------------
int y_z[64] = {};
int u_z[64] = {};
int v_z[64] = {};
zz(y_lh, y_z);
zz(u_lh, u_z);
zz(v_lh, v_z);
//--------去0-------------------------
int y_0[64][2] = {};
int u_0[64][2] = {};
int v_0[64][2] = {};
int len_y_0 = q0(y_z, y_0);
int len_u_0 = q0(u_z, u_0);
int len_v_0 = q0(v_z, v_0);
//-----整理规范------------------------
int y_zl[64][2]={}; //定义是必须指定数组内存大小，下标不能用变量，64是此数组的最大值
int u_zl[64][2]={};
int v_zl[64][2]={};
int len_y_zl=zl(len_y_0,y_0,y_zl);
int len_u_zl=zl(len_u_0,u_0,u_zl);
int len_v_zl=zl(len_v_0,v_0,v_zl);
//---------------------------------------------------------------------
for (int a = 0; a <len_y_zl;a++) {
for (int b = 0; b < 2; b++) {
printf("%d ,",y_zl[a][b]);
}
printf("\n");
}
return 0;
}