xil_ycrcb2rgb_fi_model.m

基于FPGA的YUV转换RGB的色度空间转换

function [R, G, B] = Xil_YCrCb2RGB_fi_model(Y, Cr, Cb,      ...
                           IWIDTH, CWIDTH, MWIDTH, OWIDTH,  ...
                           ACOEF, BCOEF, CCOEF, DCOEF,      ...
                           RGBMAX, RGBMIN,                  ... 
                           YOFFSET, COFFSET );
% R = (Y - Yoffset) + ACoeff' * (Cr - Coffset)                         
% G = (Y - Yoffset) + BCoeff' * (Cr - Coffset) + CCoeff' * (Cb - Coffset) 
% B = (Y - Yoffset) + DCoeff' * (Cb - Coffset)     
%
% R = Y + ACoeff' * Cr - Roffset                        
% G = Y + BCoeff' * Cr - CCoeff' * Cb + Goffset 
% B = Y + DCoeff' * Cb - Boffset
%
% In order to complement RGB2YCrCb:
%
% ACoeff' = 1/CCOEFF
% BCoeff' = ACOEFF/CCOEFF * (1-ACOEFF-BCOEFF)
% CCoeff' = BCOEFF/DCOEFF * (1-ACOEFF-BCOEFF)
% DCoeff' = 1/DCOEFF
% Roffset = Yoffset + Acoeff' * Coffset 
% Goffset = Yoffset + (Bcoeff' + Ccoeff') * Coffset 
% Boffset = Yoffset + Dcoeff' * Coffset 
%
    if  (nargin < 4 ) IWIDTH  = 8; end      
    if  (nargin < 5 ) CWIDTH  = 12; end   % Coefficients are signed
    if  (nargin < 6 ) MWIDTH  = 20; end   % IWIDTH+CWIDTH+1; 
    if  (nargin < 7 ) OWIDTH  = 8; end
    if  (nargin < 8 ) ACOEF   = 0.2988; end  %  Inherit parameters from the   
    if  (nargin < 9 ) BCOEF   = 0.1138; end  %  RGB2YCrCb encoder!!!!      
    if  (nargin < 10) CCOEF   = 0.7131; end  % 0.5/(1-ACOEF)  
    if  (nargin < 11) DCOEF   = 0.5642; end  % 0.5/(1-BCOEF) 
    if  (nargin < 12) RGBMAX  = pow2(OWIDTH)-1; end
    if  (nargin < 13) RGBMIN  = 0 ; end
    if  (nargin < 14) YOFFSET = 0 ; end
    if  (nargin < 15) COFFSET = pow2(IWIDTH-1); end

    scale = pow2(CWIDTH-2);
    AC = round(scale * (1/CCOEF));
    BC = round(-scale * (ACOEF/CCOEF*1/(1-ACOEF-BCOEF)));
    CC = round(-scale * (BCOEF/DCOEF*1/(1-ACOEF-BCOEF)));
    DC = round(scale * (1/DCOEF));
    
    % Assuming signals are OWIDTH+1 bits wide after the offset compensating
    % rounders / adders:
    rounding_const = pow2(MWIDTH - 2 - OWIDTH); %  +0.5 turns truncation to biased rounding 
    scale_m = pow2(IWIDTH+CWIDTH-MWIDTH);
    ROFFSET = round(rounding_const - (AC * COFFSET      + YOFFSET)/scale_m); 
    GOFFSET = round(rounding_const - ((BC+CC) * COFFSET + YOFFSET)/scale_m);
    BOFFSET = round(rounding_const - (DC * COFFSET      + YOFFSET)/scale_m);

    q_i=quantizer([IWIDTH, 0], 'ufix', 'round', 'wrap');
    
    y  =  quantize( q_i, Y); % unsigned fixpoint quantized version of input channels
    cr =  quantize( q_i, Cr);
    cb =  quantize( q_i, Cb);
    
    Acoef_by_Cr = cr*AC; 
    Bcoef_by_Cr = cr*BC;
    Ccoef_by_Cb = cb*CC;
    Dcoef_by_Cb = cb*DC;

    q_m=quantizer([MWIDTH, 0],  'floor', 'wrap'); % Retaining top MWIDTH bits
    Acoef_by_Cr_rnd = quantize( q_m, Acoef_by_Cr/scale_m + ROFFSET); 
    Ccoef_by_Cb_rnd = quantize( q_m, Ccoef_by_Cb/scale_m + GOFFSET);
    Dcoef_by_Cb_rnd = quantize( q_m, Dcoef_by_Cb/scale_m + BOFFSET);
    Bcoef_by_Cr_rnd = quantize( q_m, Bcoef_by_Cr/scale_m + Ccoef_by_Cb_rnd);
    
    q_r=quantizer([OWIDTH+1, 0],  'floor', 'wrap');
    scale = pow2(CWIDTH-2)/scale_m; % binary point position in Coeffs
    R_raw = quantize( q_r, Acoef_by_Cr_rnd/scale);
    G_raw = quantize( q_r, Bcoef_by_Cr_rnd/scale);
    B_raw = quantize( q_r, Dcoef_by_Cb_rnd/scale);
   
    Y_padded = quantize( q_r, y);
    R_int = Y_padded + R_raw;
    G_int = Y_padded + G_raw;
    B_int = Y_padded + B_raw;
    
    % Do the clipping
    R_int_postmax = R_int; wh = find( R_int_postmax > RGBMAX); R_int_postmax(wh) = RGBMAX;
    G_int_postmax = G_int; wh = find( G_int_postmax > RGBMAX); G_int_postmax(wh) = RGBMAX;
    B_int_postmax = B_int; wh = find( B_int_postmax > RGBMAX); B_int_postmax(wh) = RGBMAX;
    
    % Do the clamping
    R_int_postmin = R_int_postmax; wh = find( R_int_postmin < RGBMIN); R_int_postmin(wh) = RGBMIN;
    G_int_postmin = G_int_postmax; wh = find( G_int_postmin < RGBMIN); G_int_postmin(wh) = RGBMIN;
    B_int_postmin = B_int_postmax; wh = find( B_int_postmin < RGBMIN); B_int_postmin(wh) = RGBMIN;

    q_o=quantizer([OWIDTH+1, 0],  'floor', 'wrap');
    
    R= quantize( q_o, R_int_postmin);
    G= quantize( q_o, G_int_postmin);
    B= quantize( q_o, B_int_postmin);    
end