Giới thiệu dự án

Trong kỷ nguyên bùng nổ dữ liệu số và truyền thông đa phương tiện độ phân giải cao (4K/8K, ảnh y tế CT/MRI, viễn thám vệ tinh), lưu trữ và truyền tải dữ liệu ảnh đang đối mặt với bài toán nghẽn băng thông và chi phí lưu trữ hạ tầng tăng vọt. Theo thống kê từ các tổ chức y tế và viễn thông quốc tế, dữ liệu chẩn đoán hình ảnh và truyền hình thời gian thực chiếm tới hơn 60% lưu lượng mạng chuyên dụng, trong đó yêu cầu bảo toàn 100% độ chính xác của từng điểm ảnh (pixel) là bắt buộc. Việc suy hao dù chỉ một mức xám nhỏ trong ảnh y tế hoặc bản đồ địa hình có thể dẫn đến sai lệch nghiêm trọng trong chẩn đoán và phân tích.

Các phương pháp nén dữ liệu truyền thống bộc lộ rõ những hạn chế:

  • Phương pháp nén mất mát (Lossy Compression) như JPEG (Discrete Cosine Transform - DCT), Wavelet transform hay JPEG 2000 mang lại tỷ lệ nén cao nhưng loại bỏ thông tin tần số cao, làm thay đổi cấu trúc pixel gốc, không thể áp dụng cho dữ liệu y tế, bản vẽ kỹ thuật hay ảnh vệ tinh.
  • Phương pháp nén không mất mát (Lossless Compression) tĩnh như Static Huffman Coding hoặc Shannon-Fano Coding yêu cầu thuật toán phải duyệt qua toàn bộ dữ liệu ảnh ở lượt thứ nhất (Pass 1) để xây dựng bảng phân phối xác suất và tạo cây nhị phân, sau đó mới tiến hành mã hóa ở lượt thứ hai (Pass 2). Hơn nữa, toàn bộ bảng mã/cây nhị phân (Header) phải được đính kèm vào file nén để phục vụ giải nén, gây lãng phí dung lượng truyền tải và tạo độ trễ lớn (latency), hoàn toàn không khả thi cho các hệ thống truyền phát trực tiếp (real-time streaming).
  • Phương pháp từ điển như Lempel-Ziv-Welch (LZW) tuy có khả năng thích ứng động nhưng đòi hỏi bộ nhớ từ điển cực lớn, suy giảm hiệu năng rõ rệt khi xử lý dữ liệu ảnh phức tạp với các chuỗi pixel không lặp lại tuần hoàn.

Khóa luận tốt nghiệp chuyên ngành Kỹ thuật Máy tính tại Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM, thực hiện bởi sinh viên Nguyễn Thị Cẩm Hướng và Trần Thạch Tuấn Phong dưới sự hướng dẫn của TS. Lâm Đức Khải, đã giải quyết triệt để bài toán trên thông qua đề tài: "Hiện thực hóa kỹ thuật nén ảnh Dynamic Huffman Coding trên phần cứng" (Implementation of lossless image compression by Dynamic Huffman Coding algorithm).

+-----------------------------------------------------------------------------------------+
|                                    HỆ THỐNG NÉN ẢNH                                     |
|                                                                                         |
|  [ Ảnh gốc 8-bit ] ---> ( Tiền xử lý Python ) ---> [ Dữ liệu Hexadecimal ]              |
|                                                           |                             |
|                                                           v                             |
|                                       +---------------------------------------+         |
|                                       |       COMPRESSION CORE (FPGA)         |         |
|                                       |  - Khối Linear Prediction (400 MHz)   |         |
|                                       |  - Khối Dynamic Huffman Tree Engine   |         |
|                                       |    * Tree Register File (32 nodes)    |         |
|                                       |    * Run Modify, Swap Node, Check...  |         |
|                                       +---------------------------------------+         |
|                                                           |                             |
|                                                           v                             |
|  [ Ảnh tái tạo SSIM=1.0 ] <--- ( Hậu xử lý Python ) <--- [ Giải nén C++ ] <--- [ Bitstream ]
+-----------------------------------------------------------------------------------------+

Mục tiêu cụ thể của đề tài

  1. Thiết kế và tối ưu thuật toán Dynamic Huffman Coding kết hợp Dự đoán tuyến tính (Linear Prediction): Xây dựng giải thuật nén ảnh 1-pass (nén một lượt thời gian thực), không cần lưu trữ hay truyền kèm bảng mã nhị phân/cây Huffman trong gói tin nén.
  2. Tối ưu hóa không gian trạng thái phần cứng (Hardware State Optimization): Chuyển đổi dữ liệu mức xám pixel 8-bit sang định dạng Hexadecimal (4-bit symbol), giảm số lượng node của cây Dynamic Huffman từ 256 node xuống còn 32 node (16 symbol node + 16 NYT node), tiết kiệm tài nguyên logic trên chip.
  3. Hiện thực kiến trúc phần cứng chuyên dụng bằng Verilog HDL: Thiết kế khối xử lý Compression Core dạng Pipeline hoàn chỉnh, tổng hợp và mô phỏng trên nền tảng Xilinx Vivado.
  4. Đánh giá hiệu năng thực nghiệm toàn diện: Kiểm chứng trên các tập dữ liệu ảnh tiêu chuẩn (Waterloo benchmark dataset, Kaggle CT scan dataset) với kích thước $256 \times 256$ và $512 \times 512$, đảm bảo hệ số tương đồng cấu trúc SSIM đạt tuyệt đối bằng 1.0 (Lossless 100%).

Phạm vi và giới hạn hệ thống

  • Đầu vào xử lý: Ảnh mức xám (Grayscale) 8-bit với các định dạng phổ biến (.pgm, .png, .tif), kích thước linh hoạt ($256 \times 256$, $512 \times 512$).
  • Môi trường triển khai: Mô hình hóa và xác thực thuật toán trên C++/Python (Visual Studio Code); thiết kế RTL, tổng hợp logic và mô phỏng dạng sóng trên Xilinx Vivado / ModelSim.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Phương pháp Loại nén Cơ chế hoạt động Tỷ lệ nén (CR) Header Overhead Khả năng Streaming Real-time Tiêu tốn tài nguyên phần cứng
JPEG (DCT) Lossy Biến đổi cosine rời rạc, lượng tử hóa 10.0 - 20.0 Thấp Khá Cao (DSP blocks, multipliers)
Static Huffman [15] Lossless Thống kê xác suất 2-pass, cây nhị phân tĩnh 1.5 - 2.2 Rất cao (Phải gửi cả bảng mã) Không khả thi (Phải duyệt xong ảnh mới nén) Trung bình (Bảng tra ROM/RAM)
Adaptive Huffman + LZW [14] Lossless Kết hợp từ điển LZW và cây Huffman động 2.0 - 2.8 Không cần Header Khá (Trễ do cập nhật từ điển) Rất cao (Bộ nhớ CAM/RAM lớn cho Dictionary)
Kiến trúc đề xuất (Linear + Dyn. Huffman) Lossless Dự đoán sai số tuyến tính + Cây động 4-bit Hex 3.467 0% (Không cần gửi bảng mã) Tối ưu tuyệt đối (1-pass Streaming) Rất thấp (Chỉ 32 thanh ghi cây + logic FSM)

Phân tích yêu cầu theo mô hình MoSCoW

  • Must have: Kiến trúc Pipeline nén không mất mát dữ liệu (SSIM = 1.0); tự động cập nhật cây nhị phân theo thuật toán cây thích nghi (Adaptive Tree Update); khối dự đoán sai số Linear Prediction tích hợp; thiết kế RTL Verilog tổng hợp được trên FPGA/ASIC.
  • Should have: Tối ưu hóa biểu diễn dữ liệu đầu vào mức 4-bit (Nibble) để giới hạn số node thanh ghi ở mức 32; tần số hoạt động trên 100 MHz.
  • Could have: Khả năng mở rộng pipeline xử lý song song nhiều kênh màu RGB.
  • Won't have (in this phase): Khối giải nén tích hợp trực tiếp trên cùng chip phần cứng (giải nén được thực thi qua phần mềm C++ để tối ưu hóa diện tích cho Core nén).

Thiết kế hệ thống

Kiến trúc phần cứng tổng thể của khối Compression Core bao gồm 7 module chức năng được ghép nối chặt chẽ qua luồng điều khiển pipeline:

graph TD
    A["Pixel In (8-bit)"] --> B["Linear Prediction Module (400 MHz)"]
    B -->|"Symbol Error (4-bit) + Sign"| C["Check Memory / Check Tree (400 MHz)"]
    C -->|"Node Exists / NYT Position"| D["Output Block (400 MHz)"]
    D -->|"Entropy Code Bitstream"| OUT["Compressed Bitstream Out"]
    C -->|"Symbol Mới Chưa Có"| E["Insert Register / NYT Register"]
    E --> F["Tree Register File (32x41-bit)"]
    F <--> G["Run Modify Module (400 MHz)"]
    G <--> H["Check Parent Module (333 MHz)"]
    G <--> I["Swap Node Module (333 MHz)"]
    I --> F

Công nghệ và công cụ sử dụng

  • Ngôn ngữ mô tả phần cứng: Verilog HDL (IEEE 1364-2001 Standard).
  • Phần mềm EDA & Tổng hợp: Xilinx Vivado Design Suite 2020.2, Mentor Graphics ModelSim SE.
  • Ngôn ngữ xử lý dữ liệu và kiểm thử phần mềm: C++ (C++17 standard trên GCC/Clang), Python 3.9 (thư viện OpenCV, NumPy, Matplotlib).
  • Tập dữ liệu chuẩn: Waterloo Image Compression Benchmark, Kaggle Medical CT Scan Dataset.

Cấu trúc thanh ghi cây nhị phân (Tree Register File)

Để lưu trữ và cập nhật trạng thái cây Dynamic Huffman động với 32 node, mỗi thanh ghi trong Tree Register File được thiết kế có độ rộng 41-bit với định dạng trường chuyên biệt:

+----------------+----------+--------------------+-------------------+--------------------+------------------+---------------+
|  Order[40:36]  | Char[4]  |   Weight[35:20]    | AddrRight[19:15]  |  AddrLeft[14:10]   | AddrParent[9:5]  |  Input[3:0]   |
|     5 bits     |  1 bit   |      16 bits       |      5 bits       |       5 bits       |      5 bits      |    4 bits     |
+----------------+----------+--------------------+-------------------+--------------------+------------------+---------------+
  • Input[3:0]: Giá trị symbol 4-bit của node lá (chứa dữ liệu mức Hex: 0x0 đến 0xF).
  • AddrParent[9:5]: Địa chỉ 5-bit trỏ tới node cha trong cây.
  • AddrLeft[14:10] & AddrRight[19:15]: Địa chỉ 5-bit trỏ tới node con bên trái và bên phải.
  • Weight[35:20]: Trọng số 16-bit thể hiện tần suất xuất hiện của symbol/nhánh.
  • Char[4]: Cờ 1-bit phân biệt giữa Node mang dữ liệu (Symbol Node) và Node điều hướng NYT (Not Yet Transferred).
  • Order[40:36]: Thứ tự/Độ sâu (Depth) của node trong cấu trúc cây.

Phương pháp luận phát triển (Methodology)

Dự án áp dụng quy trình thiết kế phần cứng chuẩn công nghiệp dạng V-Model kết hợp các chu kỳ lặp Agile:

  1. Giai đoạn 1 (Thuật toán & Phần mềm): Hiện thực hóa mô hình toán học giải thuật Dynamic Huffman và Linear Prediction bằng C++/Python. Đo đạc tỷ lệ nén CR, chỉ số cấu trúc SSIM trên 100+ ảnh mẫu.
  2. Giai đoạn 2 (Kiến trúc RTL & Phân khối): Phân rã kiến trúc thành 7 khối chức năng độc lập, đặc tả giao tiếp tín hiệu (Signal Interface Pinout) và bảng trạng thái máy FSM.
  3. Giai đoạn 3 (Hiện thực Verilog & Mô phỏng chức năng): Viết mã Verilog HDL cho từng khối, xây dựng testbench độc lập (Unit Testbench) trên ModelSim/Vivado để xác minh đúng dạng sóng (Waveform Verification).
  4. Giai đoạn 4 (Tích hợp Top-level & Đo đạc tài nguyên): Ghép nối module Compression Core, tiến hành tổng hợp RTL Synthesis, đánh giá độ trễ đường truyền tới hạn (Critical Path Timing) và tính toán tần số đồng hồ cực đại ($F_{max}$).
  5. Giai đoạn 5 (Đối soát Bitstream & Tái tạo ảnh): Lấy luỗi bit nhị phân sinh ra từ phần cứng nạp vào giải thuật giải nén C++, tái tạo ảnh bằng Python và so sánh từng pixel với ảnh gốc ($SSIM = 1.0$).

Implementation và kết quả

Chi tiết giải thuật và mã nguồn phần cứng

1. Khối Dự đoán Tuyến tính (Linear Prediction)

Khối Linear Prediction loại bỏ độ dư thừa không gian giữa các điểm ảnh lân cận bằng cách tính toán giá trị dự đoán $P(i, j)$ và sai số $E(i, j)$:

$$\begin{aligned} P(i, j) &= \frac{I(i-1, j) + I(i, j-1)}{2} \ P_{\text{round}}(i, j) &= \text{round}(P(i, j)) \ E(i, j) &= I(i, j) - P_{\text{round}}(i, j) \end{aligned}$$

Sau đó, sai số $E(i, j)$ được chuyển đổi thành mã 4-bit symbol và 1-bit dấu (pixel_sign).

// Trích xuất cấu trúc RTL khối Linear Prediction (Pipeline Stage)
module linear_prediction (
    input  wire        clk,
    input  wire        reset_n,
    input  wire [7:0]  pixel,
    input  wire [15:0] position_in,
    input  wire        hstart,
    input  wire        hend,
    output reg  [3:0]  pixel_out,
    output reg         pixel_sign,
    output reg         valid_out
);
    reg [7:0] prev_pixel_h;
    reg [7:0] prev_pixel_v;
    wire [8:0] sum_neighbors;
    wire [7:0] predicted_val;
    wire signed [8:0] error_val;

    assign sum_neighbors = prev_pixel_h + prev_pixel_v;
    assign predicted_val = sum_neighbors[8:1]; // Chia 2 bang phep dich phai
    assign error_val     = $signed({1'b0, pixel}) - $signed({1'b0, predicted_val});

    always @(posedge clk or negedge reset_n) begin
        if (!reset_n) begin
            pixel_out   <= 4'd0;
            pixel_sign  <= 1'b0;
            valid_out   <= 1'b0;
            prev_pixel_h <= 8'd0;
        end else begin
            pixel_sign  <= error_val[8]; // Bit dau
            pixel_out   <= error_val[8] ? (~error_val[3:0] + 1'b1) : error_val[3:0]; // Lay gia tri tuyet doi 4-bit
            prev_pixel_h <= pixel;
            valid_out   <= 1'b1;
        end
    end
endmodule

2. Thuật toán Cập nhật Cây động (Dynamic Huffman Tree Algorithm)

Quá trình xử lý một symbol mới xuất hiện hoặc symbol đã tồn tại được thực hiện tuần tự qua máy trạng thái FSM:

  • Bước 1 (Check Symbol): Kiểm tra symbol[3:0] đã tồn tại trong Tree Register File chưa.
  • Bước 2 (Xuất mã Entropy):
    • Nếu là symbol mới: Xuất chuỗi đường đi tới node NYT (Not Yet Transferred) hiện tại, tiếp theo là giá trị nhị phân 4-bit của symbol. Thêm symbol mới vào vị trí NYT, tạo node NYT mới.
    • Nếu symbol đã tồn tại: Xuất chuỗi đường đi từ gốc (Root) đến node chứa symbol đó.
  • Bước 3 (Cập nhật trọng số & Hoán vị node - Run Modify & Swap Node): Tăng trọng số Weight của node thêm 1. Kiểm tra xem có node nào khác trong cây có cùng trọng số cũ nhưng có số thứ tự Order lớn hơn và không phải là node cha (Check Parent). Nếu thỏa mãn, kích hoạt khối Swap Node để hoán đổi vị trí hai node nhằm duy trì đặc tính cây Huffman tối ưu (Sibling Property). Lặp lại quá trình đệ quy lên node Root.
// Thuat toan cap nhat cay Dynamic Huffman mo phong tren C++
void update_dynamic_tree(Node*& root, Node* curr_node) {
    while (curr_node != nullptr) {
        // Tim node co cung weight lon nhat trong cung cap do ma khong phai node cha
        Node* highest_node = find_highest_node_same_weight(root, curr_node);
        if (highest_node != nullptr && highest_node != curr_node && highest_node != curr_node->parent) {
            swap_node_positions(curr_node, highest_node);
        }
        curr_node->weight += 1;
        curr_node = curr_node->parent; // Di chuyen len node cha de cap nhat de quy
    }
}

Kết quả đo đạc và hiệu năng phần cứng

Bảng thông số tần số và chu kỳ hoạt động từng khối phần cứng

Tên Module Chu kỳ tối thiểu ($T_{min}$) Tần số tối đa ($F_{max}$) Chức năng chính
Linear Prediction 2.5 ns 400.00 MHz Dự đoán sai số pixel lân cận, sinh 4-bit symbol
Check Tree 2.5 ns 400.00 MHz Dò tìm vị trí symbol trong cây 32 thanh ghi
Output Block 2.5 ns 400.00 MHz Trích xuất bitstream đường đi cây Huffman
Run Modify Block 2.5 ns 400.00 MHz Kiểm tra điều kiện cập nhật trọng số cây
Check Parent 3.0 ns 333.33 MHz Ngăn chặn hoán vị sai nhánh cha con
Swap Node 3.0 ns 333.33 MHz Hoán đổi vị trí 2 thanh ghi trong Tree File
Tree Register File 3.0 ns 333.33 MHz Mảng 32 thanh ghi 41-bit lưu trữ cây động
Toàn hệ thống (Compression Core Top) 8.0 ns 125.00 MHz Điều phối pipeline toàn hệ thống nén ảnh

Kết quả nén thực tế trên các tập ảnh Benchmark

Tên ảnh mẫu Kích thước Định dạng Dung lượng gốc (Bytes) Dung lượng sau nén (Bytes) Tỷ lệ nén (CR) Chỉ số SSIM
Lena $512 \times 512$ .pgm 262,144 74,472 3.520 1.0000
Baboon $512 \times 512$ .pgm 262,144 98,550 2.660 1.0000
Peppers $512 \times 512$ .pgm 262,144 76,875 3.410 1.0000
CT Scan Brain $256 \times 256$ .png 65,536 16,847 3.890 1.0000
CT Scan Chest $256 \times 256$ .tif 65,536 17,014 3.852 1.0000
Trung bình toàn bộ dataset -- -- -- -- 3.467 1.0000

Đổi mới và đóng góp

Các đột phá kỹ thuật nổi bật

  1. Cơ chế phân rã Nibble Hexadecimal (4-bit Decomposition):

    • Hạn chế trước đây: Xử lý trực tiếp pixel mức xám 8-bit đòi hỏi cây Dynamic Huffman phải quản lý $256$ symbol node và $256$ NYT node (tổng cộng $512$ node). Điều này dẫn tới việc tiêu tốn hàng nghìn thanh ghi, logic giải mã phức tạp, và độ trễ duyệt cây cực lớn làm tụt giảm tần số $F_{max}$.
    • Cải tiến của đề tài: Chuyển đổi giá trị sai số sang 2 ký tự Hex (mỗi ký tự 4-bit: $0 \rightarrow F$). Cây Huffman động chỉ cần quản lý tối đa 16 symbol nodes + 16 NYT nodes = 32 node registers. Giải pháp này giúp cắt giảm 87.5% số lượng thanh ghi lưu trữ cây, đồng thời rút ngắn độ sâu tối đa của cây nhị phân, cho phép khối Check Tree và Output Block đạt tần số thực thi lên tới 400 MHz.

  2. Kiến trúc phần cứng Streaming 1-Pass không cần Header:

    • Khác biệt hoàn toàn với Static Huffman, kiến trúc đề xuất xây dựng và đồng bộ cây động liên tục theo từng luồng pixel. Phía nhận (bộ giải nén) tự động cập nhật cây nhị phân song song với phía phát chỉ dựa trên chuỗi bitstream nhận được. Do đó, kích thước file nén tiết kiệm 100% phần dung lượng lưu trữ bảng mã Header.

So sánh với các công trình nghiên cứu liên quan

Tiêu chí so sánh Static Huffman [15] Adaptive Huffman + LZW [14] PNG Standard (LZ77 + Huffman) [18] Kiến trúc đề xuất (UIT - 2023)
Tỷ lệ nén trung bình (CR) 2.15 2.84 2.45 3.467 (+22% đến +61%)
Tần số xung nhịp ($F_{max}$) ~80 MHz ~95 MHz 100 MHz 125 MHz (Core con đạt 400 MHz)
Độ trễ xử lý (Latency) Rất cao (2-pass) Cao (Cập nhật từ điển) Cao (Dò chuỗi LZ77) Cực thấp (1-pass Streaming)
Dung lượng Header kèm theo Lớn (Toàn bộ cây mã) Nhỏ Trung bình 0 Byte (Không cần Header)
Tài nguyên bộ nhớ phần cứng Lưu trữ Buffer toàn khung CAM/RAM lớn cho Dictionary Sliding Window Buffer (32KB) Chỉ 32 thanh ghi 41-bit

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng thực tế (Real-world Use Cases)

  1. Hệ thống chẩn đoán hình ảnh y tế từ xa (Telemedicine & Medical Imaging):
    • Các thiết bị chụp cắt lớp vi tính (CT), cộng hưởng từ (MRI) và X-quang kỹ thuật số sản sinh hàng gigabyte dữ liệu mỗi ngày. Việc tích hợp IP Core nén Dynamic Huffman vào bo mạch xử lý hình ảnh tại đầu dò máy chụp cho phép nén dữ liệu tức thời với $CR \approx 3.89$, bảo toàn $100%$ độ nguyên vẹn chẩn đoán ($SSIM = 1.0$) và truyền tải mượt mà qua mạng băng thông hạn chế đến các chuyên gia tuyến trên.
  2. Hệ thống viễn thám và thiết bị bay không người lái (UAV/Satellite Imaging):
    • Thiết bị vệ tinh quan sát trái đất và drone chuyên dụng có dung lượng bộ nhớ onboard và công suất phát sóng vô tuyến rất giới hạn. Kiến trúc phần cứng nhỏ gọn (32 thanh ghi cây) tiêu thụ năng lượng thấp, hoạt động ở tần số 125 MHz, giúp nén trực tiếp dữ liệu cảm biến ảnh trước khi ghi vào flash memory hoặc truyền về trạm mặt đất.
+-----------------------------------------------------------------------------------------------+
|                       LỘ TRÌNH TRIỂN KHAI VÀ TÍCH HỢP HỆ THỐNG (ROADMAP)                     |
|                                                                                               |
|   [ Giai đoạn 1: Q1 ]        [ Giai đoạn 2: Q2 ]        [ Giai đoạn 3: Q3 ]        [ Giai đoạn 4: Q4 ]
|    Đóng gói IP Core           Tích hợp chuẩn AXI-4       Mở rộng RGB & H.264        Thương mại hóa    
|   * Đóng gói RTL Verilog     * Ghép nối DMA Master      * Ghép 3 lõi nén           * Kiểm định chuẩn  
|   * Tạo tài liệu AXI Stream  * Kiểm thử SoC Zynq-7000   * Nén video stream          y tế DICOM/PACS   
+-----------------------------------------------------------------------------------------------+

Phân tích hiệu quả kinh tế và ROI (Cost-Benefit Analysis)

  • Tiết kiệm chi phí lưu trữ đám mây / máy chủ y tế: Với tỷ lệ nén $CR = 3.467$, một bệnh viện lưu trữ trung bình 50 TB dữ liệu ảnh y tế mỗi năm có thể giảm dung lượng lưu trữ xuống chỉ còn ~14.4 TB, giúp tiết kiệm hơn 70% chi phí lưu trữ hạ tầng và băng thông truyền dẫn.
  • Tối ưu hóa chi phí sản xuất chip phần cứng: Nhờ giảm thiểu số lượng thanh ghi cây từ 256 xuống 32, diện tích chiếm dụng silicon (Area footprint) trên FPGA/ASIC giảm hơn 65%, cho phép nhà sản xuất tích hợp Core vào các dòng chip FPGA giá rẻ (như Xilinx Artix-7, Spartan-7) thay vì phải sử dụng các dòng Kintex/Virtex đắt đỏ.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Xử lý tuần tự chuỗi bitstream: Do đặc tính phụ thuộc dữ liệu của cây Huffman động (mỗi node cập nhật phụ thuộc vào symbol ngay trước đó), việc phân tách xử lý song song đa luồng (multi-threading parallel execution) trên cùng một cây đơn gặp nhiều rào cản về tranh chấp truy xuất thanh ghi (Race Condition).
  • Khởi đầu nén dữ liệu (Warm-up Phase): Ở những pixel đầu tiên của bức ảnh, khi cây nhị phân chưa tích lũy đủ thông tin xác suất, kích thước mã nhị phân sinh ra cho các node NYT ban đầu có thể hơi dài trước khi cây đạt trạng thái ổn định tối ưu.

Hướng phát triển trong tương lai

  1. Phát triển kiến trúc Multi-Core nén song song: Phân chia bức ảnh thành các khối độc lập (Block-based Partitioning, ví dụ $64 \times 64$ pixels) và phân bổ xử lý trên nhiều lõi Compression Core song song, nâng tốc độ khung hình lên mức 4K@60fps.
  2. Mở rộng hỗ trợ ảnh màu đa kênh (RGB/YUV): Bổ sung module chuyển đổi không gian màu và ghép nối 3 bộ nén độc lập cho từng kênh màu.
  3. Hiện thực hóa khối giải nén phần cứng (Hardware Decompression Core): Tích hợp hoàn chỉnh cả bộ mã hóa và giải mã (Codec) trên cùng một vi mạch SoC với giao tiếp chuẩn AXI4-Stream.

Đối tượng hưởng lợi

  • Sinh viên & Học viên ngành Kỹ thuật Máy tính / Điện tử Viễn thông: Nguồn tài liệu tham khảo thực tế về phương pháp luận thiết kế hệ thống số, kỹ thuật tối ưu hóa cây dữ liệu phức tạp trên phần cứng, và quy trình mô phỏng RTL trên Xilinx Vivado.
  • Kỹ sư thiết kế vi mạch & Lập trình FPGA (RTL/FPGA Engineers): Nắm bắt giải pháp phân rã dữ liệu 4-bit (Nibble decomposition) độc đáo để giải quyết bài toán nghẽn diện tích và thời gian đóng gói thanh ghi trong các thuật toán nén entropy.
  • Doanh nghiệp phát triển thiết bị Y tế & IoT Chuyên dụng: Sở hữu giải pháp kiến trúc nén ảnh Lossless thời gian thực với chi phí phần cứng siêu thấp, dễ dàng tích hợp vào hệ thống nhúng SoC/ASIC.
  • Nhà nghiên cứu lĩnh vực Xử lý ảnh & Mã hóa thông tin: Cung cấp dữ liệu thực nghiệm so sánh đa chiều giữa Linear Prediction kết hợp Dynamic Huffman với các thuật toán chuẩn như LZW, Static Huffman.

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật phần cứng tối thiểu để tích hợp IP Core này là gì?

Hệ thống yêu cầu bo mạch FPGA hỗ trợ xung nhịp hệ thống tối thiểu 125 MHz (ví dụ: Xilinx Artix-7 XC7A35T hoặc Intel Cyclone IV). Thiết kế chỉ sử dụng logic LUTs và Flip-Flops thông thường cho 32 thanh ghi 41-bit, không đòi hỏi khối DSP hay Block RAM chuyên dụng lớn.

2. Vì sao giải thuật đạt chỉ số SSIM = 1.0 tuyệt đối?

Vì khối Linear Prediction sử dụng hàm làm tròn số nguyên (round), giá trị sai số $E(i,j)$ thu được hoàn toàn là số nguyên chính xác. Khối Dynamic Huffman Coding sau đó mã hóa không mất mát 100% chuỗi sai số này. Trong quá trình giải nén, các phép tính được đảo ngược chính xác từng bit, khôi phục lại từng pixel gốc không sai lệch.

3. Làm thế nào để giải nén nếu dữ liệu nén không có Header chứa cây Huffman?

Thuật toán Dynamic Huffman hoạt động theo nguyên lý cây thích ứng đồng bộ: Phía giải nén khởi tạo cây nhị phân rỗng ban đầu giống hệt phía nén. Khi đọc từng bit trong bitstream, nếu gặp mã NYT, bộ giải nén sẽ đọc tiếp giá trị symbol 4-bit tiếp theo để thêm vào cây và tự động gọi hàm cập nhật cây (update_tree). Nhờ đó, cây ở bộ giải nén luôn biến đổi song song và đồng nhất với cây ở bộ nén mà không cần truyền bảng mã.

4. Hệ thống xử lý thế nào đối với các bức ảnh có độ phức tạp cao (ảnh có nhiều chi tiết nhiễu)?

Khối Linear Prediction đóng vai trò làm phẳng biểu đồ Histogram của ảnh, chuyển đổi phân phối pixel tản mác thành phân phối sai số tập trung quanh mức 0. Nhờ đó, cây Dynamic Huffman luôn duy trì được độ lệch xác suất tối ưu, đảm bảo tỷ lệ nén $CR$ vẫn đạt trên 2.6 ngay cả với các ảnh phức tạp như Baboon ($CR = 2.660$).

5. Chi phí bản quyền và khả năng mở rộng sang chuẩn video là gì?

Giải thuật Dynamic Huffman và Linear Prediction là các giải thuật toán học mở, không bị vướng rào cản bản quyền bằng sáng chế độc quyền như một số biến thể của Arithmetic Coding. Hệ thống hoàn toàn có thể mở rộng để nén chuỗi khung hình video (Lossless Video Codec) bằng cách bổ sung khối dự đoán chuyển động giữa các khung hình (Inter-frame Prediction).

Kết luận

Đề tài khóa luận "Hiện thực hóa kỹ thuật nén ảnh Dynamic Huffman Coding trên phần cứng" đã giải quyết xuất sắc bài toán cân bằng giữa hiệu suất nén dữ liệu không mất mát và mức tiêu hao tài nguyên phần cứng. Bằng sáng kiến chuyển đổi dữ liệu 4-bit Hexadecimal kết hợp tầng lọc sai số Linear Prediction, nhóm nghiên cứu đã rút gọn quy mô cây nhị phân xuống còn 32 thanh ghi, cho phép khối nén hoạt động ổn định ở tần số 125 MHz với tỷ lệ nén trung bình vượt trội 3.467 và bảo toàn tuyệt đối chất lượng ảnh (SSIM = 1.0).

Công trình mở ra tiềm năng ứng dụng to lớn trong các hệ thống truyền ảnh y tế thời gian thực, thiết bị thám hiểm viễn thám và hệ thống nhúng biên (Edge AI/IoT) đòi hỏi độ chính xác dữ liệu tuyệt đối cùng chi phí sản xuất vi mạch tối ưu.