2. 程式人生 > >H.264中整數DCT變換，量化，反量化，反DCT究竟是如何實現的？(無程式碼，無真相)

H.264中整數DCT變換，量化，反量化，反DCT究竟是如何實現的？(無程式碼，無真相)

阿新 • • 發佈：2019-02-01

        H.264中採用的是整數DCT變換，在實現的時候，該變換和量化又雜糅在一起，那麼這些錯綜複雜的關係究竟是怎樣糾纏的呢？在參考H.264樂園論壇會員cs1860wd的帖子和H.264 and MPEG-4 VIDEO COMPRESSION(第一版)這本書後，基於帖子和書上的講解，給出相應的實現程式碼，並驗證程式碼的正確性.

        還是以foreman視訊第一幀第一個巨集塊第一個4*4塊為例. 下面給出畫素值：

====================== Y Data ======================
+----------------+----------------+----------------+----------------+
| 43,216,254,249

,|251,254,254,253,|251,252,254,254,|254,254,254,253,|
| 49,198,193,211,|228,205,213,185,|211,207,186,248,|198,203,208,183,|
| 48,194,177,171,|197,173,185,136,|191,195,138,179,|142,176,177,135,|
| 46,214,225,169,|177,189,198,160,|203,208,177,165,|173,196,191,156,|
+----------------+----------------+----------------+----------------+
| 41,185,208,180,|203,228,226,200,|214,226,225,227,|228,225,224,210,|
| 31,130,173,178,|215,230,221,212,|220,229,227,228,|229,227,226,226,|
| 29,119,194,216,|211,213,219,222,|225,223,220,219,|218,218,218,218,|
| 25,126,219,224,|217,224,227,227,|227,226,225,224,|220,220,221,222,|
+----------------+----------------+----------------+----------------+
| 26,131,215,223,|226,225,225,225,|225,226,223,219,|221,221,219,220,|
| 30,136,216,226,|223,224,225,225,|224,221,217,221,|222,219,220,226,|
| 30,136,216,227,|224,224,225,223,|221,218,221,216,|211,224,224,211,|
| 29,135,217,225,|222,221,222,222,|221,209,181,155,|186,210,186,164,|
+----------------+----------------+----------------+----------------+
| 29,134,216,224,|226,230,230,227,|206,177,146,113,|149,162,147,150,|
| 29,135,219,231,|225,201,190,185,|163,144,153,140,|127,143,165,184,|
| 30,139,210,192,|165,142,134,133,|143,141,129,138,|150,178,201,207,|
| 30,125,166,145,|144,154,132,111,|118,161,175,180,|204,214,213,209,|
+----------------+----------------+----------------+----------------+

           該塊的預測值為128（16個位置都是128），之前分析過，在JM8.6中，這一塊在編碼端和解碼端的QDCT均為：

         9   -12   -11   -5

         3    -3      1     0 

         3    -1     -2     1

         0     0      0     0

         且用H.264visa從碼流中得到的DCT係數為：（注意解碼端的DCT與編碼端的DCT必然不同）

====================== Y Data ======================
+------------------------+------------------------+------------------------+------------------------+
| 2304,-3840,-2816,-1600

,|  768,  640, -256,  640,| 1280,  320,  256, -640,|  768, -320, -768,    0,|
|  960,-1200,  320, 0,|    0,    0,  320,    0,| -640, -800,    0,    0,|  960, -800,  320,    0,|
|  768, -320, -512,  320,|  512, -640,    0, -320,| -768,  320, -512,  320,|  768,    0,  256,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|    0,  400,    0,    0,| -320,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
|-1024,-5120,-1792, -640,| 2560, -640, -256,    0,|  512,    0,    0,    0,|    0,    0,    0,    0,|
|    0, 1200, -640, -400,| -320,  400,    0,    0,|  640,    0,    0,    0,|  320,    0,    0,    0,|
|  512,    0, -256,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|
|  320,    0,    0,    0,| -320,    0,    0,    0,|    0,    0,    0,    0,|    0,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
|    0,  320,    0,    0,|    0,    0,    0,    0,| -768,  640,    0,    0,|  512,    0, -256,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|  640, -800,    0,    0,| -640, -400,  320,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,| -256,  320,    0,    0,|    0,  320,    0,    0,|
|    0,    0,    0,    0,|    0,    0,    0,    0,|  320, -400,    0,    0,| -320,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+
| -512,  640, -256,    0,|    0,    0,    0,    0,| 1024, -320, -256,    0,| 1024, -320,    0,    0,|
|  960,-1200,  320,    0,|  960, -800,  320,    0,|-1280,  800,    0,  400,| -640,  400,    0,    0,|
| -512,  320,    0,    0,|    0,    0, -256,    0,|    0,    0, -256,    0,|  512,  640,    0,    0,|
|    0,    0,    0,    0,| -320,    0,    0,    0,| -640,  800,    0,    0,|    0,    0,    0,    0,|
+------------------------+------------------------+------------------------+------------------------+

           下面根據變換，量化，反量化和反變換公式給出如下程式，看看是否與上述資料一致.(需要特別指出的是：JM8.6中並不是這麼實現的，但本質是相同的，最後結果也一樣.)

#include <iostream>
#include <cmath>
#define BLOCK_SIZE 4
using namespace std;

int QP = 28; // 量化引數

//原始的YUV矩陣
int orgYUV[BLOCK_SIZE][BLOCK_SIZE] =
{
	43, 216, 254, 249,
    49, 198, 193, 211,
    48, 194, 177, 171,
    46, 214, 225, 169
};

//預測值矩陣
int predYUV[BLOCK_SIZE][BLOCK_SIZE] =
{
	128, 128, 128, 128,
	128, 128, 128, 128,
	128, 128, 128, 128,
	128, 128, 128, 128
};

int D[BLOCK_SIZE][BLOCK_SIZE];  //中間矩陣
int Di[BLOCK_SIZE][BLOCK_SIZE]; //中間矩陣

int W[BLOCK_SIZE][BLOCK_SIZE];  //核矩陣
int Z[BLOCK_SIZE][BLOCK_SIZE];  //QDCT矩陣
int Wi[BLOCK_SIZE][BLOCK_SIZE]; //Wi矩陣

int Xi[BLOCK_SIZE][BLOCK_SIZE]; //解碼的殘差矩陣

//Cf矩陣
int Cf[BLOCK_SIZE][BLOCK_SIZE]=
{
    1, 1,  1, 1,
    2, 1, -1, -2,
    1,-1, -1, 1,
    1,-2,  2, -1
};

//Ci矩陣      
int Ci[BLOCK_SIZE][BLOCK_SIZE]=
{
    2,  2,  2,  1,
    2,  1, -2, -2,
    2, -1, -2,  2,
    2, -2,  2, -1
};

//MF矩陣
int MF[6][3]=
{
    13107, 5243, 8066,
    11916, 4660, 7490,
    10082, 4194, 6554,
    9362,  3647, 5825,
    8192,  3355, 5243,
    7282,  2893, 4559
};

//Qstep矩陣
int V[6][3]=
{
    10, 16, 13,
    11, 18, 14,
    13, 20, 16,
    14, 23, 18,
    16, 25, 20,
    18, 29, 23
};

//矩陣轉置
void matrixTransform(int a[][BLOCK_SIZE])
{
	int i, j, tmp;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			if(i < j)
			{
				tmp = a[i][j];
				a[i][j] = a[j][i];
				a[j][i] = tmp;
			}
		}
	}
}

//矩陣求差
void  matrixSubtract(int a[][BLOCK_SIZE],int b[][BLOCK_SIZE])
{
    int i, j;
    for(i = 0;i < BLOCK_SIZE; i++)
	{
        for(j = 0; j < BLOCK_SIZE; j++)
        {
            a[i][j] -= b[i][j];
		}
	}
}

//矩陣求積
void  matrixMultiply(int a[][BLOCK_SIZE],int b[][BLOCK_SIZE],int c[][BLOCK_SIZE])
{
	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			c[i][j] = 0;
			for(k = 0; k < BLOCK_SIZE; k++)
			{
				c[i][j] += a[i][k] * b[k][j];  
			}
		}
	}      
}

//矩陣顯示
void matrixShow(int a[][BLOCK_SIZE])
{
    int i, j;
    cout << "*****************************" << endl;
    for(i = 0; i < BLOCK_SIZE; i++)
	{
        for(j = 0; j < BLOCK_SIZE; j++)
        {
            cout << a[i][j] << "\t";
        }
		cout << endl;
	}

    cout << "*****************************" << endl << endl;
}

//求QDCT
void quantizeDCT(int W[][BLOCK_SIZE])
{
	// QP決定了qbits和f, QP和位置(i, j)共同決定了mf
	int qbits = 15 + floor(QP / 6);
	int f = (int)( pow(2.0, qbits) / 3 );
	int mf;

	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			//以下均依公式實現
			
			//(0, 0), (2, 0), (0, 2), (2, 2)  mf為 MF[QP % 6][0]
			//(1, 1), (3, 1), (1, 3), (3, 3)  mf為 MF[QP % 6][1];
			// other positions                mf為 MF[QP % 6][2];

			if((0 == i || 2 == i) && (0 == j || 2 == j))
				k = 0;
			else if((1 == i || 3 == i) && (1 == j || 3 == j))
				k = 1;
			else
				k = 2;

			mf = MF[QP % 6][k];
              
			Z[i][j] = ( abs(W[i][j]) * mf + f ) >> qbits;

			if(W[i][j] < 0)
				Z[i][j] = -Z[i][j];
		} 
		
	}
}

//求Wi(即解碼端的DCT) (Z為QDCT)
void reverseQuantize(int Z[][BLOCK_SIZE])
{     
	int t = floor(QP / 6);                
	int f = (int)pow(2, t); 
	int v;
	
	int i, j, k;
	for(i = 0; i < BLOCK_SIZE; i++)
	{
		for(j = 0; j < BLOCK_SIZE; j++)
		{
			//以下均依公式實現
			  
			if((0 == i || 2 == i) && (0 == j || 2 == j))
				k = 0;
			else if((1 == i || 3 == i) && (1 == j || 3 == j))
				k = 1;
			else
				k = 2;

			v = V[QP % 6 ][k];
			Wi[i][j] = Z[i][j] * v * f;
		}
	}
}

int main()
{
	matrixSubtract(orgYUV, predYUV);
	cout << "Residual matrix is" << endl;
    matrixShow(orgYUV);

	//此時orgYUV變為殘差矩陣
    matrixMultiply(Cf, orgYUV, D);
    matrixTransform(Cf);
    matrixMultiply(D, Cf, W);        

	//得到的W即為核
	cout << "Matrix Core（W） is" << endl;
    matrixShow(W);

	//利用核W來得到QDCT（Z）
    quantizeDCT(W);
	cout << "Matrix QDCT(Z) is" << endl;
    matrixShow(Z);
  
    //利用QDCT(Z)得到解碼端的DCT(Wi).(Wi與編碼端DCT必然不同）
    reverseQuantize(Z);
	cout << "Matrix W'(解碼端DCT) is" << endl;
    matrixShow(Wi);

    //利用Wi得到解碼的殘差矩陣Xi
    matrixMultiply(Ci, Wi, Di); 
	matrixTransform(Ci);        
    matrixMultiply(Di, Ci, Xi);
	int i,j;
    for(i = 0;i < 4; i++)
	{
        for(j = 0; j < 4; j++)
		{
			Xi[i][j] = int( Xi[i][j] / 256.0 + 0.5 );
		}
	}
	cout << "Matrix Xi(解碼端殘差) is" << endl;
    matrixShow(Xi);

	return 0;
}



           結果為：(可以看出，結果中的QDCT和解碼端的DCT都與之前的資料吻合，從而證明上面程式的實現是正確的.)

Residual matrix is
*****************************
-85     88      126     121
-79     70      65      83
-80     66      49      43
-82     86      97      41
*****************************

Matrix Core（W） is
*****************************
609     -1255   -685    -560
277     -476    113     -73
175     -159    -119    98
-14     -13     4       1
*****************************

Matrix QDCT(Z) is
*****************************
9       -12     -11     -5
3       -3      1       0
3       -1      -2      1
0       0       0       0
*****************************

Matrix W'(解碼端DCT) is
*****************************
2304    -3840   -2816   -1600
960     -1200   320     0
768     -320    -512    320
0       0       0       0
*****************************

Matrix Xi(解碼端殘差) is
*****************************
-77     88      132     110
-80     63      67      77
-82     62      48      39
-79     87      93      32
*****************************

           下面，簡要看看整數DCT變換的原理.(關於整數DCT變換公式的推倒，請參考餘兆明的《影象編碼標準H.264技術》). 

           DCT變換為:      DCT = A * X * At

           量化為:           QDCT =  floor(DCT/Qstep)

反量化為:        DCT‘  = QDCT * Qstep

反DCT為:              X’ = At * DCT‘ * A

           但在H.264中採用的是整數DCT, 在JM8.6中的實現方式也很有講究：( .* 表示矩陣對應元素相乘)

整數DCT變化為：       DCT = (Cf * X *Cft) .*Ef 

          量化為：                    QDCT = floor(DCT/Qstep)

          反量化為：                  DCT‘ = QDCT * Qstep

          整數反DCT變換為：        X’ = Ci * (DCT‘ .* Ei) *Ci

          在實現的時候，經常不直接得到DCT係數，而是將變換和量化結合在一起實現. 整數DCT變換有很多好處：沒有除法，沒有浮點數，所以高效且準確，而且減少了矩陣運算.    

           最後感慨一下：如果上面的程式用matlab來模擬，就簡單多了，matlab太適合處理矩陣問題了.

相關推薦

H.264中整數DCT變換，量化，反量化，反DCT究竟是如何實現的？(無程式碼，無真相)

        H.264中採用的是整數DCT變換，在實現的時候，該變換和量化又雜糅在一起，那麼這些錯綜複雜的關係究竟是怎樣糾纏的呢？在參考H.264樂園論壇會員cs1860wd的帖子和H.264 and MPEG-4 VIDEO COMPRESSION(第一版)這本書後，

H.264中整數DCT變換，量化，反量化，反DCT究竟是如何實現的？

原文出自：http://blog.csdn.net/stpeace/article/details/8119041 下面是關於本次學習小結： 1.之前看過H.264白皮書，沒有具體的看程式碼實現，這次邊看程式碼，邊對照白皮書，總體上能夠明白DCT之類的變換和反變換，還有QD

H.264中I幀、B幀、P幀、NALU型別，塊，巨集塊，片，影象的關係

參考：http://blog.csdn.net/ivy_reny/article/details/47144121 http://blog.csdn.net/wanggp_2007/article/details/4842839 http://blog.sina.com.cn/s/blog_

H 264中NALU RBSP SODB的關係 弄清碼流結構

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

H.264中IPCM巨集塊簡介

                       在H.264中，一個巨集塊包括16*16個畫素，I巨集塊有三種形式：       1. 16個I4x4編碼方式組成的巨集塊(為了方便，簡稱I4x4方式的巨集塊);       2. I16x16巨集塊;        3. IPCM巨集塊（特殊）       為什

h.264中的stride和plane

stride指在記憶體中每行畫素所佔的空間。如下圖所示，為了實現記憶體對齊（或者其它的什麼原因），每行畫素在記憶體中所佔的空間並不是影象的寬度。 plane一般是以luma plane、chroma plane的形式出現，其實就是luma層和chroma層，就像RGB，

H.264中I幀和IDR幀

IDR幀的作用是立刻重新整理, 使錯誤不致傳播。從IDR幀開始, 重新算一個新的序列開始編碼。而I幀不具有隨機訪問的能力，這個功能是由IDR承擔。IDR幀會導致DPB (DecodedPictureBuffer 參考幀列表——這是關鍵所在）清空，而I不會。 在IDR幀之後的所有幀都不能引用任何I

H.264中的SPS和PPS

H.264碼流第一個 NALU是 SPS（序列引數集Sequence Parameter Set） 對應H264標準文件 7.3.2.1 序列引數集的語法進行解析 H.264碼流第二個 NALU是 PPS（影象引數集Picture Parameter Se

JM、H.264中一些引數的設定和含義

一·引數說明  這一節闡述的是encoder.cfg 中的引數對編碼過程的影響  要注意的是encoder.cfg 中的引數跟input 結構體中的變數是一一對應的     StartFrame：從視訊流的第幾幀開始編碼    FramesToBeEncoded：指明瞭除去 B幀後將要被編碼的幀數  inp

用shell實現一個小指令碼，用來同來統計自己某個檔案下的程式碼，總的程式碼行數，總的註釋量，總的空行量？支援遍歷查詢，支援軟連結查詢

[[email protected] yunwei]# cat sum_code_row_version1.4.sh #!/bin/bash # File Name: sum_code_row.sh # Author: Liwqiang # mail: [email

資料庫連線的兩種實現方式（讀取配置檔案）——DBCP&C3P0；DBCP實現連線程式碼，C3P0實現連線程式碼——包含完整程式碼

兩種資料庫連線實現方式 第一種方式：DBCP DBCP使用流程 導jar包使用DBCP建立資料庫連線物件 DataSource ds=BasicDataSourceFactory.createDatasource("一個儲存連線資訊的properties集合");使

JPEG&H.264的DCT變換與量化

JPEG的DCT變換和量化的內容 參考 https://blog.csdn.net/jubincn/article/details/6882179 補充說明： JPEG中的DCT變換是浮點運算。存在的缺點： （1）由於在解碼端的浮點運算精度問題，會造成解碼後的資料失配，進而引起漂

JPEG&H.264的DCT變換與量化（自學筆記）

JPEG中的DCT變換是浮點運算。存在的缺點： （1）由於在解碼端的浮點運算精度問題，會造成解碼後的資料失配，進而引起漂移； （2）硬體實現中浮點運算的效率較低，導致編碼效率較低。 H.264的整數DCT變換和量化的內容 參考自《新一代視訊壓縮標準H26

【H.264/AVC視訊編解碼技術詳解】十五、H.264的變換編碼（二）：H.264整數變換和量化的實現

《H.264/AVC視訊編解碼技術詳解》視訊教程已經在“CSDN學院”上線，視訊中詳述了H.264的背景、標準協議和實現，並通過一個實戰工程的形式對H.264的標準進行解析和實現，歡迎觀看！ “紙上得來終覺淺，絕知此事要躬行”，只有自己按照標準文件以程式碼

H264編碼器6( H.264整數DCT公式推導及蝶形演算法分析)

來自：https://www.cnblogs.com/xkfz007/archive/2012/07/31/2616791.html   這是網上的一篇文章, 我重新讀了一下, 然後做了一些整理 1.為什麼要進行變換 空間影象資料通常是很難壓縮的：相鄰的取樣點具有很強的相關

H.264量化參數QP和量化步長Qstep

nbsp area 筆記 itl www. round 描述 比特 想要 1. 量化參數QP是量化步長Qstep的序號。對於亮度（Luma）編碼而言，量化步長Qstep共有52個值，QP取值0~51，對於色度（Chroma）編碼，Q的取值0~39。 QP取最小值

H.264從SPS中提取視頻寬高

ufs ase tel .html eva depth spl evel rip H.264有兩種封裝模式： （1）annexb模式：傳統模式，使用start code來分隔NAL， SPS和PPS是在ES流的頭部； （2）mp4模式：沒有start code，使用NALU

有n個整數，使前面各數順序向後移m個位置，最後m個數變成前面m個數。寫一函式：實現以上功能，在主函式中輸入n個數和輸出調整後的n個數。

import java.util.Scanner; public class Main {     public static void main(String[] args){         Scanner sc = new Scann

海思3518EV200 SDK中獲取和儲存H.264碼流詳解

1 /****************************************** 2 step 2: Start to get streams of each channel. 3 ************************************

輸入一個整數陣列，實現一個函式， 來調整該陣列中數字的順序使得陣列中所有的奇數位於陣列的前半部分， 所有偶數位於陣列的後半部分。

調整陣列使奇數全部都位於偶數前面。 輸入一個整數陣列，實現一個函式， 來調整該陣列中數字的順序使得陣列中所有的奇數位於陣列的前半部分， 所有偶數位於陣列的後半部分。 我用冒泡實現了這個要求: #include <stdio.h> #include <window