图像压缩编码码matlab实现——JSjpeg

function y = jpegencode(x, quality)

%jpegencode函数用来压缩图像，x为输入图像

%quality决定了截去的系数和压缩比

error(nargchk(1, 2, nargin)); %检查输入参数

if nargin < 2

quality = 1; %默认时 quality为1

end

x = double(x) - 128; %像素层次移动-128

[xm, xn] = size(x); %得到像素尺寸

t = dctmtx(8);%得到8*8DCT矩阵

%将图像分割成8*8子图像，进行DCT，然后进行量化

y = blkproc(x, [8,8], 'P1*x*P2', t, t');

m = [16 11 10 16 24 40 51 61 %JPEG量化步长矩阵

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 110 103 99]*quality;

%用量化步长矩阵m对变换矩阵进行量化

yy = blkproc(y, [8, 8], 'round(x./P1)', m);

y = im2col(yy, [8, 8], 'distinct'); %将图像块排列成向量

xb = size(y, 2); %得到列数，也就是子图像个数

order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 ... %变换系数排列次序

41 34 27 20 13 6 7 14 21 28 35 42 49 57 50 ...

43 36 29 22 15 8 16 23 30 37 44 51 58 59 52 ...

45 38 31 24 32 39 46 53 60 61 54 47 40 48 55 62 63 56 64];

%用Z形扫描方式对变换系数重新排列

y = y(order, :);

eob = max(x(:)) + 1;%创建一个块结束符号

num = numel(y) + size(y, 2);

r = zeros(num, 1);

count = 0;

%将非零元素重新排列放入r中，-26-3 eob -25 1 eob

for j = 1: xb%每次对一列（即一块）进行操作

i = max(find(y(:, j))); %找最后一个非零元素

if isempty(i) %没有非零元素

i = 0;

end

p = count + 1;

q = p + i;

r(p: q) = [y(1: i, j); eob]; %截去零并加上结束符号

count = count + i + 1;

end

r((count + 1): end) = [];%删除r的没有用的部分

r = r + 128;

%保存编码信息

y.size = uint16([xm, xn]);

y.numblocks = uint16(xb);

y.quality = uint16(quality*100);

%对r进行Huffman编码

[y.huffman, y.info] = huffencode(uint8(r));

function vector = huffdecode(zipped, info, image)

% 函数对输入矩阵vector进行Huffman解码，返回解压后的图像数据

if ~isa(zipped, 'uint8')

error('input argument must be be a uint8 vector');

end

%产生0，1序列，每位占一个字节

len = length(zipped);

string = repmat(uint8(0), 1, len.*8);

bitindex = 1:8;

for index = 1:len

string(bitindex + 8.*(index-1)) = uint8(bitget(zipped(index), bitindex));

end

string = logical(string(:)');

len = length(string);

string ((len-info.pad+1):end)=[];

len = length(string);

%开始解码

weights = 2.^(0:51);

vector = repmat(uint8(0), 1, info.length);

vectorindex = 1;

codeindex = 1;

code = 0;

for index = 1:len

code = bitset(code, codeindex, string(index));

codeindex = codeindex+1;

byte = decode(bitset(code, codeindex), info);

if byte > 0

vector(vectorindex) = byte-1;

codeindex = 1;

code = 0;

vectorindex = vectorindex + 1;

end

end

vector = reshape(vector, info.rows, info.cols);

%函数decode返回码字对应的符号

function byte = decode(code, info)

byte = info.huffcodes(code);

function [zipped, info] = huffencode(vector)

% 输入和输出都是 uint8 格式

% info 返回解码需要的结构信息

% info.pad 是添加的比特数

% info.huffcodes 是 Huffman 码字

% info.rows 是原始图像行数

% info.cols 是原始图像列数

% info.length 是原始图像数据长度

% info.maxcodelen 是最大码长

if ~isa(vector, 'uint8')

error('input argument must be a uint8 vector');

end

[m, n] = size(vector);

vector = vector(:)';

f = frequency(vector); %计算各符号出现的概率

symbols = find(f~=0);

f = f(symbols);

[f, sortindex] = sort(f); %将符号按照出现的概率大小排列

symbols = symbols(sortindex);

len = length(symbols);

symbols_index = num2cell(1:len);

codeword_tmp = cell(len, 1);

% 生成 Huffman 树，得到码字编码表

while length(f)>1

index1 = symbols_index{1};

index2 = symbols_index{2};

codeword_tmp(index1) = addnode(codeword_tmp(index1), uint8(0));

codeword_tmp(index2) = addnode(codeword_tmp(index2), uint8(1));

f = [sum(f(1:2)),f(3:end)];

symbols_index = [{[index1, index2]},symbols_index(3:end)];

[f, sortindex] = sort(f);

symbols_index = symbols_index(sortindex);

end

codeword = cell(256, 1);

codeword(symbols) = codeword_tmp;

len = 0;

for index = 1:length(vector) %得到整个图像所有比特数

len = len + length(codeword{double(vector(index))+1});

end

string = repmat(uint8(0), 1, len);

pointer = 1;

for index = 1:length(vector) %对输入图像进行编码

code = codeword{double(vector(index))+1};

len = length(code);

string(pointer + (0:len-1))=code;

pointer = pointer + len;

end

len = length(string);

pad = 8-mod(len, 8);

if pad > 0

string = [string uint8(zeros(1, pad))];

end

codeword = codeword(symbols);

codelen = zeros(size(codeword));

weights = 2.^(0:23);

maxcodelen = 0;

for index = 1:length(codeword)

len = length(codeword{index});

if len > maxcodelen;

maxcodelen = len;

end

if len > 0

code = sum(weights(codeword{index} == 1));

code = bitset(code, len + 1);

codeword{index} = code;

codelen(index) = len;

end

end

codeword = [codeword{:}];

%计算压缩的向量

cols = length(string)/8;

string = reshape(string, 8, cols);

weights = 2.^(0: 7);

zipped = uint8(weights * double(string));

%码表存储到一个希疏矩阵

huffcodes = sparse(1, 1);

for index = 1:nnz(codeword) % length(codeword) %numel(codeword)

huffcodes(codeword(index), 1) = symbols(index);

end

%填写解码时所需的结构信息

info.pad = pad;

info.huffcodes = huffcodes;

info.ratio = cols./length(vector);

info.length = length(vector);

info.maxcodelen = maxcodelen;

info.rows = m;

info.cols = n;

%函数addnode添加节点

function codeword_new = addnode(codeword_old, item)

codeword_new = cell(size(codeword_old));

for index = 1:length(codeword_old)

codeword_new{index} = [item codeword_old{index}];

end

%函数frequency计算各符号出现的概率

function f = frequency(vector)

if ~isa(vector, 'uint8')

error('input argument must be a uint8 vector');

end

f = repmat(0, 1, 256);

len = length(vector);

for index = 0:255

f(index+1) = sum(vector == uint8(index));

end

f = f./len; %归一化

function x = jpegdecode(y)

%jpegdecode函数，jpegencode的解码程序

error(nargchk(1, 1, nargin)); %检查输入参数

m = [16 11 10 16 24 40 51 61 %JPEG量化步长矩阵

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 110 103 99];

order = [1 9 2 3 10 17 25 18 11 4 5 12 19 26 33 ... %变换系数排列次序

41 34 27 20 13 6 7 14 21 28 35 42 49 57 50 ...

43 36 29 22 15 8 16 23 30 37 44 51 58 59 52 ...

45 38 31 24 32 39 46 53 60 61 54 47 40 48 55 62 63 56 64];

rev = order;%计算逆序

for k = 1:length(order)

rev(k) = find(order == k);

end

% ff = max(rev(:)+1;

m = double(y.quality)/100*m;

xb = double(y.numblocks);%得到图像块数

sz = double(y.size);

xn = sz(1);

xm = sz(2);

x = huffdecode(y.huffman, y.info); %huffman1解码

x = double(x) - 128;

eob = max(x(:));

z = zeros(64, xb);

k = 1;

for j = 1: xb

for i = 1: 64

if x(k) == eob

k = k + 1;

break;

else

z(i, j) = x(k);

k = k + 1;

end

end

end

z = z(rev, :); %恢复次序

x = col2im(z, [8, 8], [xm, xn], 'distinct'); %重新排列成图像

x = blkproc(x, [8, 8], 'x.*P1', m); %逆量化

t = dctmtx(8);

x = blkproc(x, [8, 8], 'P1*x*P2', t', t);%DCT逆变换

x = uint8(x + 128);%进行位移