KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN …te.ugm.ac.id/~enas/tesis260199.pdf · Rangkaian...
Transcript of KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN …te.ugm.ac.id/~enas/tesis260199.pdf · Rangkaian...
KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN-3E
Tesis
untuk memenuhi sebagian persyaratan mencapai derajat sarjana S-2
Program Studi Teknik Elektro
Jurusan Ilmu-ilmu Teknik
diajukan oleh:
Enas Dhuhri Kusuma 07/260190/PTK/4715
Kepada PROGRAM PASCASARJANA
FAKULTAS TEKNIK UNIVERSITAS GADJAH MADA
YOGYAKARTA 2010
TESIS
KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN-3E
dipersiapkan dan disusun oleh
Enas Dhuhri Kusuma
07/260199{PTW04715
Telah dipertatrankan di depan Dewan PengujiPada tanggal25 Mei 2010
Susirniln Dewm Pengiji
Pembimbing Utama
MProf. Dr. Ir. Thomas Sri Widodo. DEA
Anggota Dewan Penguji Lain
Tesis ini telah diterima sebagai salah satu persyaratanuntuk memperoleh gelar Magister
Tanggal 14 Juni 2010Pengelola Program Studi : Teknik Elektro
k. P.Insap Santosa. M.Sc..Ph.D.NrP. I 961 01081 98503 1 002
Studi Teknik Elektro
NIP. r 9660327 t99103t002
Wakil
PBRNYATAAN
Dengan ini saya menyatakan bahwa dalam tesis ini tidak terdapat karya yang pernah
diajukan untuk memperoleh gelar kesarjanaan di suatu Perguruan Tinggi, dan sepanjang
pengetahuan saya juga tidak terdapat karya atau pendapat yang pemah ditulis atau
diterbitkan oleh orang lain, kecuali yang secara tertulis diacu dalam naskah ini dan
disebutkan dalam daftar pustaka
10 Mei 2010
iv
HALAMAN PERSEMBAHAN
Tesis ini Penulis persembahkan untuk :
Ummu Fida
The Special One, Mufida Bapak/Ibu Asyhuri Nidjar, the skinny
PRAKATA
Sungguh suatu anugerah yang luar biasa, sehingga Tesis dengan judul “Kompresi Citra
JPEG Berbasis FPGA Spartan-3E“ ini akhirnya dapat Penulis susun dan selesaikan.
Segala puji bagi Allah SWT atas segala rahmat dan hidayah yang senantiasa tercurah.
Tesis ini disusun untuk memenuhi salah satu syarat untuk menyelesaikan program
pendidikan S-2 di Program Studi Teknik Elektro, Jurusan Ilmu-ilmu Teknik, Program
Pascasarjana Universitas Gadjah Mada, Jogjakarta.
Pada kesempatan ini, dengan segala keikhlasan dan kerendahan hati, Penulis
menyampaikan banyak terima kasih kepada:
1. Bapak Prof. Dr. Ir. Thomas Sri Widodo, DEA., Selaku Pembimbing Utama yang
telah banyak meluangkan waktu, memberikan banyak perhatian dan arahan yang
tegas serta warna yang lain dalam pembimbingan dari awal hingga akhir sehingga
Penulis mempunyai pemahaman dunia elektro yang baru.
2. Bapak Dr. Ir. P. Insap Santosa M.Sc., Bapak Dr. Ir. Risanuri Hidayat M.Sc., dan
Ir. Litasari, M.Sc, selaku pengelola Program Studi Teknik Elektro, Jurusan Ilmu-ilmu
Teknik, Program Pascasarjana Universitas Gadjah Mada.
3. Bapak Ir. Wahyu Dewanto, MT selaku Pembimbing Pendamping dengan
kesabarannya dalam membantu dan memberikan saran dalam proses pembuatan tesis
ini.
4. Isteriku tercinta, Wina Ummu Fida dan the special one Mufida yang manis dan
cerdas, atas dukungannya yang riil dan setia.
5. Ibu/Bapakku Asyhuri yang senantiasa mengiringi setiap langkahku dengan do’a dan
kasihnya. Ibu/Bapak Mertua dan keluarga di Sukabumi atas do’a dan pengertiannya.
6. Adikku Nidjar atas segala dukungan yang diberikan.
v
7. Dr. Ir. Tumiran, Ph.D, selaku pribadi, sesepuh dan selaku Dekan FT Universitas
Gadjah Mada.
8. Dr. Ir. Lukito Edi Nugroho, M.Sc., selaku Ketua Jurusan Teknik Elektro dan
Teknologi Informasi atas segala kebijakannya.
9. Ir. Bambang Sutopo M.Phil., atas ide-idenya dan perkenalan tentang FPGA terhadap
penulis
10. Semua pihak yang ikut membantu terselesaikannya tesis ini, yang tak sempat
tersebutkan namanya.
Semoga Allah SWT memberikan rahmat dan karunia yang berlipat ganda atas
segala bimbingan, bantuan dan motivasinya.
Penulis menyadari bahwa tesis ini masih banyak kekurangan. Namun demikian
semoga dapat memberikan manfaat yang besar bagi pengembangan ilmu pengetahuan
dan teknologi.
Jogjakarta, 10 Mei 2010
Penulis
Enas Dhuhri Kusuma
vi
DAFTAR ISI
halaman
HALAMAN JUDUL.......................................................................................... i
HALAMAN PENGESAHAN............................................................................ ii
HALAMAN PERNYATAAN.............................................................................. iii
HALAMAN PERSEMBAHAN.......................................................................... iv
PRAKATA............................................................................................................ v
DAFTAR ISI...................................................................................................... vii
DAFTAR GAMBAR …..................................................................................... x
DAFTAR TABEL ….......................................................................................... xii
INTISARI........................................................................................................... xv
ABSTRACT …................................................................................................... xvi
I. PENDAHULUAN …....................................................................................... 1
1.1. Latar Belakang …........................................................................ 1
1.2. Tujuan Penelitian …..................................................................... 5
II. TINJAUAN PUSTAKA DAN DASAR TEORI …........................................ 6
2.1. Kajian Pustaka …......................................................................... 6
2.2. Dasar Teori ….............................................................................. 9
2.2.1 Kompresi Citra Berbasis DCT …......................................... 9
2.2.2. Kompresi Citra Baseline JPEG …....................................... 15
2.2.3. FPGA (Field Programmable Gate Array) XCS500E …...... 21
2.3. Hipotesis ….................................................................................. 23
III. METODA PENELITIAN …......................................................................... 25
3.1. Bahan Penelitian …...................................................................... 25
3.2. Alat Penelitian …......................................................................... 25
vii
3.3. Jalan Penelitian …....................................................................... 25
3.3.1. Perancangan sistem secara global …....................................26
3.3.2. Perancangan algoritma dan modul DCT 1 D ….................. 28
3.3.3. Perancangan pipeline modul DCT-1D …............................ 30
3.3.4. Aritmatika komputasi DCT-1D …....................................... 36
3.3.5. Perancangan DCT-2D …..................................................... 39
3.3.6. Perancangan Transpose Buffer …....................................... 40
3.3.7. Perancangan Pengendali DCT-2D ….................................. 42
3.3.8. Unit Zigzag …..................................................................... 44
3.3.9. Perancangan Quantizer….................................................... 45
3.3.10. Penanda nilai DC…............................................................48
3.3.11. Perancangan penyandi entropi …...................................... 48
3.3.12. AC Coder. …..................................................................... 49
3.3.13. Penyandi RLE................................................................... 50
3.3.14. Pemeta kategori dan generator simbol …......................... 51
3.3.15. DC differentiator............................................................... 52
3.3.16. Penyandi koefisien DC...........…....................................... 53
3.3.17. Code Multiplexer ….......................................................... 54
3.3.18. Bit Stuffer........................................................................... 54
3.4. Metode Pengujian Sistem …........................................................... 56
3.5. Source code dan hirarkinya …........................................................ 60
IV. HASIL PENELITIAN DAN PEMBAHASAN …....................................... 61
4.1. Simulasi Rancangan ….................................................................. 61
4.1.1. Simulasi modul DCT-1D.................................................... 61
4.1.2. Pengujian rangkaian DCT-2D terskala .............................. 67
viii
4.1.3. Pengujian zig-zag buffer......................................................73
4.1.4. Pengujian Quantizer........................................................... 75
4.1.5. Pengujian penanda nilai DC............................................... 77
4.1.6 Pengujian unit penghasil nilai beda pada koefisien DC...... 78
4.1.7. Pengujian unit penyandi entropi......................................... 78
4.1.8. Pengujian unit bit stuffer ....................................................81
4.1.9. Latensi sistem secara keseluruhan …................................. 83
4.1.11. Pengujian dekompresi data .............................................. 83
4.2. Pengujian Hardware ......................................................................... 84
4.2.1. Utilisasi komponen ............................................................ 85
4.2.2. Spesifikasi pewaktuan …............. …................................. 87
4.2.3. Perhitungan Pesat Frame …................................................ 88
4.2.4. Pengujian Rasio Kompresi ................................................. 91
4.3. Permasalahan dalam penelitian ......................................................... 94
V. KESIMPULAN DAN SARAN …................................................................ 98
DAFTAR PUSTAKA.........................................................................................101
LAMPIRAN A : Citra Uji …...........................................................................A-1
LAMPIRAN B: Hirarki Desain dan Source Code …......................................B-1
LAMPIRAN C: Tabel Huffman …..................................................................C-1
LAMPIRAN D: Komentar Responden terhadap Citra Kompresi ….............. D-1
ix
DAFTAR GAMBAR
halaman
Gambar 2.1 Diagram kompresi JPEG baseline …....................................................15
Gambar 2.2 Urutan pengeluaran data secara zig-zag pada standar JPEG …............18
Gambar 2.3 Visualisasi pengeluaran data zig-zag secara numeris ….......................19
Gambar 3.1 Interkoneksi modul-modul dalam piranti kompresi ….........................26
Gambar 3.2 Signal flow graph algoritma DCT Arai …............................................29
Gambar 3.3 Proses akusisi input, komputasi, dan pengeluaran output DCT-1D …..30
Gambar 3.4 Visualisasi proses DCT-1D dengan eksekusi single-cycle …...............31
Gambar 3.5 Rancangan timing diagram proses pipeline DCT-1D ….......................33
Gambar 3.6 Skema interkoneksi 2 stage DCT-1D …...............................................40
Gambar 3.7 Rancangan modul transpose buffer …..................................................41
Gambar 3.8 Susunan data input dan output pada transpose buffer …......................41
Gambar 3.9 Visualisasi input dan output data menuju dan dari transpose buffer …43
Gambar 3.10 Struktur unit zigzag …........................................................................46
Gambar 3.11 Skema kuantisasi dan penskalaan ulang ….........................................48
Gambar 3.12 Rancangan modul penyandi entropi …...............................................49
Gambar 3.13 Diagram blok sub modul sandi Huffman ….......................................50
Gambar 3.14 Diagram blok penyandi komponen AC ….............. .…......................51
Gambar 3.15 Rangkaian penyandi RLE …...............................................................52
Gambar 3.16 Skema penyandi koefisien DC ….......................................................53
Gambar 3.17 Interkoneksi penyandi dengan bit stuffer........................................... .55
Gambar 3.18 Skema pengujian simulasi dan hardware............................................56
x
Gambar 3.19 Skema konversi bitmap ke VHDL …..................................................58
Gambar 3.20 Diagram blok pengujian rangkaian......................................................59
Gambar 4.1 Citra asal untuk pengujian sistem kompresi ….....................................61
Gambar 4.2 Diagram pewaktuan modul DCT-1D …................................................66
Gambar 4.3 Simulasi awal pengisian data ke transpose buffer ….............................68
Gambar 4.4 Diagram pewaktuan awal pengeluaran data transpose buffer …...........69
Gambar 4.5 Diagram pewaktuan penulisan 64 data keluaran DCT-1D ke transpose
buffer ….....................................................................................................................69
Gambar 4.6 Diagram pewaktuan pengeluaran 64 titik data output …......................70
Gambar 4.7 Diagram pewaktuan DCT-2D …...........................................................73
Gambar 4.8 Diagram pewaktuan input data dari DCT2D ke zigzag buffer …..........74
Gambar 4.9 Diagram pewaktuan pembacaan data dari zig-zag buffer ….................74
Gambar 4.10 Diagram pewaktuan penanda koefisien DC …....................................77
Gambar 4.11 Diagram pewaktuan untuk menguji penghasil selisih koefisien DC ...78
Gambar 4.12 Diagram pewaktuan unit RLE dengan jumlah nol kurang dari 16 …...79
Gambar 4.13 Diagram pewaktuan unit RLE dengan jumlah nol 16 atau lebih …......80
Gambar 4.14 Diagram pewaktuan latensi sistem …...................................................83
Gambar 4.15 Screenshot teks file hasil simulasi kompresi …................................. ..84
Gambar 4.16. Rangkaian penghitung siklus clock untuk pengolahan satu frame ......89
Gambar 4.17. Skema deteksi kesalahan .....................................................................90
xi
DAFTAR TABEL
halaman
Tabel 1.1 Beberapa IC dan intellectual property untuk kompresi JPEG …..............3
Tabel 2.1 Langkah-langkah algoritma DCT-1D …...................................................13
Tabel 2.2 Nilai-nilai pada matriks kuantisasi untuk citra grayscale. …...................16
Tabel 2.3 Kode Huffman untuk pemetaan simbol dan kategori koefisien DC dan
AC …........................................................................................................................18
Tabel 2.4 Kode Huffman luminance citra untuk komponen DC dan AC …............17
Tabel 2.5 Parameter-parameter FPGA Xilinx XCS500E. …...................................21
Tabel 3.1 Tabel pipeline modul DCT-1D …............................................................33
Tabel 3.2 Delapan state sebagai acuan implementasi …..........................................33
Tabel 4.1 Nilai 8 x 8 piksel sebelum dikurangi 128 untuk pengujian DCT-1D …..62
Tabel 4.2 Nilai pixel sesudah dikurangi 128 untuk pengujian DCT-1D ….............62
Tabel 4.3 Perbandingan komputasi DCT-1D pada VHDL dan Matlab …...............63
Tabel 4.4 Hasil komputasi DCT-2D terskala pada Matlab dan simulasi VHDL ….72
Tabel 4.5 Selisih komputasi DCT-2D terskala pada Matlab dan VHDL …............72
Tabel 4.6 Hasil komputasi DCT-zigzag-kuantisasi pada VHDL dan Matlab ….....76
Tabel 4.7 Hasil penyandian entropi blok ke 1 …....................................................81
Tabel 4.8 Hasil penyandian blok ke-0 dalam paket 8 bit …...................................82
Tabel 4.9 Perbandingan data yang dipulihkan dengan citra asli …........................85
Tabel 4.10 Utilisasi komponen FPGA …............................................................... 86
Tabel 4.11 Spesifikasi pewaktuan rangkaian yang dirancang …............................87
Tabel 4.12 Unit-unit penyumbang delay pada sistem …........................................87
xii
Tabel 4.13. Jumlah siklus clock yang dibutuhkan untuk pengolahan frame pada
beberapa sampel .....................................................................................................89
Tabel 4.14. Perbandingan frame rate dan frekuensi maksimal antara rangkaian yang
dirancang dan intellectual property JPEG serta chip kompresi JPEG .....................91
Tabel 4.15. Perbandingan rasio kompresi antara FPGA dan Image Analyzer ........ 91
Tabel 4.16. MSE (Mean Square Error) antara hasil kompresi rangkaian dan citra asal
serta citra hasil kompresi software ..........................................................................94
Tabel 4.17. Penilaian secara subjektif terhadap citra hasil kompresi rangkaian
dibandingkan dengan citra asal ...............................................................................94
Tabel 4.18. Banyaknya kejadian error pada lima kali pengiriman data ................. 96
Tabel 4.19. Hubungan antara delay dan error yang muncul pada transmisi ...........97
xiii
INTISARI
Implementasi kompresi citra pada suatu chip digunakan untuk kompresi yang membutuhkan kecepatan yang real-time. Kompresi citra secara hardware digunakan pada berbagai piranti untuk penyimpanan seperti pada kamera digital dan transmisi citra seperti pada sistem video conferencing.
Pada tesis ini dibahas implementasi kompresi citra dengan metode JPEG dalam keping FPGA Xilinx Spartan-3E. Penelitian ini bertujuan membuat suatu sistem kompresi citra yang unjuk kerjanya dapat menyamai chip kompresi citra yang ada di pasaran. Chip yang dirancang dapat digunakan untuk penyimpanan dan transmisi. Rangkaian kompresi citra dirancang supaya sesuai untuk FPGA low-cost seperti Xilinx Spartan-3E.
Citra masukan untuk pengujian adalah citra grayscale. Sistem kompresi terdiri dari modul DCT-2D, quantizer, unit zig-zag, dan penyandi entropi. Rangkaian kompresi dideskripsikan menggunakan VHDL.
Rangkaian sudah berhasil disimulasi dalam software Xilinx ISE 10 dan disintesis untuk FPGA serta dijalankan secara hardware. Port serial digunakan sebagai media input citra ke dalam FPGA.
Latensi pipeline pada rangkaian yang didapat adalah 170 siklus clock. Data yang diolah dibagi dalam beberapa blok yang berukuran 8x8 pixel. Untuk melakukan kompresi terhadap n buah blok dibutuhkan 170 + 1280n siklus clock. Frekuensi clock maksimal yang diperbolehkan pada rancangan sistem ini adalah 25.724MHz. Hal itu membuat pesat data yang diperbolehkan adalah 25.724 Mega byte per detik. Utilisasi rangkaian yang didapatkan dari proses sintesis yaitu slice sebanyak 1421, look up table (LUT) sebanyak 2485 dan pengali sebanyak 11 unit. Frame rate rerata maksimal yang dapat dicapai oleh rangkaian kompresi JPEG pada citra grayscale adalah 370.04 fps (frame per second) untuk ukuran 240x320 sedangkan untuk ukuran 480x640 adalah 92.73 fps. Rasio kompresi yang dicapai oleh rangkaian kompresi JPEG dapat menyamai rasio yang dicapai oleh software pengolah citra. Untuk citra berukuran kecil (80x80 dan 40x40), rasio kompresi rangkaian bahkan lebih kecil daripada rasio kompresi software. kata kunci : kompresi, citra, JPEG, DCT-2D, FPGA
xiv
ABSTRACT
Implementation of image compression on a chip used for the compression that requires real-time speed. Image compression in hardware for use on various storage devices such as digital cameras and image transmission such as video conferencing systems.
This thesis discuss about implementation of the JPEG image compression method in the FPGA chip Xilinx Spartan-3E. This research aims to create an image compression system which can match its performance image compression chip on the market. Designed chip can be used for storage and transmission. Image compression circuit is designed to fit for low-cost FPGA such as Xilinx Spartan-3E.
Input images are gray scale images for testing. The compression system consists of modules-2D DCT, quantizer, zig-zag unit, and entropy coding. Compression circuits are described using VHDL.
Circuit has been successfully simulated in Xilinx ISE software and synthesized for FPGA 10 and executed in hardware. Serial port is used as a medium of image input into the FPGA.
Pipeline latency in the circuit obtained is 170 clock cycles. Data were processed divided into different sized blocks of 8x8 pixels. For compression of block n + 1280n required 170 clock cycles. Maximum clock frequency allowed in the design of this system is 25.724MHz. It makes rapid data that allowed the 25 724 Mega bytes per second. Utilization circuit synthesis process that is obtained from a slice of 1421, look up table (LUT) of multipliers 2485 and as many as 11 units. Mean maximum frame rate that can be achieved by a series of JPEG compression on grayscale images is 370.04 fps (frames per second) for the size of 240x320 while the size is 480x640 92.73 fps. The compression ratio achieved by a series of JPEG compression can be achieved by matching the ratio of the image processing software. For small images (80x80 and 40x40), a series of compression ratio even smaller than software compression ratio.
keyword : compression, image, JPEG, DCT-2D, FPGA
xv
1
BAB I
PENDAHULUAN
1.1. Latar Belakang
1.1.1. Perumusan Masalah
Dewasa ini, komunikasi dan informasi merupakan bagian tidak
terpisahkan dalam kehidupan manusia. Media komunikasi elektronik seperti
internet dan telepon selular sudah menjadi kebutuhan pokok. Kecenderungan
komunikasi sudah beralih dari komunikasi analog menuju komunikasi digital atau
komunikasi data.
Untuk membuat komunikasi data menjadi lebih efisien, diperlukan suatu
metode untuk menyandikan data yang dikirimkan. Jalur komunikasi yang tersedia
sudah memiliki spesifikasi tertentu yaitu pesat bit maksimal yang dapat
dilewatkan pada jalur tersebut. Penyandian diperlukan supaya informasi dapat
ditransmisikan melalui jalur komunikasi yang tersedia dengan pesat data yang
dapat diterima. Model penyandian yang diperlukan untuk keperluan tersebut
adalah kompresi atau pemampatan data.
Metode kompresi data ada bermacam-macam tergantung pada jenis
datanya. Untuk informasi yang berbentuk citra, salah satu metode kompresi yang
populer adalah JPEG. JPEG merupakan singkatan dari Joint Photographic Expert
Group. Menurut Magli (2004), JPEG banyak digunakan pada citra yang
disertakan pada halaman web internet. Penggunaan JPEG membuat halaman web
yang bergambar dapat diakses dengan lebih cepat dibanding halaman web dengan
citra tanpa kompresi.
Kompresi JPEG dapat dilakukan baik secara software maupun hardware.
1
2
Masing-masing mempunyai penggunaan yang berbeda. Kompresi secara software
umumnya digunakan untuk oleh desainer grafis mengolah dan menyimpan file
citra pada komputer. Metode kompresi JPEG secara hardware digunakan pada
piranti-piranti yang berhubungan dengan citra digital seperti kamera digital,
scanner, perekam video digital, set-top-box, sampai dengan aplikasi video
conferencing (Zoran, 1998; Inrevium, 2005). JPEG tidak hanya digunakan
sebagai metode kompresi untuk citra diam, tetapi juga dimanfaatkan untuk
kompresi citra bergerak dalam format Motion JPEG atau M-JPEG (Okada,
1997 ). M-JPEG menangani kumpulan frame citra yang masing-masing
terkompresi secara JPEG. Walaupun relatif kurang efisien, Kompresi M-JPEG
dipilih sebagai metode kompresi video karena tingkat kerumitan yang lebih
rendah daripada metode kompresi video lainnya yaitu MPEG (Pillai, 2002).
Secara struktur, MPEG juga terdiri dari unit kompresi citra JPEG-like ditambah
dengan kompensasi gerakan.
Metode kompresi JPEG secara hardware juga dapat dilakukan dengan dua
cara. Pertama, algoritma kompresi diimplementasikan pada mikrokontroler atau
DSP melalui program (Zulkarnain, 2000). Cara kedua adalah implementasi
algoritma JPEG pada rangkaian digital (ASIC atau FPGA) yang banyak
diterapkan pada berbagai piranti (Agostini, 2001). Implementasi pada rangkaian
digital banyak dipilih karena kinerjanya lebih baik dilihat dari segi waktu
kompresi. Operasi kompresi dapat dilakukan secara cepat dan realtime memakai
rangkaian digital. Pada piranti berbasis mikroprosesor, kompresi dilakukan
dengan mengeksekusi kumpulan instruksi satu demi satu. Karena pada algoritma
JPEG dibutuhkan komputasi dan iterasi yang banyak, proses eksekusinya menjadi
2
3
lebih lama. Beberapa contoh chip dan intellectual property kompresi JPEG
baseline beserta spesifikasinya ditunjukkan pada Tabel 1.1.
Rangkaian terintegrasi untuk kompresi JPEG sebenarnya sudah terdapat di
pasaran. Sebagai contoh adalah produk Zoran (1998) dan Inverium (2005) serta
beberapa properti intelektual dari Barco (2005) dan Cast-JPEG (2008).
Permasalahan yang dihadapi yaitu, pembuat produk-produk tersebut tidak
mempublikasikan rancangannya secara umum sampai pada tingkat rancangan
hardware. Keadaan seperti itu membuat teknologi perancangan piranti tersebut
tidak banyak dikuasai, terutama di negara-negara dengan teknologi yang baru
berkembang. Alih teknologi di negara-negara berkembang menjadi suatu
kebutuhan. Untuk menguasai teknologi rangkaian kompresi JPEG, dibutuhkan
usaha perancangan prototype rangkaian tersebut berdasarkan ilmu yang sudah
dikuasai.
Tabel 1.1 Beberapa IC dan intellectual property untuk kompresi JPEG
Seri chip/ pabrikan
Jenis produk
FPGA target
Spesifikasi
BA119JPEGCOD/Barco
Intellectual property
Virtex XC2V1500-6
Frekuensi maksimum 82 MHzJumlah slice = 7497Frame rate 120 fps pada 640 x 480, YcrCb=4:1:1
CAST-JPEG/Cast-inc
Intellectual property
Altera Cyclone EP1C20-C6
Frekuensi maksimum 86 MHzFrame rate = 162 fps pada resolusi 480x640, YcrCb=4:1:1Jumlah logic element = 15,305
ZR36060-29.5 / Zoran
IC Frekuensi maksimum 29.5 MHzFrame rate 33 fps pada 640 x 480, YcrCb=4:1:1
TE3310RPF-E/ Inrevium
IC Frekuensi maksimum 27 MHzFrame rate 50 fps pada 640 x 480, YcrCb=4:1:1
3
4
Perancangan prototype rangkaian digital memerlukan suatu piranti yang
dapat dikonfigurasi ulang berkali-kali. FPGA (Field Programmable Gate Array)
merupakan piranti yang sesuai untuk keperluan perancangan prototype rangkaian
digital, terutama dengan skala kompleksitas besar. Selain karena dapat
dikonfigurasi ulang, jumlah gerbang dan flip-flop pada FPGA juga sangat banyak.
FPGA Spartan 3E XC3S500E keluaran Xilinx mempunyai gerbang sebanyak
500.000 dan slice sebanyak 4.656 unit (Xilinx, 2009). Berdasarkan spesifikasi
tersebut, perancangan prototype rangkaian kompresi JPEG diperkirakan dapat
diterapkan pada keping FPGA XC3S500E dengan penerapan algoritma tertentu.
Rangkaian kompresi JPEG sesuai untuk dikembangkan pada FPGA low cost
seperti XC3S500E karena JPEG mempunyai kompleksitas yang lebih rendah
dibanding MPEG dan tidak membutuhkan operasi yang harus dibantu dengan
suatu prosesor.
1.1.2. Keaslian Penelitian
Sejauh ini penelitian mengenai kompresi citra JPEG dan bagian-bagiannya
berbasis FPGA telah dilakukan. Sun, dkk(1989) membuat rancangan DCT
(Discrete Cosine Transform)2D 16x16 pada VLSI. Rancangan tersebut belum
dapat diterapkan pada kompresi JPEG karena JPEG memakai ukuran blok 8x8
pada DCT 2D nya. Jang (1994) membuat suatu prosesor DCT 2D 8x8 dengan
metode dekomposisi matriks DCT. DCT 1D pada penelitian tersebut masing-
masing memakai 32 dan 16 operasi perkalian. Agostini (2001,2002) melakukan
kompresi JPEG pada FPGA Altera Flex10KE. Algoritma yang digunakan adalah
DCT 1D dari Arai(1988). Secara keseluruhan, operasi dilakukan secara pipeline.
Operasi aritmetika terhadap masukan dilakukan bergantian untuk tiap stage.
4
5
Tesis ini membahas mengenai rancang bangun sistem kompresi citra
dengan metode JPEG. Sistem ini diimplementasikan pada FPGA Spartan 3E.
Berbeda dengan penelitian Agostini, pada tesis ini akan dilakukan operasi
aritmetika secara paralel untuk tiap stage. Hal ini belum dilakukan penulis
sebelumnya, mengingat uraian lengkap dan teknis pada paper sebelumnya sulit
diperoleh karena tidak dipublikasikan.
1.1.3. Faedah Penelitian
Penelitian ini diharapkan dapat memperkaya khasanah pengetahuan pada
dunia komunikasi dan informasi, serta pengembangan perangkat keras, khususnya
mengenai kompresi citra.
1.2. Tujuan Penelitian
1. Merancang dan membuat prototype rangkaian terintegrasi untuk kompresi
citra JPEG baseline menggunakan FPGA Xilinx XC3S500E.
2. Rangkaian kompresi yang dibangun memilki spesifikasi yang kompatibel
dengan IC kompresi JPEG yang terdapat di pasaran, yaitu dapat diterapkan
pada aplikasi-aplikasi berikut.
a) Kompresi citra diam (JPEG) dan video (MJPEG) untuk keperluan
penyimpanan.
b) Kompresi video (MJPEG) untuk keperluan transmisi atau video
streaming.
5
6
BAB II
TINJAUAN PUSTAKA DAN DASAR TEORI
2.1. Kajian Pustaka
Berdasarkan Agostini (2001), komponen utama dari kompresi citra JPEG
adalah DCT (Discrete Cosine Transform) dua dimensi (DCT-2D). DCT-2D adalah
bagian dari kompresi JPEG yang paling kritis. Karena kompleksitas
komputasinya, sumber daya dan waktu komputasi lebih banyak terfokus pada
bagian tersebut. Kompleksitas juga telah menghasilkan beberapa penelitian yang
bertujuan menyederhanakan komputasi DCT. Penelitian-penelitian tersebut
banyak terfokus pada algoritma komputasi DCT satu dimensi dengan panjang 8
titik.
DCT dikembangkan pertama kali oleh Ahmed, dkk (1974). Chen, dkk
(1977) merintis penelitian mengenai algoritma komputasi DCT satu dimensi
(DCT 1D). Penyederhanaan dilakukan dengan cara dekomposisi matriks DCT dari
ukuran 8 x 8 menjadi dua buah matriks 4 x 4. Jumlah operasi perkalian dapat
dikurangi hingga menjadi 16 perkalian. Pada algoritma ini, komputasi invers DCT
(IDCT) dapat dilakukan dengan menukar input dan output DCT pada data flow
graph-nya (reversible).
Algoritma yang diusulkan oleh Arai, dkk(1988) mampu mengurangi
jumlah perkalian pada komputasi DCT 1D menjadi sejumlah lima perkalian saja.
Hal itu dimungkinkan karena nilai yang didapat pada output adalah nilai yang
terskala (DCT terskala). Nilai output bukanlah koefisien DCT yang
sesungguhnya. Untuk mendapatkan nilai yang sesungguhnya, dilakukan
penskalaan ulang. Pada berbagai sistem, proses penskalaan ulang dapat disertakan
6
7
pada proses pasca DCT. Misalnya seperti proses kuantisasi pada kompresi citra.
Kelima perkalian pada algoritma DCT Arai dilakukan secara paralel. Pada flow
graph-nya, tidak ada jalur yang memiliki lebih dari satu perkalian. Flow graph
pada algoritma ini tidak reversible.
Loffler, dkk (1989) kemudian mengusulkan suatu algoritma komputasi
DCT yang tidak terskala. Algoritma tersebut memerlukan 11 perkalian untuk
komputasi DCT 1D. Sama dengan algoritma Arai, pada flow graph algoritma
Loeffler juga tidak terdapat jalur yang memiliki lebih dari satu perkalian.
Penerapan DCT dua dimensi (DCT-2D) pada VLSI diusulkan oleh
Sun,dkk (1989). Usulan yang disampaikan berupa DCT terhadap matriks 16 x 16.
Ukuran ini kurang lazim untuk kompresi citra, yang menggunakan ukuran blok
8x8. Meskipun begitu, usulan ini cukup memberikan gambaran yang jelas
mengenai aristektur rangkaian DCT-2D. Rancangan ini menggunakan dua unit
DCT-1D 16 titik yang dihubungkan oleh suatu transpose buffer yang diatur oleh
rangkaian pewaktuan dan kendali.
DCT dua dimensi (DCT 2D) 8x8 dikembangkan menjadi suatu rancangan
hardware oleh Jang (1994) untuk kompresi MPEG dan untuk prosesor HDTV.
Komputasi DCT 2D direalisasi dengan dua kali pemrosesan DCT 1D. Pemrosesan
DCT 1D yang kedua berasal dari operasi transpose hasil DCT 1D yang pertama.
Untuk mendukung hal itu, digunakan suatu transpose buffer. Pada rancangan
hardware-nya, hanya digunakan 1 blok DCT 1D. Pada bagian input DCT 1D,
dipasang multiplekser untuk memilih masukan. Masukan yang dipilih adalah
masukan dari input port atau masukan dari output transpose buffer. Algoritma
DCT 1D yang digunakan adalah dengan dekomposisi matriks DCT 8x8 menjadi
7
8
dua matriks 4x4. Pengali yang dibutuhkan untuk DCT 1D sebanyak 32 unit.
Wallace (1991) mengusulkan suatu metode kompresi citra yang dinamai
dengan JPEG. JPEG baseline yang diusulkan pada paper tersebut merupakan
kompresi yang mempunyai rugi-rugi (lossy) karena ada komponen informasi yang
dibuang. Kompresi ini menggunakan DCT 2D untuk mencari komponen frekuensi
citra. Koefisien DCT 2D yang didapat kemudian direduksi melalui proses
kuantisasi untuk menghilangkan komponen frekuensi tinggi. Nilai terkuantisasi
disandikan lagi menggunakan sandi Huffman.
Perancangan hardware berbasis FPGA untuk komputasi DCT 2D sudah
dilakukan oleh Agostini (2001). DCT 2D yang dirancang ditujukan untuk
kompresi citra JPEG. Pada tulisannya yang lain Agostini (2002) juga merancang
suatu entropy encoder untuk pengolahan lebih lanjut keluaran DCT 2D sehingga
didapatkan citra terkompresi JPEG. FPGA yang digunakan pada penelitian
tersebut adalah Altera Flex 10kE dengan jumlah gerbang maksimal 200.000, logic
element sejumlah 9.984 unit, dan LUT sejumlah 24. DCT 2D dikerjakan
menggunakan dua unit DCT 1D yang dihubungkan melalui suatu transpose buffer.
Algoritma DCT 1D yang digunakan adalah algoritma DCT dari Arai(1988).
Penelitian ini menggunakan pengali yang dibuat sendiri. Pengali dibuat memakai
teknik shift and add. Pada tulisan tersebut, proses komputasi pada masing-masing
stage dilakukan secara bergantian (multiplexed). Keseluruhan proses pada
kompresi citra dilakukan secara pipeline. Pada tulisan ini disebutkan, piranti DCT
2D yang dihasilkan menggunakan 4.792 logic cell, mempunyai frekuensi operasi
maksimal 12,2 MHz. Latensi pipeline yang terbentuk adalah sebesar 160 siklus
clock.
8
9
Meskipun telah diketahui beberapa algoritma komputasi DCT dan
kompresi JPEG dari hasil-hasil penelitian terdahulu, akan tetapi uraian lengkap
dan teknis proses tersebut sulit diperoleh karena tidak dipublikasikan. Pada tesis
ini akan dirancang perangkat keras untuk kompresi citra dengan metode JPEG
baseline berbasis FPGA Xilinx Spartan 3E XC3S500E. Algoritma DCT 1D yang
digunakan pada tesis ini adalah algoritma usulan Arai, dkk(1988). Agoritma
tersebut hanya memiliki 5 perkalian dan bila dikembangkan menjadi DCT 2D
hingga kompresi JPEG, masih dapat diimplementasikan pada FPGA Spartan 3E.
Berdasarkan datasheet dari Xilinx(2007), FPGA tersebut memiliki 20 pengali.
Untuk metode pemasukan data input, tesis ini mengadopsi teknik dari paper Sun,
dkk(1989). Modul DCT hanya memiliki satu port untuk data input selebar 1
byte(8 bit). Data-data input dimasukkan secara sekuensial, bergantian untuk tiap
byte. Metode pipeline untuk pengerjaan DCT 2D dan penyandian entropi
merupakan modifikasi dari metode yang diusulkan oleh Agostini (2001,2002).
Pada dua paper tersebut, operasi aritmetika untuk tiap stage dikerjakan secara
bergantian. Pada tesis ini operasi untuk tiap stage dikerjakan secara paralel.
2.2. Dasar Teori
2.2.1 Kompresi Citra berbasis DCT (Discrete Cosine Transform)
Menurut Wallace(1991), Discrete Cosine Transform dua dimensi (DCT-
2D) digunakan sebagai bagian dari kompresi citra. Menggunakan DCT-2D, nilai-
nilai piksel suatu citra di kawasan spatial akan ditransformasi menjadi suatu
himpunan koefisien DCT di kawasan frekuensi. Sebelum dilakukan operasi
9
10
kompresi, data citra dalam memori dibagi-bagi menjadi beberapa blok MCU
(Minimum Code Unit). Setiap blok terdiri atas 8x8 piksel. Operasi kompresi
termasuk DCT-2D di dalamnya akan dilakukan terhadap setiap blok.
a. DCT satu dimensi
Komputasi DCT-1D N titik ditunjukkan oleh persamaan (2.1)
yn=an∑k=0
N−1
xk cos 2⋅⋅n⋅2k14⋅N
.............................(2.1)
dengan a0 = 1/√N dan an = √(2/N) untuk 1< n < N – 1. Untuk N=8, persamaan
(2.1) dapat dijadikan dalam bentuk perkalian matriks seperti persamaan (2.2)
sebagai berikut:
y = C x
..........(2.2)
dengan cn = cos (nπ/16).
Menurut Arai, dkk (1988), matriks C dapat difaktorisasi menjadi perkalian
beberapa matriks pada persamaan (2.3) sebagai berikut:
C = S * G * F * E * D * B * A ......................................(2.3)
A, B, C, D, E, F, dan G adalah matriks faktor dan S matriks penskala dengan
10
11
A = [0 1 0 0 0 0 1 00 0 0 1 −1 0 0 00 1 0 0 0 0 −1 00 0 1 0 0 1 0 00 0 0 1 1 0 0 00 0 1 0 0 −1 0 00 0 1 0 0 −1 0 01 0 0 0 0 0 0 −1
]B = [
1 0 0 0 0 1 0 00 1 0 0 −1 0 0 00 0 1 0 0 0 1 00 1 0 0 1 0 0 01 0 0 0 0 −1 0 00 0 0 1 0 0 0 10 0 0 1 0 0 1 00 0 0 0 0 0 0 1
]D= [
1 0 0 1 0 0 0 01 0 0 −1 0 0 0 00 0 1 0 0 0 0 00 1 0 0 1 0 0 00 0 1 0 0 −1 0 00 0 0 0 1 0 0 00 0 0 0 0 1 0 00 0 0 0 0 0 1 00 0 0 0 0 0 0 1
]
E = [1 0 0 0 0 0 0 0 00 1 0 0 0 0 0 0 00 0 m3 0 0 0 0 0 00 0 0 0 0 0 0 m1 00 0 0 0 0 0 m4 0 00 0 0 0 0 1 0 0 00 0 0 m1 0 0 0 0 00 0 0 0 m2 0 0 0 00 0 0 0 0 0 0 0 1
]11
12
F= [1 0 0 0 0 0 0 0 00 1 0 0 0 0 0 0 00 0 0 0 0 1 1 0 00 0 0 0 0 1 −1 0 00 0 0 1 0 0 0 0 10 0 0 −1 0 0 0 0 10 0 1 0 0 0 0 1 00 0 0 0 1 0 0 1 0
]
G = [1 0 0 0 0 0 0 00 0 0 0 1 0 0 10 0 1 0 0 0 0 00 0 0 0 0 1 −1 00 1 0 0 0 0 0 00 0 0 0 0 1 1 00 0 0 1 0 0 0 00 0 0 0 1 0 0 −1
]S=0.5 [
c4 0 0 0 0 0 0 00 c7 /c6 0 0 0 0 0 00 0 c6 /c4 0 0 0 0 00 0 0 c5 /c2 0 0 0 00 0 0 0 c4 0 0 00 0 0 0 0 c3/ c2 0 00 0 0 0 0 0 c2/c4 00 0 0 0 0 0 0 c1/c6
] serta
m1= cos (4π/16)
m2= cos (6π/16)
m3= cos (2π/16) - cos (6π/16)
m4= cos (2π/16) + cos (6π/16)
cn = cos (nπ/16).
Kemudian persamaan (2.3) diubah menjadi persamaan (2.4)
Cs = G * F * E * D * B * A ............................................(2.4)
12
13
Tabel 2.1 Langkah-langkah algoritma DCT-1D (Agostini, dkk, 2001)
Step 1: a0 = x0 + x7
a1 = x1 + x6
a2 = x3 – x4
a3 = x1 - x6
a4 = x2 + x5
a5 = x3 + x4
a6 = x2 – x5
a7 = x0 – x7
Step 2: b0 = a0 + a5
b1 = a1 - a4
b2 = a2 + a6
b3 = a1 + a4
b4 = a0 - a5
b5 = a3 + a7
b6 = a3 + a6
b7 = a7
Step 3: d0 = b0 + b3;d1 = b0 - b3;d2 = b2;d3 = b1 + b4;d4 = b2 - b5;d5 = b4;`1d6 = b5;d7 = b6;d8 = b7;
Step 4: e0 = d0;e1 = d1;e2 = m3 * d2;e3 = m1 * d7;e4 = m4 * d6;e5 = d5;e6 = m1 * d3;e7 = m2 * d4;e8 = d8;
Step 5: f0 = e0;f1 = e1;f2 = e5 + e6;f3 = e5 - e6;f4 = e3 + e8;f5 = e8 - e3;f6 = e2 + e7;
f7 = e4 + e7;Step 6: y0 = f0;
y1 = f4 + f7;y2 = f2;y3 = f5 - f6;y4 = f1;y5 = f5 + f6;y6 = f3;y7 = f4 - f7;
13
14
Pada dasarnya Cs pada persamaan (2.4) adalah C pada persamaan (2.3)
tanpa matriks penskala S. matriks S dihilangkan untuk mengurangi jumlah
perkalian pada komputasi DCT. Persamaan (2.4) disebut DCT terskala.
Penskalaan tersebut memungkinkan karena DCT digunakan pada kompresi citra.
Pada kompresi, proses DCT akan diikuti dengan proses kuantisasi. matriks
penskalaan akan diikutkan pada proses kuantisasi.
Agostini, dkk (2001) menjabarkan persamaan (2.4) menjadi suatu langkah-
langkah algoritma DCT-1D. Algoritma DCT-1D 8 titik dapat didefinisikan pada
Tabel 2.1 dengan input x = [ x0 x1 x2 x3 x4 x5 x6 x7 ] dan output y = [ y0 y1 y2 y3 y4 y5 y6
y7 ].
b. DCT 2 dimensi 8X8
Pada DCT 2 dimensi 8X8 titik, masukan dan keluaran adalah berupa
matriks 8X8. Menurut Rao,dkk (1974), komputasi DCT 2 dimensi dikerjakan
melalui persamaan (2.5) sebagai berikut
yv , u =C v2
C u 2 ∑
n=0
7
∑m=0
7
x n ,m cos⋅2m1 ⋅u16
cos ⋅2m1 ⋅u16
,0≤u , v≥7..(2.5)
Jika dibuat dalam notasi matriks, dengan matriks X sebagai input dan Y
sebagai output, DCT 2D memiliki persamaan (2.6) sebagai berikut.
Y = [C] [X] [C]T …..........................................(2.6)
X = matriks input DCT 8x8
Y = matriks input DCT 8x8
C = matriks DCT , sama dengan matriks C pada persamaan (2.1)
Menurut Agostini (2000), komputasi DCT 2D terskala memakai persamaan (2.7).
Y = [S2D] .* [Cs]*[X]*[Cs]T ................................ (2.7)
14
15
dengan
Cs = matriks DCT terskala pada persamaan (2.4)
S2D = matriks penskalaan DCT-2D
“ .* ” = operasi perkalian antar elemen matriks
“ * “ = operasi perkalian matriks biasa
2.2.2. Kompresi Citra Baseline JPEG
Pemampatan Citra JPEG baseline adalah salah satu metode pemampatan
yang lossy atau bersifat menghilangkan informasi terhadap citra input. Nilai
informasi yang terdapat pada citra output akan berkurang. Informasi yang dibuang
pada proses ini adalah koefisien DCT frekuensi tinggi. Bagi mata manusia,
pembuangan frekuensi tinggi tidak berpengaruh pada citra yang diamati (Wallace,
1991). Operasi kompresi meliputi DCT-2D dilanjutkan dengan kuantisasi, zig-zag
dan penyandian entropi. Berdasarkan Miano(1999), diagram lengkap kompresi
JPEG ditunjukkan pada Gambar 2.1.
Gambar 2.1 Diagram kompresi JPEG baseline
Berdasarkan Gambar 2.1, citra yang akan dikompresi dibagi dalam
beberapa blok. Masing-masing blok berukuran 8x8 piksel. Blok-blok inilah yang
akan dimasukkan modul kompresi. Data piksel pada citra disimpan dalam format
bilangan 8 bit tidak bertanda (unsigned) yaitu 0 sampai dengan 255. Meskipun
15
16
demikian, berdasarkan spesifikasi JPEG (Solomon,2004) data citra yang akan
dikompresi dikurangi terlebih dahulu dengan 128 untuk membuat suatu bilangan
unsigned menjadi bilangan signed. Masing-masing blok akan mengalami proses
DCT-2D 8x8, kuantisasi, dan entropy encoding.
a. Operasi kuantisasi
Pada kompresi citra JPEG lossy (Wallace, 1991) Operasi kuantisasi
dilakukan untuk menghilangkan komponen-komponen frekuensi tinggi dari citra
hasil DCT-2D. Untuk melakukan operasi ini, citra hasil DCT dibagi dengan suatu
nilai yang sudah terdefinisi pada tabel kuantisiasi. Tabel kuantisasi disajikan
dalam bentuk matriks 8x8 seperti pada persamaan (2.8). Nilai pembagi dalam
matriks kuantisasi ditunjukkan pada Tabel 2.2.
Tabel 2.2 Nilai-nilai pada matriks kuantisasi untuk citra grayscale, atau
komponen luminance.
Q = [q00 q01 q02 q03 q04 q05 q06 q07
q10 q11 q12 q13 q14 q15 q16 q17
q20 q21 q22 q23 q24 q25 q26 q27
q30 q31 q32 q33 q34 q35 q36 q37
q40 q41 q42 q43 q44 q45 q46 q47
q50 q51 q52 q53 q54 q55 q56 q57
q60 q61 q62 q63 q64 q65 q66 q67
q70 q71 q72 q73 q74 q75 q76 q77
] …................(2.8)
Proses kuantisasi ditunjukkan pada persamaan (2.9) berikut:
16
17
yq mn = integer_round (ymn / qmn)...............................(2.9)
dengan yq = nilai terkuantisasi dan y = nilai sebelum dikuantisasi. Kuantisasi
menyebabkan citra kehilangan sebagian dari informasinya. Nilai informasi yang
dikurangi adalah komponen frekuensi tinggi spatial. Menurut Magli (2004),
pengurangan komponen frekuensi tinggi spatial tidak mempengaruhi persepsi
visual mata terhadap citra. Nilai kuantisasi yang terdapat pada Tabel 2.2
merupakan rekomendasi yang dikeluarkan oleh CCITT (Consultative Comitee of
International Telegraph and Telephone) pada dokumen T.81 (Magli, 2004). Sesuai
dengan kualitas kompresi yang dibutuhkan, nilai-nilai pada tabel kuantisasi dapat
diatur. Kualitas kompresi diukur dalam skala 1 sampai 99 dan dihitung
menggunakan persamaan 2.10. Matriks kuantisasi pada Tabel 2.2 digunakan
sebagai basis.
α = faktor kompresi
q_JPEG = kualitas kompresi ( 1 < q_JPEG < 99).
Nilai α kemudian dikalikan dengan matriks kuantisasi pada Tabel 2.2
untuk menghasilkan matriks kuantisasi sesuai kualitas kompresi yang diinginkan.
Matriks kuantisasi pada Tabel 2.2 mempunyai kualitas kompresi 50.
b. Operasi zigzag
Data hasil kompresi akan dikeluarkan secara sekuensial pada kompresi
JPEG standar. Urutan pengeluaran data disusun secara zig-zag(Wallace,1991) dan
secara grafis ditunjukkan oleh Gambar 2.2.
17
...............(2.10)
18
Gambar 2.2 Urutan pengeluaran data secara zig-zag pada standar JPEG
Urutan data yang dikeluarkan pada suatu matriks 8 x 8 ditunjukkan secara
numeris pada Gambar 2.3. Data yang keluar pertama kali dari proses zig-zag
adalah koefisien DC, yang disusul 63 koefisien AC. Urutan pengeluaran data
seperti pada Gambar 2.2 dan Gambar 2.3 adalah, DC, AC01, AC10, AC20,
AC11, ..., AC67, AC76, AC77. Gambar 2.3 menunjukkan suatu memori dua
dimensi yang menyimpan koefisien-koefisien DCT yang terkuantisasi. Nomor-
nomor yang ditampilkan pada Gambar 2.3 merupakan nomor urut keluarnya
koefisien-koefisien tersebut dari memori.
c. Entropy Coding
Koefisien-koefisien yang menjadi output unit zig-zag akan menjadi input
bagi unit entropy coding. Pada bagian inilah proses pemampatan data
berlangsung. Kode yang digunakan dalam penyandian koefisien-koefisien adalah
kode Huffman. Kode Huffman secara eksplisit memetakan simbol input pada
suatu kata sandi. Simbol input yang mempunyai peluang paling besar dikodekan
dengan kata sandi yang paling pendek. Sementara itu, simbol input dengan
peluang terkecil dikodekan dengan kata sandi yang panjang. Penyandian Huffman
untuk JPEG tidak dilakukan melalui operasi matematis atau perhitungan
18
19
probabilitas, melainkan langsung menggunakan suatu look-up table (Salomon,
2004).
Gambar 2.3 Visualisasi pengeluaran data zig-zag secara numeris(Salomon, 2004)
Koefisien DC disandikan terpisah dan berbeda dengan koefisien AC.
Representasi koefisien DC yang dipakai adalah selisih antara koefisien DC blok
yang satu dengan koefisien DC blok sebelumnya. Misalnya koefisien DC blok
0,1, dan 2 berturut-turut 20, 18, dan 22, maka representasi koefisien DC yang
akan disandikan adalah 20, -2, dan -4. Selisih ini disandikan dengan kode
Huffman.
Penyandian Huffman dilakukan dengan memetakan bilangan yang akan
dikodekan menggunakan Tabel 2.3. Untuk menentukan kata sandinya, koefisien
DC ditentukan letak barisnya berdasarkan interval tempat bilangan itu berada.
Berdasarkan Tabel 2.3, setelah diketahui letak baris, akan diketahui juga unary
code dari bilangan itu. Langkah berikutnya adalah menentukan letak kolom
bilangan tersebut pada tabel, dan mengkonversi letak kolom ke dalam bilangan
biner. Sandi untuk koefisien DC didapat dengan menggabungkan nilai biner unary
code dengan nilai biner letak kolom.
19
20
Tabel 2.3 Kode Huffman untuk pemetaan simbol dan kategori koefisien DC dan
AC (Salomon, 2004)
Sebagai contoh, bilangan yang akan dikodekan adalah -2. Bilangan
tersebut terletak pada baris 2 (dihitung dari 0) dan mempunyai unary code 110.
Nilai -2 terletak pada kolom 1 interval. Nilai biner 2 bit dari bilangan 1 adalah 01.
Sehingga kode untuk nilai -2 adalah 110|01.
Tabel 2.4 Kode Huffman luminance citra untuk komponen DC(a) dan AC(b)
(a)
Cat Code word
0 00
1 010
2 011
3 100
4 101
5 110
6 1110
7 11110
8 111110
9 11111110
10 111111110
11 11111111110
20
21
(b)
Koefisien AC disandikan dengan gabungan sandi RLE (Run Length
Encoding) dan Huffman. Deret yang berisi koefisien AC normalnya mempunyai
banyak nilai nol di dalamnya dan hanya ada beberapa nilai nonzero.
Berikut adalah proses penyandian adalah untuk setiap bilangan nonzero (x).
1. Menghitung jumlah nol (Z) sebelum bilangan tersebut.
2. Memetakan x pada Tabel 2.3 dan menentukan letak kolom dan baris (R dan C).
3. Pasangan (R,Z) digunakan untuk menentukan baris dan kolom pada Tabel
2.4(b).
4. Kode Huffman dari baris dan kolom step (3) digabungkan ke C.
21
22
Hasil dari proses tersebut adalah sandi RLE-Huffman untuk koefisien AC x dan
bilangan nol sebelum koefisien tersebut.
2.2.3. FPGA (Field Programmable Gate Array) XC3S500E
XC3S500E merupakan keluarga FPGA dari seri Spartan 3E. Spartan 3E
mampu mendukung sistem dengan kecepatan clock hingga 300 MHz. Piranti
tersebut dilengkapi dengan RAM di dalam chip dan dekoder input yang lebar
sehingga lebih berdaya guna untuk aplikasi-aplikasi sistem digital. Spartan 3E
juga dilengkapi dengan blok pengali dengan jumlah berkisar 4 sampai 36.
Keluarga Spartan 3E mempunyai beberapa varian dengan kapasitas berkisar
100.000 sampai 1.600.000 gerbang. Pada tesis ini digunakan XC3S500E yang
mempunyai parameter seperti pada Tabel 2.5 berikut.
Tabel 2.5 Parameter-parameter FPGA Xilinx XC3S500E.
PARAMETER XC3S500Ejumlah gerbang 500.000
jumlah CLB 1164jumlah blok RAM 360 Kbjumlah max IOB 232Jumlah pengali 20
2.2.4. Perangkat Lunak Yang Berhubungan Dengan Perancangan FPGA
Penggunaan perangkat lunak dalam suatu perancangan sistem elektronis
bertujuan untuk memperoleh efisiensi dalam hal sintesis dan optimalisasi
rancangan. Karakter suatu rancangan dapat diketahui sebelum diimplementasikan
dalam bentuk perangkat keras sehingga memudahkan untuk melakukan perbaikan
terhadap rancangan tersebut.
Berdasarkan pedoman yang didokumentasikan oleh Xilinx (2007),
rancangan suatu sistem digital yang akan diimplementasikan dalam bentuk
22
23
perangkat keras menggunakan FPGA dibuat melalui beberapa tahap sebagai
berikut.
1. Pembuatan desain (Design Entry), yaitu proses pembuatan rangkaian yang
akan diimplementasikan menggunakan FPGA.
2. Verifikasi desain (Design Verification), yaitu memerikasa desain yang telah
dibuat dengan cara simulasi.
3. Pemetaan, penempatan dan routing desain (Mapping, placing and routing),
yaitu pemetaan gerbang, penempatan pin dan routing pembuatan jalur jalur
koneksi desain ke dalam FPGA.
4. Implementasi desain (Design Imlementation), yaitu mengimplementasikan
rancangan dalam bentuk perangakat keras.
Langkah-langkah tersebut dapat dilakukan dengan bantuan perangkat lunak
komputer yaitu Xilinx ISE 10.
Pembuatan desain (rangkaian) bisa dilakukan secara skematis atau
menggunakan VHDL (Very High Speed IC Description Language). Pada desain
menggunakan skematis, pengguna software menggambar rangkaian menggunakan
simbol-simbol rangkaian digital pada lembar gambar Xilinx ISE. Penggunaan
skematis ini efisien untuk rangkaian-rangkaian yang sederhana atau dengan
kompleksitas rendah.
VHDL merupakan tool desain rangkaian digital yang menggunakan
sintaks bahasa pemrograman. Bahasa pemrograman tersenut digunakan untuk
mendefinisikan kerja rangkaian. VHDL sesuai untuk rangkaian dengan
kompleksitas tinggi, seperti yang dirancang pada tesis ini. Untuk mendeasain
23
24
rangkaian yang kompleks, VHDL cukup efektif, karena pengguna cukup
mendefiniskan kerja rangkaian saja dan tidak perlu menggambar realisasi
rangkaiannya.
2.3. Hipotesis
1. Rangkaian penyandi JPEG baseline dapat diterapkan pada satu keping
FPGA Xilinx Spartan-3E XC3S500E menggunakan algoritma DCT
Agostini (2001) dan teknik komputasi sekuensial-pipeline.
2. Selain untuk kompresi citra diam dalam format JPEG, rangkaian dapat
digunakan untuk kompresi citra bergerak dalam format Motion JPEG.
3. Rasio kompresi yang dihasilkan oleh rangkaian yang dirancang dapat
menyamai rasio kompresi yang dihasilkan oleh software kompresi
komersial untuk input citra yang sama.
4. Frame rate yang dapat dicapai oleh rangkaian yang dirancang dapat
menyamai frame rate IC komersial dan intellectual property untuk
kompresi JPEG baseline pada tabel 1.1.
24
25
BAB III
METODA PENELITIAN
3.1. Bahan Penelitian
Bahan penelitian terdiri atas :
a. FPGA Spartan-3E starter board
Keping XC3S500E mempunyai 500.000 gerbang dengan jumlah CLB sebesar
1164, IOB sebesar 232 pengali sebanyak 20 unit, dan interkoneksi yang dapat
diprogram.
b. ARM7 Development Board
Sistem komputer berbasis mikrokontroler ARM7 yang digunakan untuk
mengeluarkan data-data uji ke FPGA. Piranti ini dipilih karena memiliki general
purpose I/O.
3.2. Alat Penelitian
Alat penelitian terdiri atas :
a. Satu set komputer Pentium 4
b. Satu perangkat lunak Sistem Operasi Linux.
c. Satu perangkat lunak Xilinx ISE 10.1
3.3. Jalan Penelitian
Pelaksanaan penelitian dimulai dengan merancang gambaran keseluruhan
sistem. Piranti kompresi data pada penelitian ini tersusun atas enam modul yang
saling terhubung sesuai Gambar 3.1. Enam modul itu adalah modul DCT-2D,
zigzag buffer, quantizer, penyandi entropi, byte stuffer, dan unit pengendali.
Masing-masing modul dirancang dan saling dihubungkan menggunakan bahasa
VHDL pada perangkat lunak Xilinx ISE.
25
26
3.3.1. Perancangan sistem secara global
Gambar 3.1 Interkoneksi modul-modul dalam piranti kompresi
Data input merupakan piksel-piksel citra yang akan dikompresi. Sesuai
dengan spesifikasi JPEG yang dijelaskan pada Bagian 2.2.2, data piksel citra yang
akan dikompresi sebelumnya dikurangi terlebih dahulu dengan 128 untuk
mendapatkan format bilangan signed. Data piksel dengan format signed tersebut
kemudian dimasukkan byte demi byte ke dalam unit kompresi JPEG. Berikut ini
keterangan singkat mengenai masing-masing modul.
a. DCT 1D, transpose buffer, dan DCT 2D
Unit kompresi diawali dengan operasi DCT 2 Dimensi. Operasi DCT 2
dimensi (DCT-2D) dikerjakan menggunakan dua modul DCT 1 dimensi yang
dihubungkan melalui transpose buffer. DCT 1D diterapkan pada setiap 8 titik data
yang masuk. Data hasil DCT 1D disimpan di dalam transpose buffer. Data
dikeluarkan dari transpose buffer dalam urutan yang ter-transpose untuk masuk
ke modul DCT 1D berikutnya. Keluaran modul DCT 1D yang kedua merupakan
hasil operasi DCT 2D atau koefisien DCT 2D dari data masukan.
b. Zigzag buffer
Koefisien DCT 2D disimpan dalam zigzag buffer. Data yang tersimpan
dalam zigzag buffer akan dikeluarkan secara zigzag untuk masuk pada operasi
26
27
selanjutnya, yaitu kuantisasi. Koefisien DCT 2D dikeluarkan secara zigzag untuk
diurutkan berdasarkan komponen frekuensinya. Koefisien yang dikeluarkan
terlebih dahulu merupakan komponen frekuensi yang lebih rendah daripada
komponen yang dikeluarkan selanjutnya.
c. Quantizer
Proses kompresi pada dasarnya dimulai pada bagian ini. Keluaran zigzag
buffer yang merupakan koefisien DCT 2D, satu persatu dibagi dengan suatu
bilangan sesuai dengan urutannya. Bilangan pembagi tersebut terdapat pada tabel
kuantisasi (Tabel 2.2) sesuai dengan spesifikasi JPEG baseline. Keluaran modul
ini merupakan koefisien DCT 2D yang telah terkuantisasi dan memiliki lebar bit
yang lebih kecil dari koefisien semula. Komponen frekuensi tinggi dibagi dengan
bilangan yang lebih besar, sehingga koefisien yang terkuantisasi memiliki nilai
yang besar pada frekuensi rendah dan kecil atau bahkan nol pada frekuensi tinggi.
d. Entropy Encoder
Entropy encoder (penyandi entropi) menyandikan koefisien DCT 2D yang
sudah terkuantisasi dan diurutkan secara zigzag. Penyandian entropy pada JPEG
merupakan kombinasi Run Length Encoder (RLE) pada koefisien-koefisien
bernilai nol dan sandi Huffman. Penyandi ini menghasilkan kode untuk masing-
masing kofisien dalam dengan panjang variabel. Panjang kode ditentukan oleh
tabel kode Huffman yang telah didefinisikan dalam rangkaian. Walaupun panjang
sandi variabel, tetapi lebar bit keluaran penyandi entropi dibuat tetap dengan
menambahkan isyarat yang menyatakan panjang sandi.
e. Byte stuffer
Penyandi entropi menghasilkan sandi dengan panjang variabel, karena itu
27
28
data hasil kompresi dikeluarkan menuju pinout rangkaian tiap satu bit. Byte
stuffer digunakan untuk mengeluarkan hasil penyandian entropi satu demi satu bit.
Keluaran unit ini sudah merupakan data yang terkompresi.
f. Pengendali (controller)
Unit pengendali dihubungkan pada isyarat status, kendali, dan isyarat
alamat pada masing-masing modul. Unit ini berfungsi menerjemahkan isyarat
status dari masing-masing unit dan menghasilkan isyarat kendali dan alamat untuk
unit yang lain sehingga masing-masing unit bekerja secara sinkron.
3.3.2. Perancangan algoritma dan modul DCT 1 D
Algoritma DCT satu dimensi yang akan dipakai dalam penelitian ini
mengikuti langkah-langkah yang didefinisikan pada Tabel 2.1. Langkah-langkah
tersebut sudah dirancang oleh Agostini, dkk (2001) yang berdasar pada algoritma
usulan Arai, dkk(1989). Signal flow graph algoritma Arai ditunjukkan pada
Gambar 3.2 yang didasarkan pada Tabel 2.1. Pada Gambar 3.2, x adalah vektor
iyarat input. Vektor a, b, d, e, f adalah isyarat-isyarat yang menjadi input dan
output pada masing-masing step algoritma. Vektor f adalah isyarat output. Sesuai
dengan algoritma pada Tabel 2.1, vektor a yang menjadi isyarat keluaran step 1
merupakan hasil olahan dari vektor input x. Vektor b merupakan hasil olahan step
2 dengan masukan vektor a, dan begitulah seterusnya untuk vektor d, e, f yang
merupakan hasil olahan step algoritma Arai pada Tabel 2.1. Pada akhirnya, step 6
digunakan untuk mengolah isyarat f menjadi vektor output y.
Karena modul digunakan untuk mengolah 8 titik, maka lebar bit maksimal
data output dapat dihitung sebagai berikut:
• Nilai maksimal untuk tiap titik masukan adalah 28 – 1 = 255 (semua bit
28
29
bernilai '1')
• Nilai maksimal keluaran untuk pengolah 8 titik adalah 8 x 255 = 2040
• Bilangan biner unsigned untuk 2040 adalah 11111111000 yang mempunyai
lebar 11 bit
Dari uraian tersebut didapatkan lebar output 11 bit. Secara umum dapat
dirumuskan menjadi persamaan (3.1) sebagai berikut:
lebar_out = lebar_in + 2log(jumlah_titik)...................(3.1)
Gambar 3.2 Signal flow graph algoritma DCT Arai
Metode akuisisi data input dan pengeluaran output ini diadopsi dari
rancangan Sun, dkk(1989) dan ditunjukkan pada Gambar 3.3. Data input
dimasukkan secara sekuensial pada register-register input setiap transisi clock
naik. Karena DCT 1D mengolah 8 titik data, maka dibutuhkan 8 kali siklus clock
29
a b d e fx ya
30
untuk memasukkan seluruh data. Begitu pula dengan proses pengeluaran data
yang dilakukan secara sekuensial. Seluruh data dikeluarkan dalam 8 siklus clock.
Jadi, waktu yang dibutuhkan dari proses akuisisi data input sampai pengeluaran
output adalah 8 (akuisisi input) ditambah 6(komputasi DCT) dan ditambah
8(pengeluaran) yaitu 22 siklus clock. Berdasarkan Gambar 3.3, pada tesis ini
dirancang operasi-operasi aritmetika pada setiap step algoritma DCT untuk
dikerjakan secara paralel pada tiap transisi positif clock.
3.3.3. Perancangan pipeline modul DCT-1D.
Menurut Lu, dkk(2009), pipelining adalah teknik implementasi algoritma
komputasi pada suatu piranti, yang membuat beberapa instruksi dikerjakan dalam
waktu bersamaan (overlap). Kebalikan dari teknik pipeline ini adalah single-cycle
execution yang hanya mengerjakan satu instruksi pada satu siklus.
Gambar 3.3 Proses akusisi input, komputasi, dan pengeluaran output DCT-1D
Modul DCT-1D pada tesis ini bekerja secara sekuensial. Ada dua pilihan
untuk merealisasikan sistem komputasi sekuensial ini, yang pertama dengan cara
30
31
single-cycle, yang kedua dengan pipelining. Komputasi DCT-1D sekuensial secara
single-cycle akan mengurangi pesat data yang dapat diproses. Sesuai dengan
ilustrasi proses single cycle pada Gambar 3.4, akuisisi (pemasukan) data hanya
terjadi pada saat clock ke-1 hingga ke 8. Pada fase komputasi dan pengeluaran
data output, akuisisi data tidak terjadi, dan saat itu, data tidak diperbolehkan untuk
masuk ke dalam modul. Jika ada kelompok 8 titik data berikutnya yang akan
diproses, harus ditunggu sampai fase pengeluaran data output selesai. Visualisasi
proses single cycle ditunjukkan pada Gambar 3.4. Pada komputasi yang
dikerjakan secara pipeline, dalam satu siklus clock ada beberapa proses yang
dikerjakan bersamaan. Berkaitan dengan modul DCT yang dirancang, dengan
pipeline, proses akuisisi data, komputasi DCT dan pengeluaran data dapat
berlangsung bersamaan. Karena itu, pesat data yang masuk dan keluar dari modul
menjadi lebih besar dari proses single cycle. Dalam tesis ini, dirancang suatu
komputasi DCT yang dapat dikerjakan secara pipeline.
Gambar 3.4 Visualisasi proses DCT-1D dengan eksekusi single-cycle
Dalam merancang suatu proses pipeline, diperlukan metode penempatan
proses pada waktu yang tepat. Hal itu disebabkan suatu proses memerlukan suatu
prasyarat proses sebelumnya, yang harus selesai terlebih dahulu. Misalnya, suatu
komputasi DCT 8 titik baru dapat dikerjakan setelah kedelapan data input sudah
31
32
diakuisisi, kemudian data output baru dapat dikeluarkan setelah komputasi DCT
selesai. Untuk dapat memenuhi kebutuhan tersebut, proses pipeline untuk modul
DCT-1D dirancang sesuai timing diagram yang disederhanakan pada Gambar
3.5. Sesuai Gambar 3.5, terdapat 3 stage pipeline yang dirancang, yaitu akuisisi
data input, komputasi DCT, dan pengeluaran data. Pada saat akuisisi kelompok
data input pertama (8 titik pertama), komputasi DCT dan pengeluaran data belum
berjalan. Komputasi DCT untuk kelompok data pertama dilakukan bersamaan
dengan akuisisi kelompok data ke-2. Karena komputasi DCT 1D hanya
membutuhkan 6 clock dan proses input membutuhkan 8 clock, pada proses
komputasi DCT 1D setelah clock ke-6 terdapat daerah idle. Pada saat itu, yang
dikerjakan hanya akuisisi data ke-7 dan ke-8 pada kelompok data ke-2. Proses
pipeline yang lengkap dilakukan pada akuisisi kelompok data ke-3. Akuisisi
kelompok data ke-3 dilakukan bersamaan dengan komputasi DCT 1D untuk
kelompok data ke-2 dan pengeluaran data output DCT untuk kelompok pertama.
Rancangan proses pipeline DCT tersebut kemudian dibuat dalam bentuk
tabel pipeline. Tabel pipeline akan menjadi panduan dalam implementasi
rangkaian dalam bentuk VHDL. Rancangan pipeline ditunjukkan pada Tabel 3.1.
Pada Tabel 3.1 terdapat perulangan proses setiap 8 clock. Mulai siklus
clock yang ke-17, sudah terdapat pipeline stage yang lengkap, yang terdiri dari
input data, komputasi DCT, dan output data. Berdasarkan Tabel 3.1, implementasi
pada VHDL dimulai dari clock ke-17. Karena terjadi perulangan setiap 8 clock,
pada implementasi di VHDL, proses dibagi dalam 8 state. Tiap state dikerjakan
dalam satu siklus clock. Implementasi proses dalam state ditunjukkan pada Tabel
3.2.
32
33
Gambar 3.5 Rancangan timing diagram proses pipeline DCT-1D
Tabel 3.1 Tabel pipeline modul DCT-1D
Tabel 3.2 Delapan state sebagai acuan implementasi
Menggunakan acuan Tabel 3.2, kemudian dapat dibuat kode VHDL dalam delapan
state sebagai berikut.
• Implementasi state ke-0
33
clock ke- 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40en_dct 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
dct_rdy 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
pipeline stage1 x0 x1 x2 x3 x4 x5 x6 x7 s1 s2 s3 s4 s5 s6 y0 y1 y2 y3 y4 y5 y6 y7 - -2 x0 x1 x2 x3 x4 x5 x6 x7 s1 s2 s3 s4 s5 s6 y0 y1 y2 y3 y4 y5 y6 y7 - -3 x0 x1 x2 x3 x4 x5 x6 x7 s1 s2 s3 s4 s5 s6 y0 y1 y2 y3 y4 y5 y6 y7 - -… n
xn = proses input data ke-nsn = step ke-n algoritma DCT 1Dyn = proses pengeluaran data ke-n
kelompok data ke-
state 0 1 2 3 4 5 6 7y2 y3 y4 y5 y6 y7 - -s1 s2 s3 s4 s5 s6 y0 y1x0 x1 x2 x3 x4 x5 x6 x7
proses yang dikerjakan
34
case cnt is when "0000" => -- state ke-0
vin_0<=vin(n)&vin(n)&vin(n)&vin;-->akuisisi x0 ---------------------------------- b0<=vin_0+vin_7; -->komputasi step 1 algoritma DCT b1<=vin_1+vin_6; b2<=vin_3-vin_4; b3<=vin_1-vin_6; b4<=vin_2+vin_5; b5<=vin_3+vin_4; b6<=vin_2-vin_5; b7<=vin_0-vin_7; ---------------------------------- vout<=s2(p+k downto p)+ofset2;-->pengeluaran y2• Implementasi state ke-1when "0001" =>
vin_1<=vin(n)&vin(n)&vin(n)&vin; --> akuisisi data input x1---------------------------------- c0<=b0+b5; --> komputasi step 2 c1<=b1-b4; c2<=b2+b6; c3<=b1+b4; c4<=b0-b5; c5<=b3+b7; c6<=b3+b6; c7<=b7; ---------------------------------- vout<=s3(p+k downto p)+ofset3; --> pengeluaran output y3
• Implementasi state ke-2when "0010" =>
vin_2<=vin(n)&vin(n)&vin(n)&vin; --> akuisisi data input x2 ---------------------------------- d0<=c0+c3; -->komputasi step 3 algoritma DCT d1<=c0-c3; d2<=c2; d3<=c1+c4; d4<=c2-c5; d5<=c4; d6<=c5; d7<=c6; d8<=c7; ---------------------------------- vout<=s4(p+k downto p)+ofset4;--> pengeluaran output y4
• Implementasi state ke-3when "0011" =>
vin_3<=vin(n)&vin(n)&vin(n)&vin; --> akuisisi data input x3 ---------------------------------- e0<=d0(k)&d0(k)&d0&"000000000000"; -->komputasi step 4 e1<=d1(k)&d1(k)&d1&"000000000000"; e2<=m3*d2; e3<=m1*d7;
34
35
e4<=m4*d6; e5<=d5(k)&d5(k)&d5&"000000000000"; e6<=m1*d3; e7<=m2*d4; e8<=d8(k)&d8(k)&d8&"000000000000"; ---------------------------------- vout<=s5(p+k downto p)+ofset5;--> pengeluaran output y5
• Implementasi state ke-4when "0100" =>
vin_4<=vin(n)&vin(n)&vin(n)&vin;--> akuisisi data input x4 ---------------------------------- f0<=e0; -->komputasi step 5 algoritma DCT f1<=e1; f2<=e5+e6; f3<=e5-e6; f4<=e3+e8; f5<=e8-e3; f6<=e2+e7; f7<=e4+e7; ----------------------------------
vout<=s6(p+k downto p)+ofset6;--> pengeluaran output y6• Implementasi state ke-5when "0101" =>
vin_5<=vin(n)&vin(n)&vin(n)&vin;--> akuisisi data input x5 ---------------------------------- s0<=f0; -->komputasi step 6 algoritma DCT s1<=f4+f7; s2<=f2; s3<=f5-f6; s4<=f1; s5<=f5+f6; s6<=f3; s7<=f4-f7;
ofset0(k downto 1)<=(others=>'0'); ofset0(0)<=f0(p-1); ofset4(k downto 1)<=(others=>'0'); ofset4(0)<=f1(p-1); ofset2(k downto 1)<=(others=>'0'); ofset2(0)<=f2(p-1); ofset6(k downto 1)<=(others=>'0'); ofset6(0)<=f3(p-1);
---------------------------------- vout<=s7(p+k downto p)+ofset7;--> pengeluaran output y7
----------------------------------
• Implementasi state ke-6when "0110" =>
vin_6<=vin(n)&vin(n)&vin(n)&vin; --> akuisisi data input x6 ---------------------------------- vout<=s0(p+k downto p)+ofset0; -->pengeluaran output y0
ofset1(k downto 1)<=(others=>'0'); ofset1(0)<=s1(p-1);
35
36
ofset3(k downto 1)<=(others=>'0'); ofset3(0)<=s3(p-1); ofset5(k downto 1)<=(others=>'0'); ofset5(0)<=s5(p-1); ofset7(k downto 1)<=(others=>'0'); ofset7(0)<=s7(p-1);
• Implementasi state ke-7 when others =>
vin_7<=vin(n)&vin(n)&vin(n)&vin;--> akuisisi data input x7 ---------------------------------- vout<=s1(p+k downto p)+ofset1; --> pengeluaran output y1 ----------------------------------
3.3.4. aritmetika komputasi DCT-1D
a. Operasi aritmetika secara umum
Operasi aritmetika pada komputasi DCT-1D terdiri dari penjumlahan,
pengurangan, dan perkalian. Dalam melakukan operasi-operasi tersebut, pada
tesis ini tidak dirancang untai atau modul khusus untuk penjumlah, pengurang,
dan pengali khusus. Rancangan DCT pada tesis ini memakai modul aritmetika
yang sudah tersedia di dalam FPGA. Penggunaan modul-modul aritmetika di
dalam VHDL cukup dilakukan dengan menuliskan operator aritmetika yang lazim
digunakan, seperti '+' untuk penjumlahan, ' - ' untuk pengurangan, dan ' *' untuk
perkalian. Supaya dalam VHDL dapat digunakan operasi-operasi aritmetika untuk
bilangan bertanda, digunakan library VHDL yang mendukung, yaitu
std_logic_arith, std_logic_signed, dan numeric_std. Berikut ini adalah
deklarasi library dalam VHDL.
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
36
37
b. Operasi perkalian
Pengali yang digunakan pada tesis ini adalah pengali internal yang terdapat pada
FPGA. Sebelum memutuskan untuk memakai pengali internal, perlu
diperhitungkan jumlah pengali yang dibutuhkan untuk keseluruhan operasi
kompresi JPEG. Letak-letak perkalian ada pada modul-modul berikut.
• Modul DCT-1D pertama : 5 perkalian
• Modul DCT-1D kedua : 5 perkalian
• Modul kuantisasi : 1 perkalian, karena kuantisasi dilakukan secara
sekuensial.
Berdasarkan uraian tersebut, jumlah pengali yang dibutuhkan ada 11 unit.
Sementara, pengali yang terdapat di dalam FPGA Spartan 3E XC3S500E ada 20
unit. Oleh karena itu, jumlah pengali yang ada di dalam FPGA sudah mencukupi
untuk keseluruhan operasi, sehingga tidak perlu membuat modul pengali
tersendiri.
Pengali yang terdapat pada algoritma DCT maupun proses kuantisasi
merupakan bilangan pecahan. Oleh karena itu untuk menjalakan proses perkalian,
bilangan pecahan diubah terlebih dahulu menjadi bilangan integer melalui
perkalian dengan suatu bilangan penskala 2n. Pada tesis ini, bilangan penskala
untuk komputasi DCT adalah 4096.
Bilangan pengali yang digunakan pada algoritma DCT1D Arai adalah
sebagai berikut.
m1 = cos(4*π/16) = 0.70711
m2 = cos(6*π/16) = 0.38268
37
38
m3 = cos(2*π/16) � cos(6*π/16) = 0.54120
m4 = cos(2*π/16)+cos(6*π/16) = 1.3066
Representasi integer dari bilangan pengali diperoleh dengan mengalikan
bilangan tersebut dengan 212 dan dibulatkan ke bilangan integer terdekat sebagai
berikut. Bilangan yang didapat disandikan dalam bilangan 14 bit bertanda.
m1' = round(m1*4096) = 2896 = 00101101010000b,
m2' = round(m2*4096) = 1568 = 00011000100000b,
m3' = round(m3*4096) = 2217 = 00100010101001b,
m4' = round(m4*4096) = 5352 = 01010011101000b.
Proses perkalian dilakukan antara bilangan 11 bit keluaran step 3 dengan
pengali. Hasil kali disimpan dalam bilangan 24 bit. Bilangan yang tidak dikalikan,
digeser ke kiri 12 bit. Berikut implementasi perkalian dalam VHDL.
e0<=d0(k)&d0(k)&d0&"000000000000"; e1<=d1(k)&d1(k)&d1&"000000000000"; e2<=m3*d2; e3<=m1*d7; e4<=m4*d6; e5<=d5(k)&d5(k)&d5&"000000000000"; e6<=m1*d3; e7<=m2*d4; e8<=d8(k)&d8(k)&d8&"000000000000";
Untuk mendapatkan hasil kali yang sebenarnya, hasil kali diskala ulang
dengan cara dibagi lagi dengan 4096 (212). Proses pembagian dilakukan dengan
menggeser 12 bit ke kanan. Penggeseran dilakukan pada saat data akan
dikeluarkan ke output. Proses pembagian ini disertai dengan pembulatan.
Pembulatan dilakukan ke bilangan bulat terdekat. Bilangan 0.5 ke atas dibulatkan
menjadi 1 dan bilangan kurang dari 0.5 dibulatkan menjadi 0. Teknis pembulatan
38
39
dilakukan sebagai berikut.
• Bilangan hasil kali mempunyai lebar 25 bit. Hasil kali yang diharapkan
hanya selebar 11 bit. Dari 25 bit tersebut, diambil bit 12 sampai 22.
• Untuk melakukan pembulatan bilangan pada kelompok bit 22 downto 12
dijumlahkan dengan bit ke 11.
Berikut adalah implementasi teknik tersebut dalam VHDL untuk komputasi
keluaran y1.
ofset1(10 downto 1)<=(others=>'0'); ofset1(0)<=s1(11);vout<=s1(22 downto 12)+ofset1;
3.3.5. Perancangan DCT-2D
Komputasi DCT-2D dilakukan berdasarkan persamaan 2.7. Karena yang
akan diproses adalah DCT-2D yang terskala, matriks penskala S2D belum
dikalikan terlebih dahulu. Penghitungan DCT-2D merupakan dua tingkat operasi
DCT-1D yang disusun sedemikian rupa. Input DCT-1D tingkat kedua berasal dari
output DCT-1D tingkat pertama. Jumlah titik operasi kedua DCT sama, yaitu 8
titik. Karena output DCT tingkat pertama mempunyai lebar 10 bit, input DCT
tingkat kedua juga mempunyai lebar 10 bit dan output DCT tingkat kedua
memiliki lebar 10 ditambah 2log 8 yaitu 13 bit.
DCT-1D pada tingkat yang pertama mengoperasikan data-data pada tiap
baris citra input. Pada DCT-1D tingkat ke-2, inputnya adalah keluaran DCT-1D,
tetapi dioperasikan secara per kolom. Hal ini menghendaki suatu operasi
transpose terhadap keluaran DCT-1D tingkat pertama. Untuk melakukan
transpose, data keluaran tingkat pertama dimasukkan ke dalam suatu memori
terlebih dahulu. Setelah sejumlah data output DCT 1-D untuk baris masuk ke
39
40
dalam memori, data dari memori tersebut dikeluarkan satu persatu secara ter-
transpose. Ter-transpose berarti data dikeluarkan secara per kolom. Akses
terhadap memori tersebut dikendalikan oleh sebuah controller. Skema
interkoneksi dua modul DCT-1D ditampilkan pada Gambar 3.6.
Gambar 3.6 Skema interkoneksi 2 stage DCT-1D
3.3.6. Perancangan Transpose Buffer
Modul transpose buffer dirancang dari suatu RAM statis. Transpose buffer
memiliki jalur data dan alamat. Data tulis dan baca memiliki urutan yang berbeda.
Karena itu, modul ini dirancang memiliki pasangan jalur data dan alamat yang
terpisah untuk masing-masing operasi baca dan tulis. Rancangan modul transpose
buffer ditunjukkan pada Gambar 3.7. Proses tulis dan baca data pada transpose
buffer dideskripsikan pada Gambar 3.8.
Satu blok data pada DCT mempunyai ukuran 8x8 atau 64 byte. Transpose
buffer dirancang untuk dapat menampung dua blok data atau 128 byte. Fungsinya
adalah supaya ketika blok pertama baru dibaca, keluaran DCT-1D berikutnya
dapat ditampung di blok kedua.
40
41
Gambar 3.7 Rancangan modul transpose buffer
Gambar 3.8 Susunan data input dan output pada transpose buffer: Kotak putih menggambarkan jalur input, kotak abu-abu menggambarkan output.
Perancangan transpose buffer dilakukan dengan membuat deskripsi dalam
bahasa VHDL sesuai dengan Gambar 3.7 dan 3.8. Cuplikan kode berikut
merupakan definisi input dan output transpose buffer dalam bahasa VHDL.
entity memori is
port(addr_baca: in std_logic_vector(7 downto 0);addr_tls: in std_logic_vector(7 downto 0);data_tls: in std_logic_vector(lebar_data downto 0);data_baca: out std_logic_vector(lebar_data downto 0); we:in std_logic;clk: in std_logic);
end entity;
41
42
Definisi input dan output pada transpose buffer tersebut diikuti dengan
definisi sifat yang dirancangkan pada transpose buffer. Sifat tersebut yaitu
transpose buffer memiliki pasangan bus data dan alamat untuk proses baca
maupun tulis. Sifat tersebut dijelaskan pada potongan program berikut.
--proses tulisprocess(clk) begin
if(falling_edge(clk) and we='1') thenmem(conv_integer(addr_tls)) <= data_tls;
end if;end process;--proses bacadata_baca<=mem(conv_integer(addr_baca));
3.3.7. Perancangan Pengendali DCT-2D
Pengendali berfungsi untuk menghasilkan isyarat enable untuk DCT-1D
tingkat dua. Selain itu modul ini berfungsi untuk menghasilkan alamat tulis dan
alamat baca modul transpose buffer. Seperti yang telah dibahas pada bagian
perancangan DCT-2D, data untuk input DCT-1D tingkat dua baru dikeluarkan dari
transpose buffer saat output DCT tingkat pertama yang tersimpan pada buffer
mencapai jumlah tertentu. Untuk menentukan secara spesifik waktu mulai
pengiriman data dari transpose buffer, dipergunakan aturan sebagai berikut.
a) Data dikirimkan ke modul DCT-1D kedua secara per kolom, maka pada
saat pengiriman suatu larik pada kolom, jumlah data pada kolom itu harus
lengkap sejumlah 8 titik.
b) Berdasarkan aturan tersebut, data dari transpose buffer mulai dikeluarkan
setelah kolom 0 baris ke-6 terisi data dari DCT-1D pertama.
Visualisasi proses tersebut ditampilkan pada Gambar 3.9. Berdasarkan
Gambar 3.9, lokasi tulis merupakan alamat yang dihasilkan oleh unit controller
untuk menunjuk lokasi memori yang akan ditulisi data keluaran DCT 1D. Data
42
43
yang disimpan tersebut kemudian dikeluarkan secara transpose dengan isyarat
lokasi baca sebagai penunjuk lokasi memori yang akan dibaca. Data mulai
dikeluarkan pada saat penulisan data dengan koordinat (6,2) pada citra. Fitur ini
dirancang dengan mendeskripsikan dalam program VHDL.
Gambar 3.9 Visualisasi input dan output data menuju dan dari transpose buffer
Berikut adalah definisi isyarat untuk mengakses alamat yang ter-
transpose. Alamat dengan urutan ter-transpose dihubungkan pada alamat baca
(a_out).
a_out(5 downto 3)<=a_out1(2 downto 0);a_out(2 downto 0)<=a_out1(5 downto 3);a_out(7 downto 6)<=a_out1(7 downto 6);
Pengaksesan alamat tulis dilakukan pada proses dct_proc pada VHDL
.....elsif(rising_edge(clk))then
en_dct<=ctr_en;
if(dct_rdy='1')thenwe<='1';if(cntia="111") then
cntib<=cntib+1;cntia<="000";
elsecntia<=cntia+1;
end if;
if(a_in1="00111111")then
en2<='1'; a_in1<=a_in1+1;
elsif(a_in1="01111111")then a_in1<="00000000";else
a_in1<=a_in1+1;
43
44
end if;.....
Pengaksesan alamat baca dilakukan pada proses yang terpisah, yaitu dct2_proc
dct2_proc:process(clk,rst,en2) beginif(rst='1')then
a_out1<="01111111";en_dct2<='0';
elsif(rising_edge(clk))thenif(en2='1') thenen_dct2<='1';
if(a_out1="01111111")then a_out1<="00000000";else
a_out1<=a_out1+1;end if;
elseen_dct2<='0';
end if;end if;end process;
3.3.8. Unit Zigzag
Data dikeluarkan dari modul DCT-2D secara satu persatu. Urutan
pengeluarannya dilakukan secara Zigzag. Pada penelitian ini, untuk membuat data
keluar secara zigzag, data ditampung pada zigzag buffer setelah keluar dari DCT-
2D. Zigzag buffer dirancang seperti transpose buffer, yaitu SRAM yang
mempunyai bus data baca dan tulis serta bus alamat baca dan tulis. Sequence
alamat baca dan tulis dihasilkan oleh unit controller. Bus alamat tulis diakses
secara linear, tetapi bus alamat baca diakses dalam urutan alamat yang zigzag
seperti pada Gambar 2.2 dan 2.3.
Ukuran modul tersebut adalah 128 byte atau dua blok, dengan tujuan jika
blok ke-1 sedang dibaca, controller akan mengakses blok ke-2 untuk ditulisi.
Begitu pula dengan sebaliknya. Data dari buffer mulai dibaca setelah data ke-28
dari keluaran DCT-2D ditulis ke memori, untuk menghindari data pada alamat
yang belum ditulis ikut dikirim lebih dahulu. Demikian cuplikan kode VHDL
44
45
untuk fungsi ini
if(a_in2a(5 downto 0)="011100")then --> jika address input =28=011100b
rom_rd<='1'; --> flag tanda buffer siap dibaca. . .. . .elsif(rising_edge(clk) and rom_rd='1')then --> flag aktif,
if(a_out2a="01111111")then a_out2a<="00000000";
else a_out2a<=a_out2a+1; --> increment ROM zigzag
end if; end if;
Bilangan zigzag dihasilkan oleh suatu unit generator zigzag. Unit ini
berbentuk suatu ROM yang didalamnya tersimpan bilangan dalam urutan zigzag
sesuai Gambar 2.2 dan 2.3. Jika bus alamat ROM zigzag diakses secara linear,
ROM akan mengeluarkan data zigzag pada bus datanya. Bus data ROM zigzag ini
dihubungkan ke bus alamat baca zigzag buffer. Struktur modul zigzag
selengkapnya ditunjukkan pada Gambar 3.10.
3.3.9. Perancangan Quantizer
Quantizer pada dasarnya adalah suatu untai pembagi. Supaya dapat
diimplementasikan pada FPGA, operasi pembagian diubah menjadi perkalian.
Nilai pengali didapat dari 1/pembagi. Nilai kuantisasi pada Tabel 2.2 adalah nilai
pembagi. Setelah diubah menjadi pengali, matriks kuantisasi Qk ditunjukkan pada
persamaan (3.2). Masukannya berasal dari output unit zigzag. Besarnya masukan
sama dengan keluaran DCT-2D. Karena nilai output DCT-2D adalah nilai yang
terskala, nilai pengali adalah hasil penskalaan ulang dari matriks Qk.
45
46
Gambar 3.10 Struktur unit zigzag
Qk = [0.0625 0.0909 0.1 0.0625 0.0416 0.025 0.0196 0.01630.0833 0.0833 0.0714 0.0526 0.0384 0.0172 0.0166 0.01810.0714 0.0769 0.0625 0.0416 0.025 0.0175 0.0144 0.01780.0714 0.0588 0.0454 0.0344 0.0196 0.0114 0.0125 0.01610.0555 0.0454 0.027 0.0178 0.0147 0.0091 0.0097 0.01290.0416 0.0285 0.0181 0.0156 0.0123 0.0096 0.0088 0.01080.0204 0.0156 0.0128 0.0114 0.0097 0.0082 0.0083 0.00990.0138 0.0108 0.0105 0.0102 0.0089 0.01 0.0097 0.0101
]................. ...(3.2)
Vektor penskala s didapat dari nilai-nilai bukan nol matriks S pada
persamaan (2.3) dan disusun pada persamaan (3.3)
s = [c4
c7 /c6c6 /c4c5/c2
c4c3/c2c2/c4c1 /c6
] .......................................(3.3)
dan nilai pengali terskala Qs didapat dengan cara
46
47
Qs = Qk * (s*s')............................................(3.4)
Nilai Qs masih berbentuk bilangan pecahan. Untuk mendapatkan representasi
integernya, digunakan cara yang sama dengan pengali pada DCT. Masing-masing
bilangan pada Qs dikalikan dengan 4096 menjadi Qis pada persamaan (3.5).
Qis = Qs x 4096.......................................(3.5)
dan dihasilkan
Qis = ….........................(3.6)
Nilai Qis inilah yang akan disimpan di ROM pengali dan dikalikan dengan
keluaran DCT-2D. Qis dikodekan menggunakan bilangan 8 bit bertanda. Karena
data yang dikuantisasi berasal dari zigzag buffer, maka alamat pada ROM pengali
juga diakses secara zigzag. ROM zigzag sama dengan ROM pada zigzag buffer.
Perkalian dilakukan secara sekuensial pada tiap byte data yang keluar dari DCT-
2D. Nilai pengali juga dikeluarkan secara sekuensial satu demi satu dari ROM
pengali. Hasil kali pada quantizer digeser 12 bit ke kanan untuk mendapatkan
hasil kali yang sebenarnya. Skema kuantisasi ditunjukkan pada Gambar 3.11
berikut.
Sebagaimana pengali pada DCT, pengali pada quantizer juga diambil dari
pengali internal FPGA. Implementasi quantizer pada VHDL ditunjukkan pada
cuplikan source code berikut.
hasil_kali<=dct_in*rom_in; quant_out<=hasil_kali(20 downto 12)+(ofset&hasil_kali(11));
47
48
Gambar 3.11 Skema kuantisasi dan penskalaan ulang
3.3.10. Penanda nilai DC
Nilai DC terletak pada posisi (0,0) dari bidang 8x8. Setiap kali
mengeluarkan data dari posisi tersebut, sistem akan mengaktifkan 1 bit penanda
nilai DC. Penanda ini dihasilkan oleh modul controller. Sinyal penanda diaktifkan
saat output DCT mengeluarkan data pada posisi (0,0). Data pada posisi tersebut
dikeluarkan bersamaan dengan pemasukan data input pada alamat 28.
Implementasi fitur ini di VHDL adalah sebagai berikut.
if(a_in2a(5 downto 0)="011100")then rom_rd<='1';
dc<='1'; a_in2a<=a_in2a+1;
elsif(a_in2a="01111111")then a_in2a<="00000000";
dc<='0'; else
a_in2a<=a_in2a+1; dc<='0';
end if;
3.3.11. Perancangan penyandi entropi
Data output dari quantizer akan masuk penyandi entropi. Data yang sudah
diatur secara zigzag ini dimasukkan secara paralel-sekuensial ke dalam entropy
encoder. Lebar bit data yang masuk penyandi entropi adalah 9 bit. Keluaran
48
x >>12 +yq yq'
yq(11)
y
14 bit 22 bit 9 bit 9 bit
8 bit Postscaler &quantizer
Scaler-Quantizer
ROM
Zigzagbuffer Out
QuantizedValue x 4096
QuantizedValue
hasil_kali(20..12)
hasil_kali(11)
49
penyandi entropi sebenarnya adalah bit-stream yang dikeluarkan secara serial tiap
satu bit. Pada rancangan ini, bit-bit keluaran penyandi entropi dikelompokkan tiap
8 bit (bit-stuffed) dan dikeluarkan secara paralel 8 bit. Rancangan modul penyandi
entropi secara umum ditunjukkan pada Gambar 3.12.
Gambar 3.12 Rancangan modul penyandi entropi
Penyandi entropi terdiri dari modul penyandi Huffman dan bit-stuffer. Dalam
modul sandi Huffman terdapat beberapa submodul yaitu AC coder, DC
differentiator, DC coder, dan code multiplexer. Bit stuffer adalah submodul untuk
pemaketan data. Struktur penyandi Huffman ditunjukkan pada Gambar 3.13.
3.3.12. AC Coder
AC coder merupakan bagian dari penyandi entropi yang berfungsi untuk
menyandikan koefisien AC dari data output quantizer. Bagian-bagian dari AC
coder adalah penyandi RLE, pemeta kategori, generator simbol data, dan
generator kode Huffman. Struktur AC coder ditampilkan pada Gambar 3.14. Sandi
komponen AC keluaran penyandi mempunyai panjang 40 bit yang terdiri dari 16
bit sandi Huffman, 4 bit panjang sandi, 16 bit simbol, dan 4 bit panjang simbol.
Sandi Huffman dan simbol masing-masing adalah sandi dengan panjang variabel
(Variable Length Code) dan panjang maksimum 16 bit. Karena panjang sandi
variabel, perlu didampingi dengan nilai 4 bit (0-15) yang berisi informasi panjang
sandi.
49
50
Gambar 3.13 Diagram blok sub modul sandi Huffman
3.3.13. Penyandi RLE
RLE (Run Length Encoding) diterapkan pada hasil kuantisasi karena pada
data tersebut banyak deretan bilangan nol. Cara kerja RLE sebagai berikut.
a) Pada deretan yang terdiri 63 bilangan koefisien AC DCT terdapat bilangan
nol dan bukan nol.
b) Pada setiap bilangan bukan nol, dibuat suatu susunan bilangan (R,B).
Dengan R adalah jumlah bilangan nol sebelum bilangan tersebut dan B
adalah bilangan bukan nol itu sendiri.
c) Jika terdapat deretan bilangan nol yang jumlahnya kurang dari 16, bilangan
nol tidak disandikan.
d) Jika terdapat jumlah bilangan nol lebih dari 15, maka pada bilangan nol ke-
16, dibuat sandi (15,0).
50
51
Gambar 3.14 Diagram blok penyandi komponen AC (AC coder)
Realisasi RLE dalam rangkaian digital adalah sebuah pencacah 4-bit.
Pencacah ini digunakan untuk mencacah jumlah nilai nol yang masuk sebelum
ada nilai bukan nol. Pencacah ini akan bekerja jika data yang masuk bernilai nol.
Untuk mendeteksi adanya bilangan nol, digunakan rangkaian gerbang OR.
Rangkaian RLE dirancang sesuai Gambar 3.15. Output utama rangkaian ini
adalah nilai run. Output valid digunakan untuk menandai bahwa data valid atau
tidak. Suatu data disebut valid, jika data tersebut non zero, merupakan koefisien
DC, atau nilai run sebelumnya sudah 15 (1111b). Data akan diambil oleh unit
sesudahnya hanya jika data tersebut valid.
3.3.14. Pemeta Kategori dan Generator Simbol
Data-data yang masuk ke dalam penyandi entropi, selain disandikan
dengan teknik RLE, juga dipetakan kategorinya. Pemetaan kategori dilakukan
berdasarkan Tabel 2.3. Output unit ini adalah kategori data yang masuk ke dalam
penyandi entropi dan diberi simbol cat.
51
52
Gambar 3.15 Rangkaian penyandi RLE
Berdasarkan Tabel 2.3, ada 16 kategori data yang akan dikelompokkan.
Implementasi pemeta kategori ini adalah suatu look up table yang di dalam VHDL
berbentuk konstruksi if .. then. Karena ada 16 kategori, maka keluaran submodul
ini mempunyai lebar 4 bit. cat dan run digabungkan menjadi bilangan 8 bit dan
menjadi input bagi penyandi Huffman.
Untuk menandai data secara lebih spesifik, terutama untuk data yang
berada pada kategori yang sama, setiap data diberi simbol berukuran 16 bit.
Simbol ini berbeda-beda untuk data yang berada pada kategori yang sama. Karena
itu, penggunaan simbol ini harus bersama-sama dengan kategori.
3.3.15. DC differentiator
Koefisien DC disandikan dengan prosedur yang berbeda dengan koefisien
AC. Representasi bilangan DC yang disandikan adalah selisih antara koefisien DC
pada blok yang sedang diolah dan koefisien DC pada blok sebelumnya. Khusus
untuk blok 8x8 yang pertama, representasi bilangan DC adalah koefisien DC-nya.
Untuk membedakan antara koefisien DC dengan yang lain, digunakan
sinyal kendali DC. Berikut adalah cuplikan kode VHDL untuk implementasi DC
52
53
differentiator.
diff<=din-dctemp;
process(clk,rst,dc) begin if(rst='1') then
dctemp<=(others=>'0'); elsif(rising_edge(clk) and dc='1')then
dctemp<=din; end if; end process;
3.3.16. Penyandi Koefisien DC
Representasi koefisien DC yang disandikan adalah nilai bedanya. Proses
penyandian sedikit berbeda dengan koefisien AC.
Gambar 3.16 Skema penyandi koefisien DC
Penyandian DC dan AC sama-sama menggunakan pemeta kategori dan
simbol yang sama. Perbedaannya, penyandian DC tidak menggunakan RLE,
sehingga kode Huffman untuk DC didapatkan dari penyandian kategorinya saja.
Penyandian kategori untuk memperoleh sandi Huffman DC menggunakan
tabel yang berbeda dari penyandian AC. Dalam implementasinya pada VHDL,
pembuatan sandi Huffman dikerjakan dalam suatu look-up table. Implementasi
rangkaian penyandi DC ditampilkan pada Gambar 3.16.
53
54
3.3.17. Code Multiplexer
Dalam rangkaian terdapat penyandi koefisien AC dan DC. Masing-masing
jenis koefisien dikeluarkan pada waktu yang berbeda. Koefisien DC hanya
dikeluarkan pada saat posisi data (0,0). Selain saat itu, yang dikeluarkan adalah
koefisien AC. Untuk melewatkan kode untuk koefisien AC dan DC dalam satu
jalur, digunakan suatu unit multiplekser pada Gambar 3.13. MUX yang digunakan
adalah 2 ke 1 jalur dengan panjang bit tiap jalur 40 bit. Untuk memilih jalur
MUX, digunakan masukan select yang dihubungkan dengan masukan DC.
Masukan DC ini untuk menandai koefisien yang aktif adalah koefisien DC.
3.3.18. Bit Stuffer
Keluaran penyandi entropi sebenarnya bersifat variable length. Pada
modul penyandi koefisien AC dan DC, keluaran dibuat fixed length 40 bit untuk
mempermudah proses penyandian. Untuk membuat suatu data variable length dari
data 40 bit tersebut, dibuat suatu modul yang dinamakan bit stuffer.
Modul bit stuffer mengubah data paralel keluaran modul penyandi
koefisien AC dan DC menjadi data serial. Data serial berasal dari data sym dan
huff. Panjang data serial untuk sym ditentukan oleh cat dan untuk huff ditentukan
oleh len. Gambar 3.17 menunjukkan interkoneksi penyandi koefisien dengan bit
stuffer. Rangkaian bit stuffer pada dasarnya merupakan konverter paralel ke
serial. Pada bit stuffer, panjang data yang dikeluarkan secara serial bisa diatur.
Data yang akan dikeluarkan secara serial adalah huff dan sym. Keduanya memiliki
panjang 16 bit. Melalui bit stuffer, panjang data serial yang dikeluarkan tidak
selalu 16 bit, tetapi tergantung pada panjang yang ditentukan masukan len dan cat.
54
55
Gambar 3.17. Interkoneksi penyandi dengan bit stuffer
3.4. Metode Pengujian Sistem
Sistem yang telah dirancang kemudian akan diuji unjuk kerjanya.
Pengujian dilakukan pada beberapa modul secara individual dan gabungan
beberapa modul. Pengujian juga dapat dilakukan secara simulasi dan secara
hardware. Target pengujian adalah didapatkan parameter-parameter berikut,
a. spesifikasi kecepatan dan latensi pipeline modul secara keseluruhan maupun
masing-masing modul secara individual,
b. ketelitian komputasi untuk keseluruhan modul secara terintegrasi maupun
secara individu,
c. hasil sintesis rangkaian dari VHDL yang menghasilkan informasi mengenai
resource FPGA yang digunakan,
d. perbandingan hasil kompresi yang dilakukan hardware dan hasil kompresi yang
dilakukan oleh software komputer,
e. perbandingan frame rate antara hardware yang dirancang dan IC komersial.
Skema pengujian ditunjukkan pada Gambar 3.18. Objek yang digunakan
55
Penyandi AC/DC
Controllable parallel to serial(bit stuffer)
huff(16)len (4)
sym(16)
cat (4)
Serial out
56
sebagai data uji adalah data citra yang sebenarnya.
Gambar 3.18 Skema pengujian simulasi dan hardware
Citra yang diujikan berupa citra grayscale dengan format bitmap. Citra
tersebut digunakan untuk pengujian melalui simulasi maupun hardware melalui
prosedur berikut.
a. Prosedur simulasi
a.1. Persiapan test bench simulasi
Untuk melakukan simulasi, citra objek diubah menjadi file testbench
VHDL menggunakan suatu program Matlab. File testbench berfungsi
mengeluarkan stimulus untuk rangkaian yang diuji. Karena dibentuk dari citra,
data-data stimulus merupakan representasi nilai piksel dari citra. Konversi citra
BMP ke kode VHDL ditunjukkan melalui skema pada Gambar 3.20. Sebagai nilai
pembanding, data-data yang sama juga digunakan sebagai input program (DCT,
kuantisasi, penyandi entropi) versi Matlab. Berdasarkan skema kompresi JPEG
dari Wallace (1990) dan ditunjukkan pada Gambar 3.20, nilai-nilai piksel yang
56
57
dikodekan dengan bilangan tak bertanda 8 bit (0 -255) harus dikurangi dengan
128 sebelum masuk ke penyandi JPEG. Dengan begitu piksel menjadi terkodekan
menggunakan bilangan 8 bit bertanda.
Solomon (2004) menjelaskan tentang teknis pengelompokan data pixel
pada citra yang akan dikompresi. Kompresi citra dilakukan terhadap setiap blok
citra yang berukuran 8x8. Sebelum dilakukan konversi, citra dibagi menjadi
beberapa blok yang berukuran 8x8. Data pada blok diurutkan pada tiap kolomnya.
Setelah suatu blok diproses, dilanjutkan dengan blok yang berada di bawahnya
pada kolom yang sama. Jika pemrosesan sudah sampai pada blok terakhir pada
kolom tersebut, dilanjutkan pada blok pada kolom sebelah kanannya.
a.2. Proses simulasi
Simulasi diawali dengan pembuatan source code VHDL untuk test bench.
Prosesnya ditunjukkan pada Gambar 3.19. Setelah test bench dipersiapkan, proses
selanjutnya adalah melakukan simulasi. Simulasi dijalankan menggunakan
software ISE simulator.
a.3. Hasil Simulasi
Simulasi akan menghasilkan dua macam output berikut.
a.3.1 Diagram pewaktuan
Diagram pewaktuan digunakan untuk menganalisis pewaktuan data output
dan nilai dari beberapa sampel data. Dari diagram pewaktuan tersebut dapat
diketahui bahwa output sudah muncul pada saat yang tepat atau tidak. Selain itu
juga dapat diketahui besarnya nilai output sudah seperti yang diharapkan atau
tidak.
a.3.2. File teks yang berisi data yang sudah terkompresi
57
58
Simulator VHDL pada penelitian ini dirancang untuk menghasilkan output
berupa teks file. Teks file ini berisi data hasil DCT 2D, kuantisasi, dan data hasil
kompresi. Output ini berfungsi untuk menghitung tingkat akurasi komputasi yang
telah dilakukan.
Gambar 3.19 Skema konversi bitmap ke VHDL
b. Prosedur pengujian hardware
Untuk menguji hardware diperlukan suatu antarmuka untuk mengirimkan
data citra ke FPGA dan membaca data hasil kompresi dari FPGA. Antarmuka
58
59
yang digunakan pada penelitian ini adalah port serial atau UART. UART dipilih
karena mudah diimplementasikan untuk koneksi PC dan FPGA. Pada PC,
digunakan konverter USB ke serial untuk mendapatkan port serial. Evaluation
board FPGA yang digunakan juga sudah menyediakan interface ke UART.
Kerugian pengujian data menggunakan UART adalah kecepatan rangkaian
menjadi turun untuk menyesuaikan dengan kecepatan UART. Oleh karena itu,
metode pengujian hardware ini digunakan untuk menguji validitas data saja dan
bukan kecepatan rangkaian sesungguhnya. Untuk mengetahui kecepatan
rangkaian, digunakan pengujian melalui simulasi.
Gambar 3.20. Diagram blok pengujian rangkaian
Diagram blok pengujian rangkaian menggunakan UART ditunjukkan pada
Gambar 3.20. Berdasarkan gambar 3.20, terdapat 3 modul tambahan yaitu modul
TX, modul RX dan S/P atau konverter serial ke paralel. Data yang akan
dikompresi berasal dari file citra. Nilai piksel citra tersebut kemudian dikirim ke
rangkaian kompresi. Data yang dimasukkan ke rangkaian berasal dari data yang
dikirim oleh PC (komputer) lewat UART (TX). Setelah data tersebut lengkap 8
bit, data dimasukkan ke rangkaian yang akan diuji. Rangkaian yang akan diuji
mempunyai keluaran serial, tetapi data yang akan dikirimkan lewat UART harus
ditampung di dalam register RX dahulu. Oleh karena itu dibuat rangkaian S/P
59
RXregister
Rangkaianyang diuji S/P TX
register
RX
DariPC
TX
KePC
data_in hasil kompresi
60
untuk mengkonversi keluaran serial rangkaian kompresi menjadi data paralel 8
bit. Data inilah yang dimasukkan ke dalam register RX dan dikirim lewat jalur RX
port serial. Data yang diterima PC melalui port serial akan disimpan di dalam
sebuah file biner. File tersebut merupakan representasi hasil kompresi citra. Pada
tesis ini, hasil kompresi tidak disimpan dalam format file resmi JPEG yang
disebut JFIF (JPEG File Interchange Format), tetapi dalam bentuk raw data.
Program Cutecom yang berjalan di atas sistem operasi Linux digunakan untuk
mengirim dan menerima data melalui port serial.
3.5 Source code dan hirarkinya
Implementasi rangkaian pada FPGA dilakukan dengan bahasa VHDL.
Untuk memudahkan pembuatan koneksi antar komponen atau modul, masing-
masing modul dibuatkan source code tersendiri, misalnya modul DCT 1D
disimpan dalam file dct3_pl.vhd kemudian quantizer disimpan dalam file
quantizer.vhd dan seterusnya. Kumpulan file tersebut tersusun dalam suatu
hirarki rangkaian. Keterangan mengenai bentuk hirarki rangkaian dan source code
yang lebih detail dijelaskan pada Lampiran B.
60
61
BAB IV
HASIL PENELITIAN DAN PEMBAHASAN
4.1. Simulasi Rancangan
Pengujian hasil perancangan sistem kompresi citra salah satunya dilakukan
dengan simulasi menggunakan perangkat lunak Xilinx ISE simulator. Simulasi
secara perangkat lunak dilakukan pada satu rangkaian kompresi secara utuh dan
pada tiap-tiap modul pada rangkaian kompresi. Data input berasal dari citra
grayscale dengan ukuran 160X120. Timing diagram yang dihasilkan diamati
untuk melakukan verifikasi terhadap bentuk gelombang masing-masing isyarat.
Data output yang dihasilkan dari simulasi disimpan di dalam suatu file dan
dibandingkan dengan keluaran komputasi algoritma yang sama pada Matlab.
4.1.1. Simulasi Modul DCT-1D
a. Analisis perhitungan DCT-1D
Data yang menjadi input untuk menguji modul ini secara simulasi adalah
data dari citra grayscale berukuran 8x8 yang disampel dari citra asal 160x120.
Citra asal ditunjukkan pada Gambar 4.1.
Gambar 4.1 Citra asal untuk pengujian sistem kompresi
Dari citra asal, disampel sejumlah 8 x 8 piksel untuk pengujian DCT-1D.
Data input untuk DCT-1D ditampilkan pada Tabel 4.1. Label kn berarti kolom ke-
61
62
n, sedangkan bn berarti baris ke-n. Data input dari citra dikurangi dengan 128
sebelum dimasukkan ke sistem kompresi untuk mendapatkan format data bilangan
8 bit bertanda. Nilai yang sudah dikurangi 128 ditampilkan pada Tabel 4.2.
Tabel 4.1 Nilai 8 x 8 piksel sebelum dikurangi 128 untuk pengujian DCT-1D
Tabel 4.2 Nilai pixel sesudah dikurangi 128 untuk pengujian DCT-1D
Nilai-nilai piksel pada Tabel 4.2 kemudian akan diproses oleh modul DCT-
1D. Modul DCT-1D melakukan komputasi untuk tiap 8 pixel. Pixel yang
digunakan sebagai input adalah pixel dalam satu kolom, dari baris 0 sampai 7,
kemudian dilanjutkan kolom berikutnya. Tabel 4.3 menampilkan perbandingan
hasil komputasi DCT-1D dengan simulasi VHDL dan Matlab.
Berdasarkan Tabel 4.3, ketelitian komputasi DCT-1D di VHDL dapat
dihitung menggunakan mean square error (MSE). MSE dihitung menggunakan
persamaan (4.1) berikut.
MSE = Σin=1 (xi_data -xi_acuan)2 / n ..........................(4.1)
Variabel xi_data adalah data yang didapat dari simulasi VHDL dan xi_acuan
62
k0 k1 k2 k3 k4 k5 k6 k7b0 42 7 -41 -42 -42 13 32 42b1 38 11 -46 -45 -44 21 37 45b2 29 15 -51 -41 -10 5 50 46b3 33 3 -41 -41 -12 20 57 57b4 28 -14 -41 -45 -15 31 55 61b5 16 -23 -44 -44 -4 31 56 58b6 18 -39 -46 -42 -6 51 49 51b7 14 -54 -59 -45 26 39 51 -101
k0 k1 k2 k3 k4 k5 k6 k7b0 170 135 87 86 86 141 160 170b1 166 139 82 83 84 149 165 173b2 157 143 77 87 118 133 178 174b3 161 131 87 87 116 148 185 185b4 156 114 87 83 113 159 183 189b5 144 105 84 84 124 159 184 186b6 146 89 82 86 122 179 177 179b7 142 74 69 83 154 167 179 27
63
adalah data acuan hasil perhitungan pada Matlab. Variabel n adalah banyaknya
data. Dengan ukuran 8x8 pixel, banyaknya data adalah n=64. Berdasarkan data
pada Tabel 4.3a, didapatkan tabel selisih untuk tiap titik yang ditunjukkan pada
Tabel 4.3b dan mean square error untuk DCT-1D sebesar 0.069219.
Tabel 4.3 Perbandingan komputasi DCT-1D pada VHDL dan Matlab: (a) Hasil komputasi dan (b) Selisih komputasi VHDL dan Matlab
(a)
(b)
63
k0 k1 k2 k3vhdl Matlab vhdl Matlab vhdl Matlab vhdl Matlab
b0 218 218.00 -94 -94.00 -369 -369.00 -345 -345.00b1 103 102.57 247 246.82 27 27.00 6 5.68b2 -1 -0.76 -76 -75.60 -29 -28.61 -3 -3.12b3 6 6.40 -10 -9.56 36 36.31 -3 -3.47b4 16 16.00 -22 -22.00 5 5.00 -1 -1.00b5 3 2.93 7 7.11 10 9.59 9 9.47b6 -9 -9.24 4 3.60 -7 -7.39 1 1.12b7 0 0.10 0 -0.37 -1 -0.90 0 0.32
k4 k5 k6 k7vhdl Matlab vhdl Matlab vhdl Matlab vhdl Matlab
b0 -107 -107.00 211 211.00 387 387.00 259 259.00b1 -198 -198.19 -131 -131.49 -62 -61.90 251 250.72b2 -7 -6.68 27 27.16 -64 -63.65 -308 -307.81b3 -75 -74.68 26 26.35 -14 -14.44 223 222.94b4 21 21.00 -5 -5.00 3 3.00 -141 -141.00b5 1 0.91 1 0.84 2 1.90 88 88.52b6 29 28.68 -25 -25.16 6 5.65 -46 -46.19b7 0 -0.03 0 0.30 -2 -1.56 10 9.82
k0 k1 k2 k3 k4 k5 k6 k7b0 0 0 0 0 0 0 0 0b1 -0.43 -0.18 0 -0.32 -0.19 -0.49 0.1 -0.28b2 0.24 0.4 0.39 -0.12 0.32 0.16 0.35 0.19b3 0.4 0.44 0.31 -0.47 0.32 0.35 -0.44 -0.06b4 0 0 0 0 0 0 0 0b5 -0.07 0.11 -0.41 0.47 -0.09 -0.16 -0.1 0.52b6 -0.24 -0.4 -0.39 0.12 -0.32 -0.16 -0.35 -0.19b7 0.1 -0.37 0.1 0.32 -0.03 0.3 0.44 -0.18
64
b. Analisis diagram pewaktuan
Simulasi rangkaian DCT-1D menghasilkan diagram pewaktuan yang
berfungsi untuk verifikasi kebenaran isyarat yang dihasilkan. Parameter yang
perlu diamati pada diagram pewaktuan adalah posisi pewaktuan dan nilai isyarat
keluaran. Parameter tersebut digunakan untuk menilai kesesuaian hasil simulasi
dengan rancangan. Masukan untuk analisis diagram pewaktuan ini adalah sampel
citra dengan ukuran 16 x 16.
Isyarat kendali pada DCT-1D adalah ten. Isyarat tersebut digunakan untuk
meng-enable data input untuk masuk ke sistem. Isyarat status keluaran DCT-1D
adalah rdy. Status tersebut adalah aktif jika bernilai logika 1. Sinyal rdy akan
aktif jika ada data hasil komputasi DCT-1D yang akan dikeluarkan. Sinyal rdy
harus aktif satu siklus sebelum data dikeluarkan. Kedua isyarat tersebut harus
mempunyai lebar siklus pewaktuan yang sama. Diagram pewaktuan ditunjukkan
pada Gambar 4.2.
Tampilan semua isyarat ditunjukkan pada Gambar 4.2(a). Pada Gambar
4.2(b) ditunjukkan bahwa isyarat ten diaktifkan dari t=0 sampai t=5120 ns untuk
memasukkan 256 data dengan pesat data 50 Mbyte per detik atau periode 20 ns.
Data berjumlah 256 karena ada 16 x 16 piksel yang diujicobakan. Pada Gambar
4.2(c) terlihat sinyal rdy baru muncul pada saat t = 270.1 ns yang menandakan
adanya latency pada sistem karena penerapan pipelining. Sinyal rdy akan
berlogika 0 kembali pada t = 5410.1 ns sehingga lebar logika 1 sinyal rdy adalah
5140 ns. Lebar sinyal rdy lebih besar 20 ns (satu periode) dari ten karena sinyal
tersebut diaktifkan satu periode sebelum data hasil DCT-1D dikeluarkan. Hal ini
sengaja dirancang untuk memberi persiapan untai sesudah DCT-1D untuk
64
65
melakukan persiapan pengambilan sampel data keluaran DCT-1D. Gambar 4.2(d)
memperlihatkan proses pengambilan data input. Data input diambil tiap transisi
clock naik. Data-data input simulasi dituliskan pada source test bench VHDL.
Pada test bench, data input diubah tiap transisi clock turun. Pengeluaran data
output ditunjukkan pada Gambar 4.2(e). Data dikeluarkan tiap transisi clock naik.
(a)
(b)
(c)
65
66
(d)
(e)
Gambar 4.2 (a – e). Diagram pewaktuan modul DCT-1D: (a) tampilan semua sinyal pada DCT-1D, (b) pengamatan lebar sinyal enable (c) pengamatan sinyal
rdy (d) pengambilan data input, dan (e) pengeluaran data output
Urutan pengeluaran data adalah data pada suatu kolom dikeluarkan baris
per baris. Setelah semua data pada kolom tersebut sudah dikeluarkan, dilanjutkan
ke kolom selanjutnya.
66
67
4.1.2. Simulasi Rangkaian DCT-2D
DCT-2D dibentuk oleh dua rangkaian DCT-1D yang dihubungkan oleh
suatu transpose buffer dan dikendalikan oleh suatu rangkaian controller. Dua
modul DCT-1D yang diterapkan di bagian ini adalah sama, tetapi hanya berbeda
pada lebar bit yang diproses saja. Untuk bagian transpose buffer dan controller,
pengamatan kinerja dilakukan berdasarkan diagram pewaktuan saja. Sedangkan
untuk DCT-2D pengamatan kinerja juga dilakukan dengan analisis akurasi hasil
penghitungan.
a. Pengujian Transpose buffer dan controller.
Transpose buffer digunakan untuk menyimpan data keluaran DCT-1D
stage pertama untuk dikirim sebagai input untuk DCT-1D stage kedua sehingga
membentuk operasi DCT-2D. Input transpose buffer adalah data dengan urutan
normal, dan keluarannya adalah data dengan urutan yang sudah ter-transpose.
Untuk menjalankan transpose buffer, dibutuhkan suatu pengendali. Tugas
pengendali adalah memberikan alamat tulis dan alamat baca untuk transpose
buffer dengan trigger yang berasal dari sinyal status (rdy) keluaran dari DCT-1D.
Berdasarkan hasil simulasi pada unit transpose dan controller, urutan data
keluaran unit transpose sudah merupakan transpos dari urutan data input. Hasil
simulasi pada saat awal pengisian data ditampilkan pada Gambar 4.3.
Buffer di-enable akses tulisnya oleh isyarat we. Isyarat ini dihasilkan oleh
unit controller, aktif satu siklus clock setelah data output DCT-1D yang pertama
ready. Setelah isyarat we aktif, data akan dituliskan ke tiap alamat buffer dengan
urutan alamat secara increment.
67
68
Gambar 4.3 Simulasi awal pengisian data ke transpose buffer
Alamat baca unit transpos diakses dengan urutan secara transpose. Data
akan dikeluarkan dari unit transpose ini setelah alamat ke-64 ditulis supaya data
yang dikeluarkan adalah data yang sudah benar-benar diisikan. Inisiasi
pengeluaran data ditandai dengan aktifnya isyarat en_dct2 yang dihasilkan oleh
controller. Isyarat en_dct2 sekaligus untuk meng-enable modul DCT-1D yang
kedua. Diagram pewaktuan pada saat awal pengeluaran data ditunjukkan pada
Gambar 4.4.
Gambar 4.5 memperlihatkan secara lengkap diagram pewaktuan modul
transpose buffer untuk menangani 64 data keluaran DCT-1D yang pertama. Pada
Gambar tersebut, terlihat bahwa alamat untuk penulisan buffer diberikan dalam
urutan yang increment. Pada Gambar 4.6, terlihat bahwa alamat untuk pembacaan
buffer diberikan dalam urutan yang transposed. Terlihat juga bahwa data yang
tertulis dan terbaca pada buffer adalah sama, hanya urutannya yang berbeda.
Transpose buffer mempunyai lebar bit 10 bit untuk tiap unit
penyimpanannya. Lebar bit ini menyesuaikan dengan keluaran DCT-1D.
68
69
Gambar 4.4 Diagram pewaktuan awal pengeluaran data transpose buffer
Gambar 4.5 Diagram pewaktuan penulisan 64 data keluaran DCT-1D ke
transpose buffer
Unit penyimpanan yang dialokasikan adalah 128 unit penyimpan. 128 unit
ini digunakan untuk menampung dua blok data yang berukuran 8x8 atau 64 unit.
Kemampuan untuk menyimpan 2 blok ini, digunakan supaya proses baca dan tulis
69
70
blok dapat berjalan bersamaan. Pada waktu yang sama misalnya, 64 unit yang
pertama diakses tulis sementara 64 unit yang kedua diakses baca. Pada siklus 64
clock berikutnya, giliran 64 unit pertama diakses baca dan 64 unit kedua diakses
tulis secara bersamaan. Siklus baca-tulis transpose buffer tersebut akan terus
berjalan secara bergantian. Metode akses ini ditunjukkan pada Gambar 4.6.
Gambar 4.6 Diagram pewaktuan pengeluaran 64 titik data output
b. Pengujian rangkaian DCT-2D terskala
Rangkaian DCT-2D merupakan kombinasi dua rangkaian DCT-1D yang
dihubungkan oleh transpose buffer. Masukan modul DCT-1D yang kedua berasal
70
71
dari keluaran transpose buffer yaitu nilai DCT-1D yang susunannya telah
ditranspos. Sama dengan analisis kinerja DCT-1D, analisis DCT-2D dilakukan
melalui diagram pewaktuan dan analisis ketelitian.
b.1. Pengujian ketelitian DCT-2D terskala
Data input untuk menguji DCT-2D sama dengan data uji pada DCT-1D,
yaitu data pada Tabel 4.1 berupa cuplikan citra grayscale pada Gambar 4.1 yang
berukuran 8x8 pixel dan sudah dikurangi 128. Kemudian dibuat suatu source
VHDL testbench yang berisi data dari 8x8 pixel tersebut. Testbench berfungsi
untuk memberi input bagi modul DCT. Data output dari modul DCT disimpan
dalam suatu file teks sehingga lebih mudah dilakukan analisis terhadap data
tersebut. Untuk menguji ketelitian komputasi DCT, hasil simulasi VHDL
dibandingkan dengan komputasi DCT-2D pada Matlab. Tabel 4.4 a dan b berisi 64
titik hasil komputasi DCT-2D terskala pada Matlab dan hasil simulasi VHDL.
Kriteria MSE juga dipakai untuk mengukur ketelitian komputasi DCT-2D
pada VHDL. Sebelum MSE, selisih antara hasil komputasi Matlab dengan
simulasi VHDL perlu dihitung terlebih dahulu. Berdasarkan Tabel 4.4, maka
untuk DCT-2D terskala didapatkan tabel selisih komputasi Matlab dan VHDL
pada Tabel 4.5 kemudian dapat didapatkan MSEDCT-2D = 0.52796.
b.2. Analisis diagram pewaktuan
Gambar 4.7 menunjukkan diagram pewaktuan modul DCT-1D yang
kedua. Modul ini sama dengan modul pertama, tetapi memiliki lebar bit yang
lebih banyak. Input modul mempunyai lebar 11 bit dan output memiliki lebar 14
bit. Pada Gambar 4.7(a), ditunjukkan bahwa operasi DCT-1D yang kedua di-
enable oleh isyarat en_dct yang dikeluarkan oleh controller.
71
72
Tabel 4.4 Hasil komputasi DCT-2D terskala pada Matlab dan simulasi VHDL
(a) Kolom 0 – 3
(b) Kolom 4-7
Tabel 4.5 Selisih komputasi DCT-2D terskala pada Matlab dan VHDL
Isyarat en_dct merupakan isyarat yang sama dengan isyarat en_dct2 yang
digunakan untuk menandai data dari transpose buffer siap diakses. Berbeda
dengan keluaran DCT-1D pertama yang datanya diurutkan per kolom, data
keluaran DCT-1D stage ke-2 dikeluarkan per baris. Pengeluaran data DCT-2D
72
k0 k1 k2 k3matlab vhdl matlab vhdl matlab vhdl matlab vhdl
b0 160 160 -1586.5 -1587 1904.8 1905 1265.2 1265b1 241.21 243 469.24 469 1136.4 1136 -751.86 -751b2 -459.06 -461 511.84 512 -607.48 -608 516.11 516b3 189.85 189 -370.53 -372 463.64 463 -383.01 -384b4 -124 -124 263.75 264 -260.97 -261 229.21 229b5 121.26 121 -143.35 -142 137.39 137 -142.22 -141b6 -48.94 -47 76.55 77 -115.93 -115 48.22 48b7 7.68 7 -17.95 -17 15.51 16 -12.2 -13
k4 k5 k6 k7matlab vhdl matlab vhdl matlab vhdl matlab vhdl
b0 -110 -110 153.27 153 -46.81 -47 4.06 4b1 80.35 81 -205.19 -205 -44.79 -44 -104.8 -105b2 -177.68 -177 193.77 194 9.93 10 6.51 6b3 112.54 113 -71.04 -70 151.34 151 -41.56 -42b4 -86 -86 106.01 106 -29.03 -29 29.03 29b5 82.37 81 -48.71 -49 24.76 25 -8.08 -8b6 -2.32 -3 3.43 3 -54.52 -55 19.57 20b7 12.74 13 -7.23 -9 3.76 4 -1.52 -2
k0 k1 k2 k3 k4 k5 k6 k7b0 0 0.46 -0.19 0.21 0 0.27 0.19 0.06b1 -1.79 0.24 0.39 -0.86 -0.65 -0.19 -0.79 0.2b2 1.94 -0.16 0.52 0.11 -0.68 -0.23 -0.07 0.51b3 0.85 1.47 0.64 0.99 -0.46 -1.04 0.34 0.44b4 0 -0.25 0.03 0.21 0 0.01 -0.03 0.03b5 0.26 -1.35 0.39 -1.22 1.37 0.29 -0.24 -0.08b6 -1.94 -0.45 -0.93 0.22 0.68 0.43 0.48 -0.43b7 0.68 -0.95 -0.49 0.8 -0.26 1.77 -0.24 0.48
73
ditunjukkan pada Gambar 4.7(b). Data output DCT dikeluarkan satu siklus setelah
isyarat en_out aktif.
(a)
(b)
Gambar 4.7 Diagram pewaktuan DCT-2D, (a) Pada saat awal data dimasukkan ke modul DCT yang kedua (b)Pada saat awal data hasil komputasi DCT-2D
dikeluarkan
4.1.3. Pengujian zig-zag buffer
Pengujian kinerja rangkaian zig-zag dapat dilakukan dengan melihat
diagram pewaktuannya. Zigzag buffer adalah rangkaian yang sama dengan
transpose buffer.
73
74
Gambar 4.8 Diagram pewaktuan input data dari DCT2D ke zigzag buffer
Gambar 4.9 Diagram pewaktuan pembacaan data dari zig-zag buffer
Rangkaian merupakan suatu RAM statis dengan dua pasang bus data-bus
alamat. Masing-masing bus untuk baca dan tulis. Alamat baca dan tulis dihasilkan
74
75
oleh unit controller. Variabel yang perlu diperhatikan pada timing diagram adalah
alamat baca dan tulis serta kesesuaian antara data yang ditulis dan dibaca. Gambar
4.8 menunjukkan keseluruhan data 64 titik dimasukkan ke dalam zig-zag buffer.
Pembacaan data 64 titik dari zig-zag buffer ditunjukkan pada Gambar 4.9. Pada
Gambar 4.8 dapat diamati bahwa zig-zag buffer ditulis dengan urutan alamat yang
normal (increment), sedangkan pada Gambar 4.9 terlihat bahwa pembacaan
dilakukan dengan urutan alamat yang zig-zag. Pembacaan buffer dimulai pada
saat t=2470 ns atau 28 siklus setelah alamat ke-0 buffer ditulisi.
4.1.4. Pengujian Quantizer
Analisis kinerja quantizer cukup dilakukan menggunakan analisis
ketelitian komputasi dengan dibandingkan dengan data keluaran Matlab. Hasil
komputasi total DCT2D - zigzag – kuantisasi pada VHDL dibandingkan dengan
hasil komputasi DCT2D - zigzag – kuantisasi pada Matlab. Perbandingan hasil
dan urutan komputasi versi VHDL dan Matlab diperlihatkan pada Tabel 4.6. Pada
Matlab, fungsi DCT-2D yang dipakai adalah fungsi DCT yang asli, yaitu DCT
tidak terskala,sehingga nilai kuantisasi yang dipakai adalah nilai-nilai kuantisasi
yang asli, yang tercantum pada Tabel 2.2. Pada penerapan di FPGA, DCT-2D
adalah versi terskala, sehingga nilai-nilai kuantisasinya juga harus diskala ulang
untuk mendapatkan nilai output yang benar.
Berdasarkan hasil simulasi VHDL pada Tabel 4.6, hasil komputasi DCT-
2D- zigzag - kuantisasi pada VHDL sudah seperti yang dirancang. Nilai DCT-2D
terkuantisasi sama dengan nilai keluaran Matlab dengan pembulatan ke integer
terdekat. Urutan data yang dikeluarkan oleh sistem yang dirancang dengan VHDL
juga sama dengan urutan data hasil komputasi Matlab.
75
76
Tingkat kesalahan pada bagian ini juga diukur menggunakan MSE antara
keluaran VHDL dengan keluaran komputasi Matlab yang unrounded. Nilai MSE
keluaran quantizer didapatkan sebesar,
MSEquantizer = 0.060552
Tabel 4.6 Hasil komputasi DCT-zigzag-kuantisasi pada VHDL dan Matlab
(a). Data ke-0 sampai 23
(b) Data ke-24 sampai 47
(c) Data ke-48 sampai 63
76
vhdl matlab vhdl matlab vhdl matlab24 -1 -1.19 -1 32 0 0.43 0 40 0 -0.11 025 0 -0.43 0 33 0 0.3 0 41 0 0.03 026 0 -0.41 0 34 0 0.2 0 42 -1 -0.62 -127 0 -0.21 0 35 0 0.05 0 43 0 0.04 028 0 0.03 0 36 0 -0.06 0 44 0 0.37 029 0 -0.12 0 37 0 -0.26 0 45 0 0.15 030 0 0.41 0 38 0 -0.3 0 46 0 0.16 031 0 0.24 0 39 0 -0.16 0 47 0 0.11 0
data ke-
matlab rounded
data ke-
matlab rounded
data ke-
matlab rounded
vhdl matlab vhdl matlab48 0 0.06 0 56 0 0.01 049 0 -0.05 0 57 0 0.05 050 0 0 0 58 0 -0.04 051 0 -0.1 0 59 0 -0.2 052 0 -0.07 0 60 0 -0.05 053 0 -0.26 0 61 0 0.17 054 0 0.17 0 62 0 0.03 055 0 0.07 0 63 0 -0.03 0
data ke-
matlab rounded
data ke-
matlab rounded
vhdl matlab vhdl matlab vhdl matlab0 1 1.25 1 8 3 2.72 3 16 0 0.28 01 -13 -13 -13 9 1 1.44 1 17 2 1.75 22 2 1.81 2 10 -1 -0.86 -1 18 2 1.72 23 -3 -3.14 -3 11 -2 -1.67 -2 19 1 1.08 14 3 2.54 3 12 -3 -2.78 -3 20 1 0.8 15 18 18.23 18 13 -3 -3.03 -3 21 0 -0.23 06 8 8.4 8 14 -1 -0.57 -1 22 0 -0.47 07 6 5.6 6 15 1 0.61 1 23 -1 -0.67 -1
data ke-
matlab rounded
data ke-
matlab rounded
data ke-
matlab rounded
77
Nilai MSEquantizer jauh lebih kecil dari MSE pada keluaran DCT-2D. Hal ini
dapat disebabkan nilai pada quantizer merupakan nilai keluaran DCT-2D yang
sudah dikuantisasi sehingga menjadi lebih kecil. Karena itulah maka kesalahan
yang ditimbulkan juga ikut terkuantisasi.
4.1.5. Pengujian penanda nilai DC
Pengujian fungsi penanda nilai DC adalah cukup dengan mengamati
timing diagram keluaran pin dc pada unit gabungan DCT-2D – zigzag –
kuantisasi. Isyarat dc ini dihasilkan oleh unit controller dan diaktifkan saat
koefisien DC dikirimkan. Gambar 4.10 adalah diagram pewaktuan isyarat
penanda nilai DC.
Gambar 4.10 Diagram pewaktuan penanda koefisien DC
Berdasarkan diagram pewaktuan pada Gambar 4.10, dapat diamati bahwa
penanda koefisen DC aktif ketika sinyal rdy pertama kali aktif. Sinyal rdy
penanda keluaran unit ini siap untuk dibaca. Penanda koefisien DC ini hanya aktif
selama 1 siklus saja, ketika koefisien DC sedang dibaca.
77
78
4.1.6 Pengujian unit penghasil nilai beda pada koefisien DC
Representasi koefisien DC pada suatu blok (misalnya blok ke-n) yang
disandikan adalah selisih koefisien DC pada blok ke-n dan blok ke-(n-1). Pada
bagian ini akan diuji kinerja unit penghasil nilai beda tersebut dengan mengamati
nilai yang terkirim pada output ketika penanda nilai DC aktif.
Gambar 4.11 Diagram pewaktuan untuk menguji penghasil selisih koefisien DC
Nilai DC yang sebenarnya untuk blok ke-n dan blok ke-(n-1) juga diamati
untuk verifikasi bahwa nilai yang terkirim merupakan selisih koefisien DC kedua
blok. Hasil pengamatan diagram pewaktuan ditampilkan pada Gambar 4.11.
Berdasarkan diagram pewaktuan pada Gambar 4.11, teramati bahwa nilai
yang dikeluarkan pada blok ke-1 pada saat dc=1 adalah -12. Nilai ini adalah
selisih antara nilai DC asli blok ke-1 (-11)dan nilai DC asli blok ke-0 (1).
4.1.7. Pengujian unit penyandi entropi
Penyandi entropi digunakan untuk penyandian baik itu nilai DC maupun
AC. Keluaran unit ini adalah sym(simbol) dengan lebar 16 bit, cat(kategori)
dengan lebar 4 bit, huff(kode huffman) dengan lebar 16 bit, dan len(panjang kode
huffman) 4 bit. Input bagi unit ini adalah data keluaran quantizer. Representasi
koefisien DC yang jadi masukan pada unit ini sudah merupakan selisih koefisien
78
79
DC dua blok yang berdekatan. Keluaran dari unit ini diverifikasi dengan cara
dibandingkan dengan Tabel 2.3 dan 2.4 yang merupakan tabel huffman untuk tiap
kriteria.
Unit penyandi entropi ini diawali dengan penyandi RLE. Setiap data bukan
nol yang melewati penyandi RLE akan disandikan dengan format data
(kategori_data, jumlah_nol_sebelum_data). Kategori data disimbolkan dengan cat
dan jumlah nol disimbolkan dengan run. Pengujian unit RLE untuk jumlah nol
kurang dari 16 ditunjukkan pada Gambar 4.12. Untuk jumlah nol lebih dari 16,
diagram pewaktuan ditunjukkan pada Gambar 4.14. Isyarat valid menunjukkan
pada saat itu data keluaran dari penyandi adalah valid untuk dibaca. Isyarat ini
juga dibangkitkan oleh unit RLE.
Gambar 4.12 Diagram pewaktuan unit RLE dengan jumlah nol kurang dari 16
Suatu kondisi disebut valid jika data yang terbaca bukan nol atau suatu
data nol yang didahului oleh 15 data nol atau koefisien DC. Pada Gambar 4.12
dan 4.13, teramati sistem sudah berjalan sesuai kriteria tersebut. Isyarat run dan
cat akan disandikan lagi menggunakan sandi Huffman sehingga menghasilkan
isyarat huff. Khusus untuk representasi koefisien DC, penyandian hanya
dilakukan terhadap nilai cat saja. Hasil simulasi penyandi entropi untuk satu blok
pertama untuk tiap data valid dituliskan dalam Tabel 4.7.
79
80
Gambar 4.13 Diagram pewaktuan unit RLE dengan jumlah nol 16 atau lebih
Tabel 4.7 memuat hasil penyandian entropi terhadap data keluaran unit
quantizer sehingga menghasilkan isyarat-isyarat sandi huff dan sym. Kedua
isyarat tersebut sebenarnya panjangnya variabel, sehingga pembacaanya perlu
didampingi oleh isyarat len (untuk huff) dan cat (untuk sym). Berdasarkan
pengamatan pada Tabel 4.7, teramati bahwa nilai-nilai keluaran penyandi entropi
sudah sama dengan nilai yang berasal dari tabel simbol (Tabel 2.3) dan tabel kode
Huffman (Tabel 2.4). Meskipun demikian, panjang kode masih berbeda, karena
isyarat huff dan sym sementara dikodekan menggunakan panjang maksimalnya,
yaitu 16 bit.
Pada baris ke-3 dari terakhir Tabel 4.7, terlihat bahwa kode sym tidak
valid ketika kode huff = 11111111001. Hal itu disebabkan kode sym memang
tidak punya nilai saat nilai huff-nya 11111111001. Nilai huff yang seperti itu
adalah untuk mensimbolkan ada 16 nilai nol yang berurutan. Sistem dirancang
untuk mengeluarkan kode EOB (end of block) yaitu huff = 1010 jika terdapat dua
kali kode huff=11111111001. Artinya jika terdapat dua kali 16 nilai nol yang
berurutan, sistem diprogram untuk menghentikan pemrosesan pada blok itu dan
mengeluarkan kode huff =1010. Hal ini tercantum pada baris terakhir Tabel 4.7.
80
81
Tabel 4.7 Hasil penyandian entropi blok ke 1
4.1.8. Pengujian unit bit stuffer
Hasil penyandian entropi yang berupa huff dan sym dalam format fixed
length 16 bit dibuat menjadi variable length. Karena tidak memungkinkan untuk
mengeluarkan suatu data dengan lebar bit yang berubah-ubah, maka bit-bit kode
dikeluarkan satu persatu. Untuk mengamati data yang dikeluarkan bit stuffer, bit-
bit data ditampung pada register 8 bit. Keluaran bit stuffer untuk pemrosesan blok
pertama ditunjukkan pada Tabel 4.8.
Berdasarkan Tabel 4.8, dapat diamati bahwa data blok pertama benar-
benar terkompresi. Ukuran data masukan tiap blok adalah 64 byte sebelum
dikompresi. Setelah dikompresi, sesuai Tabel 2.4, data menjadi berukuran 15 byte.
81
komputasi VHDL menurut tabel 3 dan 4
jenis run cat len sym huff sym huff1 DC 0 1 2 0000000000000001 0000000000000010 1 010
-13 AC 0 4 3 0000000000000010 0000000000001011 0010 10112 AC 0 2 1 0000000000000010 0000000000000010 10 10
-3 AC 0 2 1 0000000000000000 0000000000000000 00 003 AC 0 2 1 0000000000000011 0000000000000011 11 11
18 AC 0 5 4 0000000000010010 0000000000010010 10010 100108 AC 0 4 3 0000000000001000 0000000000001000 1000 10006 AC 0 3 2 0000000000000110 0000000000000100 110 1003 AC 0 2 1 0000000000000011 0000000000000001 11 011 AC 0 1 1 0000000000000001 0000000000000000 1 00
-1 AC 0 1 1 0000000000000000 0000000000000000 0 00-2 AC 0 2 1 0000000000000001 0000000000000001 01 01-3 AC 0 2 1 0000000000000000 0000000000000001 00 01-1 AC 0 1 1 0000000000000000 0000000000000000 0 001 AC 0 1 1 0000000000000001 0000000000000000 1 002 AC 1 2 4 0000000000000010 0000000000011011 10 110112 AC 0 2 1 0000000000000010 0000000000000001 10 011 AC 0 1 1 0000000000000001 0000000000000000 1 001 AC 0 1 1 0000000000000001 0000000000000000 1 00
-1 AC 2 1 4 0000000000000000 0000000000011100 0 11100-1 AC 0 1 1 0000000000000000 0000000000000000 0 000 AC 15 0 10 x 0000011111111001 x 11111111001
-1 AC 1 1 3 0000000000000000 0000000000001100 0 11000 AC 15 0 3 x 0000000000001010 - -
encoder input
82
Kode pada Tabel 4.8 disusun dari nilai-nilai huff dan sym yang berasal
dari Tabel 4.7. Nilai-nilai tersebut didapat dari proses penyandian entropi. Kode
pada Tabel 4.8 akan dicoba diuraikan untuk menunjukkan bahwa kode tersusun
dari nilai huff dan sym. Misalnya pada Tabel 4.8 baris ke-1.
Nilai kode stuffed = 10111010, dengan perjanjian bit paling kiri adalah bit
7 dan bit paling kanan adalah bit 0, dapat diketahui bahwa bit 0 – 3 tersusun dari
kode sym dan huff dari baris ke-1 Tabel 4.7 yaitu, sym = 1, huff = 010
menghasilkan 1010 (4 bit paling belakang kode stuffed)
Data pada baris ke-2 Tabel 4.8 dikodekan dengan sym =0010 dan huff =
1011. Kode ini dibagi pada sebagian byte yang ada di baris pertama dan sebagian
byte baris kedua Tabel 4.8. Penjelasannya sebagai berikut.
Tabel 4.8 Hasil penyandian blok ke-0 dalam paket 8 bit
Data baris pertama Tabel 4.8 = 10111010. Empat bit paling belakang sudah
dipakai oleh kode sebelumnya. Pada 4 bit paling depan didapat angka 1011 yang
merupakan kode huff dari data ke-2 Tabel 4.7. Kode sym dari data ke-2 Tabel 14
(0010) diletakkan pada byte baris kedua Tabel 4.8 = 10010010, yaitu pada empat
82
data valid ke- sandi terpaket 8 bit1 101110102 100100103 110100014 010110105 001011106 110100107 010011018 010101009 00000100
10 1011100011 0100110112 1001001013 0100001114 1111111015 10011001
83
bit paling belakang.
4.1.9. Latensi sistem secara keseluruhan
Latensi adalah tertundanya pengeluaran data output akibat adanya proses
pipeline. Pada sistem ini, latensi diukur pada saat data output pertama
dikeluarkan.
Gambar 4.14 Diagram pewaktuan latensi sistem
Output yang dimaksud adalah output dari bit stuffer yang merupakan
output utama dari sistem. Waktu keluarnya output itulah waktu latensi dari sistem.
Berdasarkan hasil simulasi pada Gambar 4.14, output bit stuffer yang pertama
keluar pada saat t = 3790 ns dengan clock 50 MHz atau periode 20 ns. Dihitung
berdasarkan siklus clock-nya, pipeline latency sistem yang dirancang adalah 170
siklus clock.
4.1.10. Pengujian Dekompresi Data Hasil Simulasi Xilinx ISE
Hasil simulasi kompresi menggunakan Xilinx ISE disimpan di dalam suatu
file teks. Tampilan editor file teks untuk data hasil kompresi ditunjukkan pada
Gambar 4.15. Data hasil kompresi pada simulasi VHDL akan didekompresi
menggunakan program dalam Matlab. Proses dekompresi dilakukan dengan cara
entropy decoding – inverese zigzag – dekuantisasi – IDCT-2D. Hasil dekompresi
83
84
atau pemulihan citra tersebut dibandingkan dengan data sumber yang semula.
Hasil perbandingan untuk blok-0 berukuran 8x8 ditampilkan pada Tabel 4.9. Citra
yang digunakan untuk analisis ini adalah citra pada Gambar 4.1. Berdasarkan
Tabel 4.9, selisih pada beberapa data dekompresi dengan citra asli cukup besar.
Untuk melihat pengaruhnya terhadap citra, pengamatan harus dilakukan pada citra
yang sesungguhnya. Dengan ukuran citra yang besar (lebih dari 40x40), simulator
Xilinx ISE sudah mengalami penurunan unjuk kerja, karena itu, pengujian harus
dilakukan secara hardware menggunakan FPGA yang sudah dikonfigurasi dengan
rangkaian penyandi JPEG.
Gambar 4.15 Screenshot teks file hasil simulasi kompresi
4.2. Pengujian Hardware
Setelah melalui simulasi, sistem dapat diimplementasikan pada FPGA.
FPGA yang digunakan adalah Xilinx Spartan 3E seri XC3S500E. Hasil sintesis
rangkaian dari VHDL oleh Xilinx ISE 10 menghasilkan beberapa output. Output
pertama adalah utilisasi rangkaian dalam FPGA. Utilisasi memberi informasi
jumlah gerbang, slice, dan komponen FPGA lainnya. Output kedua adalah
informasi pewaktuan. Informasi ini memberi ketentuan mengenai frekuensi
maksimal yang dapat dipakai dan propagation delay terbesar yang didapat.
84
85
Tabel 4.9 Perbandingan data yang dipulihkan dengan citra asli (citra yang sudah dikurangi 128)
Setelah rangkaian berhasil disintesis dan dikompilasi, bit-code hasil
kompilasi digunakan untuk mengkonfigurasi FPGA. Rangkaian yang dihasilkan
diuji dengan skema sesuai Gambar 3.21. Pengujian mencakup pengukuran frame
rate , rasio kompresi, dan verifikasi hasil kompresi
4.2.1. Utilisasi Komponen
Berikut ini adalah laporan penggunaan komponen berupa gerbang, flip-
flop maupun unit aritmetika pada sistem yang dirancang.
Macro Statistics# RAMs : 2 128x14-bit dual-port RAM : 2# ROMs : 4 256x16-bit ROM : 1 256x4-bit ROM : 1 64x6-bit ROM : 1 64x8-bit ROM : 1# Multipliers : 11 11x14-bit multiplier : 5 14x14-bit multiplier : 5 14x8-bit multiplier : 1# Adders/Subtractors : 65 11-bit adder : 12 11-bit subtractor : 8 14-bit adder : 12 14-bit subtractor : 8 16-bit adder : 2 25-bit adder : 6 25-bit subtractor : 4 28-bit adder : 6
85
k0 k1 k2 k3 k4 k5 k6 k7
dec asli dec asli dec asli dec asli dec asli dec asli dec asli dec aslib0 41 42 10 7 -42 -41 -33 -42 -52 -42 17 13 32 32 37 42b1 42 38 5 11 -49 -46 -43 -45 -53 -44 18 21 39 37 43 45b2 43 29 5 15 -39 -51 -36 -41 -36 -10 27 5 50 50 48 46b3 29 33 -2 3 -27 -41 -28 -41 -22 -12 26 20 54 57 48 57b4 13 28 -20 -14 -35 -41 -44 -45 -25 -15 19 31 62 55 59 61b5 18 16 -28 -23 -43 -44 -57 -44 -14 -4 30 31 79 56 66 58b6 20 18 -37 -39 -47 -46 -51 -42 15 -6 44 51 62 49 13 51b7 4 14 -55 -54 -55 -59 -44 -45 36 26 41 39 18 51 -70 -101Dec = hasil dekompresi
86
28-bit subtractor : 4 8-bit adder : 1 9-bit adder : 1 9-bit subtractor : 1# Counters : 20 3-bit up counter : 4 4-bit up counter : 3 6-bit up counter : 1 8-bit up counter : 12# Registers : 158 1-bit register : 30 11-bit register : 34 14-bit register : 34 16-bit register : 4 25-bit register : 25 28-bit register : 25 4-bit register : 4 8-bit register : 1 9-bit register : 1# Latches : 4 16-bit latch : 2 4-bit latch : 2# Comparators : 6 8-bit comparator equal : 2 8-bit comparator not equal : 4
Utilisasi komponen FPGA seperti gerbang dan CLB ditunjukkan pada
Tabel 4.10. Dari laporan utilisasi komponen, diperoleh informasi bahwa pada
sistem yang dirancang, digunakan slice sebanyak 1421 unit, look up table (LUT)
sebanyak 2485 unit, dan pengali sebanyak 11 unit.
Tabel 4.10 Utilisasi komponen FPGA
Number of Slices: 1421 out of 4656 30% Number of Slice Flip Flops: 1913 out of 9312 20% Number of 4 input LUTs: 2485 out of 9312 26% Number used as logic: 2085 Number used as RAMs: 400 Number of MULT18X18SIOs: 11 out of 20 55% Number of GCLKs: 1 out of 24 4%
Laporan utilisasi ini memberikan informasi bahwa komponen yang tersisa
pada FPGA Spartan-3E masih banyak walaupun setelah diberi konfigurasi sistem
yang dirancang.
86
87
4.2.2. Spesifikasi Pewaktuan
Spesifikasi pewaktuan untuk rangkaian yang dirancang dapat diamati
dalam laporan hasil sintesis rangkaian. Laporan spesifikasi pewaktuan
ditunjukkan pada Tabel 4.11.
Tabel 4.11 Spesifikasi pewaktuan rangkaian yang dirancang
Speed Grade: -4 Minimum period: 38.874nsMaximum Frequency: 25.724MHz Minimum input arrival time before clock: 7.038ns Maximum output required time after clock: 4.450ns
Berdasarkan Tabel 4.11, periode clock minimal yang diperbolehkan
dipakai pada sistem yang dirancang adalah 38.874 ns dan frekuensi maksimal
25.724 MHz. Nilai-nilai tersebut didapat dari analisis delay yang terdapat pada
suatu titik atau net. Rangkuman mengenai unit-unit penyumbang delay pada
rangkaian ditunjukkan pada Tabel 4.12. Berdasarkan Tabel 4.11, frekuensi
maksimal yang dapat dipakai untuk rangkaian cukup kecil untuk ukuran penyandi
yang dioperasikan pada frekuensi tinggi.
Tabel 4.12 Unit-unit penyumbang delay pada sistem
Frekuensi maksimal yang kurang tinggi disebabkan oleh delay total yang
cukup besar. Delay total ini merupakan gabungan dari berbagai delay pada tiap
net seperti yang ditunjukkan pada Tabel 4.12. Total delay adalah 19.44 ns.
Besarnya delay dipengaruhi oleh perancangan rangkaian yang dilakukan secara
87
unit gate delay(ns) net delay(ns) total gate+netcore DCT2 3.45 1.13 4.58quantizer 6.97 1.44 8.41AC coder 1.41 1.42 2.83compress 2.42 1.21 3.63
total(ns) 14.24 5.2 19.44
88
cascade dan tidak pipelined. Berdasarkan Tabel 4.12, sumber delay paling banyak
berasal dari quantizer. Hal itu wajar karena komputasi pada unit itu tidak
dirancang secara pipeline.
4.2.3. Perhitungan Pesat Frame
Pengukuran pesat frame dilakukan secara langsung pada FPGA, karena
simulasi tidak bisa berjalan untuk ukuran frame citra di atas 40x40. Skema
pengujian ditunjukkan pada Gambar 3.21. Waktu yang dibutuhkan untuk
mengolah satu frame citra diukur dari pertama kali isyarat masukan en diaktifkan
sampai saat isyarat keluaran rdy berubah keadaan dari aktif menjadi tidak aktif.
Untuk mengukur waktu pengolahan satu frame digunakan satuan siklus clock.
Jumlah siklus clock yang dibutuhkan untuk mengolah satu frame bisa digunakan
untuk mengukur waktu pengolahan frame. Realisasi rangkaian bisa dilakukan
menggunakan counter dengan masukan enable berasal dari operasi OR isyarat en
dan rdy. Jumlah clock yang dihitung selama isyarat en dan rdy aktif kemudian
dikalikan dengan periode minimal yang dapat ditangani oleh sistem. Nilai yang
didapat merupakan waktu pengolahan satu frame. Periode minimal diketahui
berdasarkan tabel 4.11. Keluaran counter ditampilkan pada LCD untuk
mengetahui jumlah siklus clock. Diagram blok rangkaian penghitung siklus clock
ditampilkan pada Gambar 4.16. Pada pengukuran waktu pengolahan frame
digunakan sampel citra satu.bmp, dua.bmp, tiga.bmp, dan empat.bmp. Masing-
masing untuk ukuran 240x320 dan 480x640 dengan format grayscale. Tabel 4.13
menampilkan jumlah siklus clock untuk 4 citra masing-masing dengan ukuran
240x320 dan 480x640.
88
89
Gambar 4.16. Rangkaian penghitung siklus clock untuk pengolahan satu frame
Tabel 4.13. Jumlah siklus clock yang dibutuhkan untuk pengolahan frame pada beberapa sampel
Nama citra ukuran Jumlah clock per framesatu.bmp
dua.bmp
tiga.bmp
empat.bmp
satu.bmp
dua.bmp
tiga.bmp
empat.bmp
240x320
240x320
240x320
240x320
480x640
480x640
480x640
480x640
69.489
69.377
69.550
69.650
277.389
277.245
277.490
277.510
Berdasarkan Tabel 4.13, didapatkan rerata jumlah clock untuk citra
240x320 yaitu 69.516,5 siklus clock. Rerata jumlah clock untuk citra 480x640
adalah 277.408,5. Jika digunakan clock dengan periode minimal sesuai dengan
Tabel 4.11, yaitu 38,874 ns, waktu pengolahan frame dapat dihitung dengan cara
mengalikan jumlah clock dengan 38,874 ns. Rerata waktu pengolahan untuk
89
counter
clock
en OR rdy BinerTo
8-nibbleBCD
cnt_out
LCDcontroller
digit-0
digit-1
digit-2
digit-3
digit-0
digit-1
digit-4
digit-5
digit-6
digit-7
enable
clk
LCD
Data(4 bit)
control(2 bit)
masing-masing4 bit
20 bit
90
240x320 adalah 2,7 ms sedangkan untuk 480x640 sebesar 10,78 ms. Frame rate
dapat dihitung dengan cara membagi 1000 dengan waktu pengolahan dalam
milidetik. Rerata frame rate untuk ukuran 240x320 adalah 370,04 fps (frame per
second) sedangkan untuk ukuran 480x640 adalah 92,73 fps. Frame rate tersebut
adalah untuk citra grayscale.
Frame rate untuk citra berwarna juga dapat dihitung. Sebelum kompresi,
citra berwarna diubah dalam format Y-Cr-Cb. Y adalah tingkat keabuan, dan Cr-
Cb adalah tingkat warna (chrominance). Citra berwarna mengalami proses
downsample sebelum kompresi dengan format Y:Cr:Cb = 4 : 1 : 1. Berdasarkan
informasi tersebut, frame rate berwarna dapat dihitung dengan cara
frb = frg x 4/(4+1+1) = frg x 4/6 ..........................(4.1)
dengan fb = frame rate citra berwarna, dan fg = frame rate citra grayscale. Rerata
frame rate untuk citra berwarna 480x640 adalah 61.68 fps dan untuk citra
berwarna 240x320 adalah 246.7 fps. Tabel 4.14 menunjukkan perbandingan unjuk
kerja dan utilisasi komponen antara rangkaian yang dirancang dan beberapa
intellectual property serta IC kompresi JPEG. Pesat frame diukur pada ukuran
citra 480 x 640 dan sistem warna YCrCb = 4:1:1. Dibandingkan dengan beberapa
IC kompresi JPEG yang ada di pasaran yaitu produk Zoran(1998) dan
Inrevium(2005), rangkaian yang dirancang mempunyai pesat frame yang lebih
tinggi. Rancangan intellectual property (IP) kompresi JPEG dari Barco (2005) dan
Cast-JPEG (2008) mempunyai pesat frame yang tinggi, karena keduanya
memakai FPGA high-end dengan speed grade tinggi. Walaupun demikian,
rangkaian yang dirancang lebih sesuai diterapkan pada FPGA Spartan-3E karena
memiliki tingkat pemakaian komponen FPGA yang lebih rendah daripada kedua
90
91
intellectual property tersebut. Informasi speed grade dan utilisasi slice hanya
terdapat pada FPGA sebagai spesifikasi intellectual property.
Tabel 4.14. Perbandingan frame rate dan frekuensi maksimal antara rangkaian yang dirancang dan intellectual property JPEG serta chip kompresi JPEG yang
ada di pasaran untuk ukuran frame 480 x 640 dan sistem warna Y Cr Cb = 4:1:1.
Pembanding Spartan-3E BA119/ Barco(2005)
Cast-JPEG/Cast (2008)
ZR36060/Zoran(1998)
TE3310/Inrevium(2005)
Jenis produk
IP IP IC IC
Speed grade FPGA
4 6 6 - -
Utilisasi FPGA
Jumlah slice = 1.421
Jumlah slice = 7.497
Jumlah slice = 15.305
- -
Frekuensi maks
25,7 MHz 82 MHz 86 MHz 29.5 MHz 27 MHz
Frame rate maks
61,68 fps 120 fps 162 fps 33 fps 50 fps
4.2.4. Pengujian Rasio Kompresi
Pengujian rasio kompresi dilakukan dengan membandingkan rasio yang
dihasilkan oleh rangkaian yang dirancang dan rasio yang dihasilkan oleh software
pengolah citra. Software pengolah citra yang digunakan adalah Image Analyzer
karena ringan untuk dijalankan pada netbook. Citra sampel adalah citra grayscale
dengan ukuran 640x480, 240x320, 80x80, dan 40x40. Rasio kompresi dihitung
dengan membagi jumlah byte sesudah kompresi dengan jumlah byte sebelum
dikompresi. Rasio diukur dengan satuan bit per piksel. Citra yang sama digunakan
sebagai masukan software dan rangkaian. Faktor kualitas kompresi pada masing-
masing alat kompresi dibuat sama, yaitu 50. Tabel 4.15 menunjukkan
perbandingan ukuran data hasil kompresi antara software Image Analyzer dan
FPGA. Berdasarkan Tabel 4.15, terlihat bahwa rasio kompresi yang dihasilkan
91
92
oleh FPGA cukup mendekati rasio kompresi yang dihasilkan oleh software
dengan kualitas kompresi 50. Untuk citra berukuran kecil (80x80 dan 40x40),
rangkaian kompresi pada FPGA bahkan menghasilkan rasio kompresi yang lebih
efisien daripada software.
Tabel 4.15. Perbandingan rasio kompresi antara FPGA dan Image Analyzer
Citra dan ukurannya
Kompresi dengan FPGA Kompresi dengan Image Analyzer
(dalam piksel)
Ukuran(byte)
rasio Bit per piksel
Ukuran(byte)
rasio Bit per piksel
satu.bmp480x640
3221 10,50% 0, 839 3215 10,50% 0, 837
dua.bmp240x320
1147 14,90% 1, 194 1179 15,30% 1, 228
fruit.bmp80x80
797 12,40% 0, 990 113 17,60% 1, 408
mata.bmp40x40
326 20,40% 1, 630 654 40,80% 3, 270
Untuk mengamati citra hasil kompresi, digunakan metode dekompresi
menggunakan Matlab seperti pada bagian 4.1.10. Hasil pemulihan citra yang
terkompresi secara hardware menggunakan FPGA ditunjukkan pada Lampiran A.
Terdapat perbedaan nilai piksel antara citra yang dipulihkan dari data hasil
kompresi dan citra asli. Perbedaan tersebut menentukan kualitas citra yang
dipulihkan dari data hasil kompresi. Tingkat perbedaan diukur menggunakan MSE
(mean square error). Nilai MSE juga digunakan untuk mengukur perbedaan
antara citra hasil kompresi rangkaian dan citra hasil kompresi software Image
Analyzer dengan berbagai faktor kualitas. Tabel 4.16 menunjukkan nilai MSE
antara citra hasil kompresi rangkaian yang dipulihkan dan citra asli. Tabel 4.16
juga menunjukkan MSE antara citra hasil kompresi rangkaian dan citra
92
93
terkompresi software pada faktor kualitas (Q) 10, 25, 50, 75, dan 90. Tampak pada
Tabel 4.16 MSE terkecil untuk semua citra didapat pada faktor kualitas kompresi
software 50. Rangkaian dirancang untuk kualitas kompresi 50. MSE terkecil
tersebut menandakan bahwa ditinjau dari hasil kompresi, unjuk kerja rangkaian
dapat mendekati hasil kompresi software.
Tabel 4.16. MSE (Mean Square Error) antara hasil kompresi rangkaian dan citra asal serta citra hasil kompresi software dengan berbagai faktor kualitas
(Q=10,25,50,75 90)
File citra ukuran MSE1 MSE2 MSE3 MSE4 MSE5 MSE6
satu.bmp 240x320 0,0238 0,0243 0,0252 0,0033 0,0302 0,0401
dua.bmp 240x320 0,0279 0,0288 0,0290 0,0023 0,0340 0,0450
tiga.bmp 240x320 0,0180 0,0181 0,0180 0,0016 0,0235 0,0331
empat.bmp 240x320 0,0252 0,0259 0,0261 0,0020 0,0311 0,0425
satu.bmp 480x640 0,0087 0,0087 0,0086 0,00120 0,0110 0,0157
dua.bmp 480x640 0,0120 0,0122 0,0123 0,00098 0,0143 0,0191
tiga.bmp 480x640 0,0062 0,0061 0,0064 0,00076 0,0090 0,0131
empat.bmp 480x640 0,0082 0,0084 0,0085 0,00084 0,0115 0,0167
rerata 0,01625 0,0166 0,0168 0,00162 0,0206 0,0201
MSE1: MSE citra hasil dekompresi keluaran rangkaian - citra asalMSE2: MSE citra hasil dekompresi keluaran rangkaian - citra terkompresi software , Q=90MSE3: MSE citra hasil dekompresi keluaran rangkaian - citra terkompresi software , Q=75MSE4: MSE citra hasil dekompresi keluaran rangkaian - citra terkompresi software , Q=50MSE5: MSE citra hasil dekompresi keluaran rangkaian - citra terkompresi software , Q=25MSE6: MSE citra hasil dekompresi keluaran rangkaian - citra terkompresi software , Q=10
Kondisi citra hasil kompresi juga diukur secara kualitatif menggunakan
penilaian subjektif yang diambil berdasarkan pendapat responden yang terhadap
citra tersebut. Tabel 4.17 merangkum penilaian 10 responden terhadap citra hasil
kompresi. Citra diklasifikasikan dalam lima tingkatan kualitatif, yaitu excellent,
good, fair, poor, dan unsatisfactory (Jain, 1989). Tingkatan excellent dicapai jika
citra hasil kompresi tidak bisa dibedakan dengan citra aslinya. Setingkat di bawah
excellent, good dicapai jika citra hasil kompresi sedikit berbeda dengan citra asli,
93
94
tetapi tidak ditemukan distorsi. Jika pada citra ditemukan sedikit distorsi, tetapi
tidak menggangu penampilan, citra dimasukkan dalam tingkat fair. Jika distorsi
sudah mulai menggangu penampilan, citra dimasukkan dalam tingkat poor.
Tingkatan unsatisfactory dicapai saat tampilan citra terkompresi sudah banyak
terdistorsi dan beberapa detail sudah tidak dapat dikenali. Untuk semua citra yang
diujikan, terdapat 12 atau 15% pendapat yang menyatakan excellent dan 33 atau
41% yang menyatakan good. Pendapat yang lain sebanyak 29% menyatakan fair
dan sebanyak 15% menyatakan poor serta tidak ada pendapat unsatisfactory.
Tabel 4.17. Penilaian secara subjektif terhadap citra hasil kompresi rangkaian dibandingkan dengan citra asal
Nama file ukuran Excellent Good Fair Poor Unsatisfactory
satu.bmp 240x320 2 2 4 2 -dua.bmp 240x320 1 4 3 2 -tiga.bmp 240x320 1 3 3 3 -empat.bmp 240x320 1 2 3 4 -satu.bmp 480x640 1 7 2 - -dua.bmp 480x640 3 4 3 - -tiga.bmp 480x640 2 5 3 - -empat.bmp 480x640 1 6 2 1 -total 12 33 23 12 -% 15.00% 41,25% 28,75% 15.00%Penilaian subjektif dilakukan oleh 10 responden untuk setiap citra
4.3. Permasalahan dalam penelitian
Permasalahan yang muncul dalam penelitian ini berasal dari metode
pengujian hardware. Pengiriman data citra dari PC ke FPGA serta data
terkompresi dari FPGA ke PC dilakukan melalui jalur port serial PC. Masalah
timbul pada komunikasi melalui port serial tersebut, khususnya pada pengiriman
94
95
data dari FPGA ke PC. Adanya kesalahan tersebut dapat dideteksi melalui operasi
eksklusif-OR (XOR) yang diterapkan pada semua data yang dikirimkan dari PC
ke FPGA dan sebaliknya. Proses XOR pada pengiriman data PC-FPGA dilakukan
di sisi komputer dan di sisi FPGA. Data yang akan dikirim dihitung nilai XOR-
nya pada PC. Nilai XOR ini juga dikirimkan ke FPGA setelah semua data
terkirim. FPGA akan menghitung nilai XOR data yang diterima dari PC. Jika nilai
XOR pada FPGA sama dengan nilai XOR yang dikirim PC, tidak ada kesalahan
pada pengiriman data PC-FPGA. Proses yang sama juga dilakukan untuk
pengiriman data hasil kompresi dari FPGA ke PC. Nilai XOR data yang akan
dikirimkan ke PC dihitung di FPGA dan ikut dikirimkan ke PC. Pada sisi PC, nilai
XOR antara data yang diterima juga dihitung. Nilai XOR data diterima yang
dihitung pada PC dibandingkan dengan nilai XOR yang dikirimkan oleh FPGA.
Jika sama, tidak ada kesalahan pada pengiriman data FPGA-PC. Skema deteksi
kesalahan data menggunakan XOR ditunjukkan pada gambar 4.17.
Gambar 4.17. Skema deteksi kesalahan (a) untuk transmisi data citra dan (b) untuk transmisi data terkompresi
95
PCData citra
XOR
NilaiXOR Data citra
FPGA
XORXOR untuk semuadata yang masuk
Jika XOR = 0, tidak ada kesalahan
Data terkompresi
XOR
FPGANilaiXOR
Data terkompresiXORXOR untuk semuadata yang masuk
PC
Jika XOR = 0, tidak ada kesalahan
Jalur UART TX PC
Jalur UART RX PC
(a)
(b)
96
Berdasarkan percobaan, pada pengiriman data citra dari PC ke FPGA tidak
terdapat kesalahan. Kesalahan hanya muncul pada pengiriman data terkompresi
dari FPGA ke PC. Tabel 4.18 menunjukkan banyaknya kejadian error pada lima
kali pengiriman untuk masing-masing citra.
Tabel 4.18. Banyaknya kejadian error pada lima kali pengiriman data
Nama citra dan ukuran Banyaknya error pada lima kali transmisisatu.bmp 480x640 4dua.bmp 240x320 2fruit.bmp 80x80 1mata.bmp 40x40 0
Berdasarkan Tabel 4.18, error terjadi pada citra dengan ukuran besar, yaitu
lebih dari 80x80 piksel. Sistem pengujian tidak mampu menangani transmisi data
dalam jumlah yang besar.
Sumber clock untuk sistem kompresi diambil dari isyarat RX_rdy yang
aktif ketika 8 bit data selesai diterima oleh FPGA. Frekuensi clock yang
dihasilkan bisa diturunkan dengan memberi delay antar pengiriman data.
Pemberian delay dapat mempengaruhi error yang dihasilkan. Percobaan pada
Tabel 4.18 tidak memakai delay antar data. Berdasarkan Tabel 4.19, semakin
besar delay yang ditambahkan, error akan semakin berkurang. Dengan delay yang
besar, delay antar data yang dikirimkan dari FPGA ke PC juga semakin besar.
Berdasarkan hal tersebut, bisa disimpulkan bahwa program yang dijalankan pada
PC tidak mampu menangani pengiriman data dalam jumlah yang banyak dan
frekuensi pengiriman yang tinggi.
Penambahan delay dapat mengatasi error pada transmisi data terkompresi
96
97
dari FPGA ke PC, tetapi hal itu mengakibatkan proses kompresi menjadi lebih
lama karena periode clock menjadi lebih besar. Periode clock efektif yang
digunakan oleh sistem adalah 10 kali 1/baud rate port serial. Rumus tersebut
didapat dari lebar 1 bit pada data serial yang sebesar 1/ baud rate dan transmisi 1
byte data yang terdiri dari 10 bit, yaitu 8 bit data dan 2 start-stop bit. Untuk baud
rate 38.400 bps, didapatkan periode 10 / 38.400 atau 0,26 ms. Sebagai contoh,
pemrosesan citra satu.bmp 240x320 membutuhkan 69.489 clock. Total waktu
pemrosesan tanpa delay adalah 69.489 x 0,26 ms = 18,07 detik. Dengan
penambahan delay n milidetik pada periode clock, total waktu pemrosesan adalah
69,489 n + 18,07 detik.
Tabel 4.19. Hubungan antara delay dan error yang muncul pada transmisi
Nama citra dan ukuran
Delay (ms) Jumlah error untuk 5 kali pengiriman
satu.bmp 480x640 0 41 42 23 14 0
dua.bmp 240x320 0 21 12 0
fruit.bmp 80x80 0 11 0
97
98
BAB V
KESIMPULAN DAN SARAN
5.1. Kesimpulan
Berdasarkan hasil perancangan dan simulasi yang diperoleh sampai saat
ini, dapat diambil kesimpulan sebagai berikut.
1. Perangkat yang dirancang yaitu sistem kompresi citra JPEG berbasis
FPGA berdasarkan hasil simulasi dan pengujian hardware, dapat
melakukan kompresi citra grayscale.
2. Berdasarkan perbandingan hasil komputasi dengan Matlab, masing-
masing unit komputasi pada sistem yang dirancang mempunyai mean
square error (MSE) sebagai berikut.
• MSE keluaran DCT-1D = 0.069219
• MSE keluaran DCT-2D = 0.52796
• MSE keluaran DCT-2D terkuantisasi = 0.060552
3. Implementasi rancangan pada FPGA Xilinx Spartan-3E menghasilkan
utilisasi komponen sebagai berikut.
• Slice sebanyak 1421 unit
• Look up table sebanyak 2485 unit
• Pengali sebanyak 11 unit
4. Spesifikasi pewaktuan yang didapat dari rangkaian yang dirancang yaitu
frekuensi maksimal sebesar 25.724MHz atau periode minimal clock yang
diperbolehkan sebesar 38.874ns. Pesat data maksimal yang diizinkan
adalah sebesar frekuensi maksimal.
98
99
5. Latensi akibat proses pipeline pada rangkaian adalah 170 siklus clock
6. Frame rate rerata maksimal yang dapat dicapai oleh rangkaian kompresi
JPEG pada citra grayscale adalah 370.04 fps (frame per second) untuk
ukuran 240x320 sedangkan untuk ukuran 480x640 adalah 92.73 fps.
7. Rerata frame rate maksimal untuk citra berwarna 480x640 adalah 61.68
fps dan untuk citra berwarna 240x320 adalah 246.7 fps.
8. Rasio kompresi yang dicapai oleh rangkaian kompresi JPEG dapat
menyamai rasio yang dicapai oleh software pengolah citra. Untuk citra
berukuran kecil (80x80 dan 40x40), rasio kompresi rangkaian bahkan
lebih kecil daripada rasio kompresi software.
9. Kualitas citra hasil kompresi FPGA dapat mendekati hasil kompresi
software dengan faktor kualitas 50. Rerata MSE antara keduanya sebesar
0.00162. Rerata MSE antara citra terkompresi FPGA dan citra asli
0.01625.
10. Berdasarkan pendapat 10 responden terhadap 8 kelompok citra, sebanyak
41 % menyatakan kualitas citra hasil kompresi mempunyai tingkatan
good. 15 % menyatakan excellent , 29% fair, dan sisanya poor.
5.2. Saran
Berdasarkan kesimpulan dan hasil penelitian yang didapatkan, diberikan
saran-saran sebagai berikut.
1. Unjuk kerja rangkaian, terutama pada bagian modul akuisisi citra, dapat
ditingkatkan menggunakan SDRAM yang terpasang pada modul board
FPGA. SDRAM yang berukuran besar (32 MB) dapat digunakan untuk
99
100
menampung data citra input dan data hasil kompresi.
2. Rasio kompresi yang didapat pada FPGA sedikit berbeda dengan rasio
yang didapat pada software, terutama untuk citra dengan ukuran kecil.
Untuk meningkatkan kualitas kompresi, diperlukan tabel kuantisasi dan
tabel Huffman yang adaptif terhadap kondisi citra. Hal itu dapat direalisasi
menggunakan tambahan prosesor embedded pada FPGA.
100
101
DAFTAR PUSTAKA
Agostini, L., Ivan, S., and Sergio, B., “Pipelined Fast 2-D DCT Architecture for
JPEG Image Compression,” Symposium on Integrated Circuits and
System Design, SBCCI Proceedings, pp.226-231, 2001.
Agostini, L., Ivan S., and Sergio B., “Pipelined Entropy Coders for JPEG
Compression,” Proceedings of the 15th symposium on Integrated circuits
and systems design, pp.203-208, 2002.
Ahmed, N., Natarajan, T., and Rao, K. “Discrete Cosine Transforms”. in IEEE
Transactions on Computer., vol. C-23, pp. 90-93, 1974.
Arai Y. , Agui T., Nakajima M.. “A Fast DCT-SQ Scheme for Images”.
Transactions of IEICE, vol. E71, no. 11, pp. 1095-1097, 1988.
Barco Corporation, “JPEG Codec : BA119JPEGCOD Factsheet”, Data Sheet,
Perancis, 1998.
Cast -Inc. “JPEG-C : Baseline JPEG Codec ”,Product Specification, USA, 2008
Chen, W., Smith, C., and Fralick, S., “A Fast Computation Algorithm for the
Discrete Cosine Transform ”, in IEEE Transactions on
Communications, vol. 25, pp. 1004-1009, 1977.
Inrevium, “High Performance JPEG Coder LSI : TE3310RPF”, Data Sheet,
Japan, 2005.
Jang, Y., Kao, J., Yang, J., and Huang, P., “A 0.8u 100-MHz 2-D DCT Core
Processor”, in IEEE Transactions on Consumer Electronics, vol. 40, pp.
703-709, 1994.
Jain, A. K., “Fundamental of Digital Image Processing”, Prentice-Hall
101
102
International, New Jersey, 1989.
Loeffler, C., Ligtenberg, A. and Moschytz, G. S.,"Practical Fast 1-D DCT
Algorithms With 11 Multipliers," Proc. of IEEE Int. Conf. on ASSP ,
1989, pp. 988-991.
Magli, E., “The JPEG Family Of Coding Standard”, Part of “Document and
Image Compression”, Taylor and Francis, New York, 2004.
Okada, S., Matsuda, Y., Watanabe, T., dan Kondo, T. ,” A Single Chip Motion
JPEG CODEC LSI,” IEEE Transactions on Consumer Electronics, Vol.43,
No.3, pp.418-422, 1997.
Pillai, L. ,”Video Compression Using DCT”, Xilinx Application Note, XAPP610,
V1.2, 2002.
Solomon, D., “Data Compression : The Complete Reference”, Springer, New
York, 2004.
Sun, M., Ting C., and Albert M., “VLSI Implementation of a 16 X 16 Discrete
Cosine Transform”, IEEE Transactions on Circuits and Systems, Vol. 36,
No. 4, April 1989.
Wallace, G. K. ,''The JPEG Still Picture Compression Standard'', Communications
of the ACM, Vol. 34, Issue 4, pp.30-44. 1991.
Xilinx, Inc., “Spartan-3E FPGA Family : Data Sheet ”, Xilinx Corporation, 2009.
Zoran Corporation, “ZR36060 : Integrated JPEG Codec”, Data Sheet, USA, 1998.
Zulkarnain, M., “Real Time Implementation of Baseline JPEG Decoder Using
Floating Point DSP TMS320C31” Proceeding of IEEE TENCON, 2000,
pp. 988-991.
102
Lampiran A. Citra Uji (resolusi 480x640)
1. Satu.bmp
a. Citra Asli
A-1
b. Hasil Kompresi
rasio kompresi = 10,50% MSE (kompresi-citra asli) = 0.0238
Hasil Penilaian Subjektif(dari 10 responden):excellent : 1, good : 7, fair : 2, poor : -
A-2
2. Dua.bmp
a. Citra Asli
A-3
b. Hasil Kompresi
rasio kompresi = 13.5% MSE (kompresi-citra asli) = 0.0120
Hasil Penilaian Subjektif(dari 10 responden):excellent : 3, good : 4, fair : 3
A-4
3. Tiga.bmpa. Citra asli
A-5
b. Hasil kompresi
rasio kompresi = 9 % MSE (kompresi-citra asli) = 0.0062
Hasil Penilaian Subjektif(dari 10 responden):excellent : 2, good : 5, fair : 3
A-6
4. Empat.bmpa. Citra asli
A-7
b. Hasil kompresi
rasio kompresi = 12.1% MSE (kompresi-citra asli) = 0.0082
Hasil Penilaian Subjektif(dari 10 responden):excellent : 1, good : 6, fair : 2
A-8
Lampiran B – Hirarki desain dan Source Code
Hirarki desain
B - 1
Penyandi JPEG root(keluaran serial)
Penyandi JPEGKeluaran paralel
Paralel ke serial
Full entropy coder Core 2D-DCT+ quantizer +zigzag
DCT-1D DCT-1D #2 quantizer Zigzag ROM
Transposebuffer
zigzagbuffer
quantizerROM
AC coder DC coder Code MUX
Penghitung bedaDC antar blok
Counter RLE
Counterkategori
ROMhuffman
ROMpanjang
jpeg_ram.vhd
jpegcoder.vhdp2s.vhd
fullcoder.vhd core2.vhd
dct3_pl.vhd dct3_st2.vhd quantizer.vhd
rom_zigzag.vhd
diff_pcm.vhd ram.vhd ram.vhd qrom.vhd
ac_coder.vhd dc_coder.vhd codemux.vhd
rlectr.vhd findcat.vhd huff_rom.vhd len_rom.vhd
DCT controller
ctr2.vhd
Source code root enkoder JPEG (jpeg-ram.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
LIBRARY UNISIM;use UNISIM.VCOMPONENTS.ALL;
entity jpeg_ram isgeneric(
lebar_in:integer:=7; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port( clk: in std_logic; clk2: in std_logic;rst: in std_logic;
-- rst2: in std_logic;en: in std_logic; dat_in: in std_logic_vector(lebar_in downto 0);
-- clko: out std_logic;data_rdy: out std_logic;par_rdy: out std_logic;serial_out:out std_logic );
end jpeg_ram;architecture behav of jpeg_ram is
component jpegcoder is generic(
lebar_in:integer:=7; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port( clk: in std_logic; rst: in std_logic; en: in std_logic; dat_in: in std_logic_vector(lebar_in downto 0);cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);addr:out std_logic_vector(7 downto 0);en_out: out std_logic;--en_serial:out std_logic;valid:out std_logic );
end component;
component coderam is generic(
B - 2
lebar_data:integer:=39--lebar bus data memori );--pengali dikalikan 2^12
port( addr_baca: in std_logic_vector(7 downto 0); addr_tls: in std_logic_vector(7 downto 0); data_tls: in std_logic_vector(lebar_data downto 0); data_baca: out std_logic_vector(lebar_data downto 0); we:in std_logic; clk: in std_logic );
end component;
component p2s isport(
clk: in std_logic;clr: in std_logic;en: in std_logic;addr_tls: in std_logic_vector(7 downto 0);addr: out std_logic_vector(7 downto 0);len:in std_logic_vector(3 downto 0);huff: in std_logic_vector(15 downto 0);cat:in std_logic_vector(3 downto 0);sym: in std_logic_vector(15 downto 0);rdy: out std_logic;ser: out std_logic);
end component;
signal cat: std_logic_vector(3 downto 0);signal len: std_logic_vector(3 downto 0);signal sym: std_logic_vector(15 downto 0);signal huff: std_logic_vector(15 downto 0);signal addr_bc,addr_tls:std_logic_vector(7 downto 0);signal rdy:std_logic;signal en_serial,valid:std_logic;signal data_tls,data_bc:std_logic_vector(39 downto 0);SIGNAL clk50m_dcm : std_logic; SIGNAL clk50m : std_logic; signal clk_2 : std_logic;signal end_ser:std_logic;begin
clk_2<=clk2;koder_jpeg:jpegcoder port
map(clk,rst,en,dat_in,cat,len,sym,huff,addr_tls,rdy,valid);data_tls(39 downto 36)<=len;data_tls(35 downto 20)<=huff;data_tls(19 downto 16)<=cat;data_tls(15 downto 0)<=sym;ram_kode: coderam port map(addr_bc,addr_tls,data_tls,data_bc,valid,clk);par2ser: p2s port map(clk_2,rst,en_serial,addr_tls,addr_bc,data_bc(39 downto
36),data_bc(35 downto 20),data_bc(19 downto 16),data_bc(15 downto 0),end_ser,serial_out);
data_rdy<=end_ser;par_rdy<=rdy;
process(clk,rst) beginif(rst='1')then
en_serial<='0';
B - 3
--addr_max<=(others=>'0');elsif(rising_edge(clk)) then
if(huff="0000000000001010" and valid='1') thenen_serial<='1';
end if;if(en_serial='1' and rdy='0' and addr_bc=addr_tls-1 and
end_ser='0') thenen_serial<='0';
end if;end if;
end process;end behav;
Source code VHDL untuk penyandi JPEG keluaran paralel (jpegcoder.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; use ieee.numeric_std.all;
entity jpegcoder is generic(
lebar_in:integer:=7; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port( clk: in std_logic; rst: in std_logic; en: in std_logic; dat_in: in std_logic_vector(lebar_in downto 0);cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);addr:out std_logic_vector(7 downto 0);en_out: out std_logic;--en_serial:out std_logic;valid:out std_logic );
end entity;
architecture behav of jpegcoder iscomponent core1 is generic(
lebar_ctr:integer:=15; lebar_in:integer:=7; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port( clk: in std_logic; rst: in std_logic; en: in std_logic; dat_in: in std_logic_vector(lebar_in downto 0);
B - 4
dc: out std_logic; dat_out: out std_logic_vector(lebar_ot downto 0); dct2_rdy: out std_logic );
end component;
component fullcoder isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;data_in:in std_logic_vector(15 downto 0);cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);valid:out std_logic);
end component;
component compress isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;en: in std_logic;len:in std_logic_vector(3 downto 0);huff: in std_logic_vector(15 downto 0);cat:in std_logic_vector(3 downto 0);sym: in std_logic_vector(15 downto 0);valid: in std_logic;olen:out std_logic_vector(3 downto 0);ohuff: out std_logic_vector(15 downto 0);ocat:out std_logic_vector(3 downto 0);osym: out std_logic_vector(15 downto 0);ovalid: out std_logic);
end component;
signal tlen: std_logic_vector(3 downto 0);signal thuff: std_logic_vector(15 downto 0);signal tcat:std_logic_vector(3 downto 0);signal tsym: std_logic_vector(15 downto 0);signal tvalid: std_logic;signal ovalid:std_logic;signal ohuff: std_logic_vector(15 downto 0);
signal dc:std_logic;signal clr_tmp:std_logic;signal dct_rdy:std_logic;signal dct_out:std_logic_vector(8 downto 0);signal coder_in:std_logic_vector(15 downto 0);signal taddr:std_logic_vector(7 downto 0);begin
valid<=ovalid;huff<=ohuff;
coder_in<=dct_out(8)&dct_out(8)&dct_out(8)&dct_out(8)&dct_out(8)&dct_out(8)&dct_out(8)&dct_out;
B - 5
-- clr_tmp<=dc or rst;addr<=taddr;en_out <= dct_rdy;dctcore: core1 port map(clk,rst,en,dat_in,dc,dct_out,dct_rdy);coder:fullcoder port map(clk,rst,dc,coder_in,tcat,tlen,tsym,thuff,tvalid);kompres: compress port
map(clk,rst,dc,dct_rdy,tlen,thuff,tcat,tsym,tvalid,len,ohuff,cat,sym,ovalid);
process(clk,rst) beginif(rst='1')then
taddr<=(others=>'0');elsif(rising_edge(clk) and ovalid='1') then
taddr<=taddr+1;end if;
end process;
end behav;
Source code VHDL untuk core DCT-2D terkuantiasi (core2.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
entity core1 is generic(
lebar_ctr:integer:=15; lebar_in:integer:=7; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port( clk: in std_logic; rst: in std_logic; en: in std_logic; dat_in: in std_logic_vector(lebar_in downto 0);dc: out std_logic; dat_out: out std_logic_vector(lebar_ot downto 0); dct2_rdy: out std_logic );
end entity;
architecture struktural of core1 is
component dpcm isgeneric(
lebar_ctr:integer:=5; lebar_dat:integer:=5; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port(clk: in std_logic;
B - 6
rst: in std_logic;dc: in std_logic;din: in std_logic_vector(lebar_ot downto 0);dout: out std_logic_vector(lebar_ot downto 0));
end component;
component myROM is generic( width: integer:=6; -- lebar bit tiap alamat
depth: integer:=64; -- ada berapa byte alamat addr: integer:=6); -- lebar bus alamat
port( --din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) ); end component;
component controller is port(
clk: in std_logic; rst: in std_logic; a_in: out std_logic_vector(7 downto 0); a_out: out std_logic_vector(7 downto 0); en_dct: out std_logic; en_dct2: out std_logic; we: out std_logic; ctr_en: in std_logic; dct_rdy2: in std_logic;--penanda dct2 sudah ready datanya dct_rdy: in std_logic; rom_rdy: out std_logic; --menandai apakah rom zigzag sudah bisa diakses we2: out std_logic;dc_en: out std_logic; a2in: out std_logic_vector(7 downto 0); a2out: out std_logic_vector(7 downto 0) );
end component;
component dct8a is generic(m:integer:=13;--MSB pengali
n:integer:=7;--MSB data input k:integer:=10;--MSB output h:integer:=24;--MSB hasil kali p:integer:=12);--pengali dikalikan 2^12
port( clk: in std_logic; rst: in std_logic; en_dct: in std_logic; vin: in std_logic_vector(n downto 0); cnt_out: out std_logic_vector(3 downto 0); en_out: out std_logic; vout:out std_logic_vector(k downto 0) );
end component;
component dct8b is generic(m:integer:=13;--MSB pengali
B - 7
n:integer:=10;--MSB data input k:integer:=13;--MSB output h:integer:=27;--MSB hasil kali p:integer:=12);--pengali dikalikan 2^12
port( clk: in std_logic; rst: in std_logic; en_dct: in std_logic; vin: in std_logic_vector(n downto 0); cnt_out: out std_logic_vector(3 downto 0); en_out: out std_logic; vout:out std_logic_vector(k downto 0) );
end component;
component memori is generic(
lebar_data:integer:=13--lebar bus data memori );
port( addr_baca: in std_logic_vector(7 downto 0); addr_tls: in std_logic_vector(7 downto 0); data_tls: in std_logic_vector(lebar_data downto 0); data_baca: out std_logic_vector(lebar_data downto 0); we:in std_logic; clk: in std_logic );
end component;
component quantizer is generic(
lebar_dct:integer:=13; lebar_rom:integer:=7;--lebar bus data rom
lebar_out:integer:=8; kali:integer:=21
); port(
dct_in:in std_logic_vector(lebar_dct downto 0); rom_in:in std_logic_vector(lebar_rom downto 0); quant_out: out std_logic_vector(lebar_out downto 0) );
end component;
component myqROM is generic( width: integer:=8; -- lebar bit tiap alamat
depth: integer:=64; -- ada berapa byte alamat addr: integer:=6); -- lebar bus alamat
port( --din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) --rd: in std_logic ); end component;
signal dout: std_logic_vector(lebar_max downto 0);--keluaran memori signal dct_out: std_logic_vector(10 downto 0);--keluaran dcta
B - 8
signal dct_out2: std_logic_vector(lebar_max downto 0);--masukan dari dcta ke memori signal en_dct,en_dct2: std_logic; signal rdy,rdy2: std_logic; signal wen,wen2: std_logic; signal ain: std_logic_vector(7 downto 0); signal aout: std_logic_vector(7 downto 0); signal aout_ram2: std_logic_vector(7 downto 0); --signal dct2_out:std_logic_vector(lebar_max downto 0); signal romrdy:std_logic; signal ain2,aout2,alamat_bc:std_logic_vector(7 downto 0); signal dct2_out,dat2_out:std_logic_vector(lebar_max downto 0); signal alamat_ram2_lo:std_logic_vector(5 downto 0); signal dc_en: std_logic; signal qmul:std_logic_vector(7 downto 0); signal dat_out_tmp: std_logic_vector(lebar_ot downto 0); begin alamat_bc<=aout2(7 downto 6)&alamat_ram2_lo; dct_out2<=dct_out(10)&dct_out(10)&dct_out(10)&dct_out; dct2_rdy<=romrdy;dc<=dc_en; dcta: dct8a port map(
clk=>clk, rst=>rst, en_dct=>en, vin=>dat_in, cnt_out=>open, en_out=>rdy, vout=>dct_out);
mem: memori port map( addr_baca=>aout, addr_tls=>ain, data_tls=>dct_out2, data_baca=>dout, we=>wen, clk=>clk);
ctr: controller port map( clk=>clk, rst=>rst, a_in=>ain, a_out=>aout, en_dct=>en_dct, en_dct2=>en_dct2, we=>wen, ctr_en=>en, dct_rdy2=>rdy2, dct_rdy=>rdy, rom_rdy=>romrdy, we2=>wen2,dc_en=>dc_en, a2in=>ain2, a2out=>aout2);--aout2=aout2_hi&lo
dctb: dct8b port map( clk=>clk,
B - 9
rst=>rst, en_dct=>en_dct2, vin=>dout(10 downto 0), cnt_out=>open, en_out=>rdy2, vout=>dct2_out);
rom: myROM port map( dout=>alamat_ram2_lo, address=>aout2(5 downto 0));
mem2: memori port map(
addr_baca=>alamat_bc, addr_tls=>ain2, data_tls=>dct2_out, data_baca=>dat2_out, we=>wen2, clk=>clk);
rom2: myqROM port map( dout=>qmul, address=>alamat_ram2_lo);
--dct_in:in std_logic_vector(lebar_dct downto 0); --rom_in:in std_logic_vector(lebar_rom downto 0); --quant_out: out std_logic_vector(lebar_out downto 0)
qtizer: quantizer port map( dct_in=>dat2_out, rom_in=>qmul, quant_out=>dat_out_tmp);
diff_pcm: dpcm port map(clk => clk,rst => rst,dc => dc_en,din =>dat_out_tmp,dout => dat_out);
end struktural;
Source code VHDL untuk DCT-1D pertama (dct_pl.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
entity dct8a is generic(m:integer:=13;--MSB pengali
n:integer:=7;--MSB data input k:integer:=10;--MSB output h:integer:=24;--MSB hasil kali p:integer:=12);--pengali dikalikan 2^12
port( clk: in std_logic; rst: in std_logic;
B - 10
en_dct: in std_logic; vin: in std_logic_vector(n downto 0); cnt_out: out std_logic_vector(3 downto 0); en_out: out std_logic; vout:out std_logic_vector(k downto 0) );
end dct8a;
architecture behav of dct8a is
constant m1:std_logic_vector(m downto 0):="00101101010000"; --0.7071x4096 constant m2:std_logic_vector(m downto 0):="00011000100000"; --0.3827 constant m3:std_logic_vector(m downto 0):="00100010101001"; --0.5412 constant m4:std_logic_vector(m downto 0):="01010011101000"; --1.3066
signal out_en:std_logic; signal cnt_in:std_logic_vector(7 downto 0); signal cntr_out:std_logic_vector(7 downto 0); signal rdy: std_logic; signal cnt: std_logic_vector(3 downto 0); signal vin_0: std_logic_vector(k downto 0); signal vin_1: std_logic_vector(k downto 0); signal vin_2: std_logic_vector(k downto 0); signal vin_3: std_logic_vector(k downto 0); signal vin_4: std_logic_vector(k downto 0); signal vin_5: std_logic_vector(k downto 0); signal vin_6: std_logic_vector(k downto 0); signal vin_7: std_logic_vector(k downto 0); signal b0: std_logic_vector(k downto 0); signal b1: std_logic_vector(k downto 0); signal b2: std_logic_vector(k downto 0); signal b3: std_logic_vector(k downto 0); signal b4: std_logic_vector(k downto 0); signal b5: std_logic_vector(k downto 0); signal b6: std_logic_vector(k downto 0); signal b7: std_logic_vector(k downto 0); signal c0: std_logic_vector(k downto 0); signal c1: std_logic_vector(k downto 0); signal c2: std_logic_vector(k downto 0); signal c3: std_logic_vector(k downto 0); signal c4: std_logic_vector(k downto 0); signal c5: std_logic_vector(k downto 0); signal c6: std_logic_vector(k downto 0); signal c7: std_logic_vector(k downto 0); signal d0: std_logic_vector(k downto 0); signal d1: std_logic_vector(k downto 0); signal d2: std_logic_vector(k downto 0); signal d3: std_logic_vector(k downto 0); signal d4: std_logic_vector(k downto 0); signal d5: std_logic_vector(k downto 0); signal d6: std_logic_vector(k downto 0); signal d7: std_logic_vector(k downto 0);
B - 11
signal d8: std_logic_vector(k downto 0);
signal e0: std_logic_vector(h downto 0); signal e1: std_logic_vector(h downto 0); signal e2: std_logic_vector(h downto 0); signal e3: std_logic_vector(h downto 0); signal e4: std_logic_vector(h downto 0); signal e5: std_logic_vector(h downto 0); signal e6: std_logic_vector(h downto 0); signal e7: std_logic_vector(h downto 0); signal e8: std_logic_vector(h downto 0);
signal f0: std_logic_vector(h downto 0); signal f1: std_logic_vector(h downto 0); signal f2: std_logic_vector(h downto 0); signal f3: std_logic_vector(h downto 0); signal f4: std_logic_vector(h downto 0); signal f5: std_logic_vector(h downto 0); signal f6: std_logic_vector(h downto 0); signal f7: std_logic_vector(h downto 0);
signal s0: std_logic_vector(h downto 0); signal s1: std_logic_vector(h downto 0); signal s2: std_logic_vector(h downto 0); signal s3: std_logic_vector(h downto 0); signal s4: std_logic_vector(h downto 0); signal s5: std_logic_vector(h downto 0); signal s6: std_logic_vector(h downto 0); signal s7: std_logic_vector(h downto 0); signal ofset0: std_logic_vector(k downto 0); signal ofset1: std_logic_vector(k downto 0); signal ofset2: std_logic_vector(k downto 0); signal ofset3: std_logic_vector(k downto 0); signal ofset4: std_logic_vector(k downto 0); signal ofset5: std_logic_vector(k downto 0); signal ofset6: std_logic_vector(k downto 0);
signal ofset7: std_logic_vector(k downto 0);
--signal en_dct2:std_logic; begin cnt_out<=cnt; en_out<=out_en; myproc: process(clk,rst) begin
if(rst='1') then
cnt<="0000"; --out_en<='0'; rdy<='0'; vout<=(others=>'0');
-- en_dct2<='0';
b0<=(others=>'0'); b1<=(others=>'0'); b2<=(others=>'0'); b3<=(others=>'0');
B - 12
b4<=(others=>'0'); b5<=(others=>'0'); b6<=(others=>'0'); b7<=(others=>'0'); c0<=(others=>'0'); c1<=(others=>'0'); c2<=(others=>'0'); c3<=(others=>'0'); c4<=(others=>'0'); c5<=(others=>'0'); c6<=(others=>'0'); c7<=(others=>'0'); d0<=(others=>'0'); d1<=(others=>'0'); d2<=(others=>'0'); d3<=(others=>'0'); d4<=(others=>'0'); d5<=(others=>'0'); d6<=(others=>'0'); d7<=(others=>'0'); d8<=(others=>'0'); e0<=(others=>'0'); e1<=(others=>'0'); e2<=(others=>'0'); e3<=(others=>'0'); e4<=(others=>'0'); e5<=(others=>'0'); e6<=(others=>'0'); e7<=(others=>'0'); e8<=(others=>'0'); f0<=(others=>'0'); f1<=(others=>'0'); f2<=(others=>'0'); f3<=(others=>'0'); f4<=(others=>'0'); f5<=(others=>'0'); f6<=(others=>'0'); f7<=(others=>'0'); s0<=(others=>'0'); s1<=(others=>'0'); s2<=(others=>'0'); s3<=(others=>'0'); s4<=(others=>'0'); s5<=(others=>'0'); s6<=(others=>'0'); s7<=(others=>'0'); ofset0<=(others=>'0'); ofset1<=(others=>'0'); ofset2<=(others=>'0'); ofset3<=(others=>'0'); ofset4<=(others=>'0');
B - 13
ofset5<=(others=>'0'); ofset6<=(others=>'0'); ofset7<=(others=>'0');
elsif(rising_edge(clk)) then if(en_dct='1' or out_en='1') then case cnt is when "0000" =>
vin_0<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- b0<=vin_0+vin_7; b1<=vin_1+vin_6; b2<=vin_3-vin_4; b3<=vin_1-vin_6; b4<=vin_2+vin_5; b5<=vin_3+vin_4; b6<=vin_2-vin_5; b7<=vin_0-vin_7; ---------------------------------- vout<=s2(p+k downto p)+ofset2;
when "0001" =>
vin_1<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- c0<=b0+b5; c1<=b1-b4; c2<=b2+b6; c3<=b1+b4; c4<=b0-b5; c5<=b3+b7; c6<=b3+b6; c7<=b7; ---------------------------------- vout<=s3(p+k downto p)+ofset3; ----------------------------------
when "0010" => vin_2<=vin(n)&vin(n)&vin(n)&vin;
---------------------------------- d0<=c0+c3; d1<=c0-c3; d2<=c2; d3<=c1+c4; d4<=c2-c5; d5<=c4; d6<=c5; d7<=c6; d8<=c7; ---------------------------------- vout<=s4(p+k downto p)+ofset4;
when "0011" =>
vin_3<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- e0<=d0(k)&d0(k)&d0&"000000000000"; e1<=d1(k)&d1(k)&d1&"000000000000"; e2<=m3*d2;
B - 14
e3<=m1*d7; e4<=m4*d6; e5<=d5(k)&d5(k)&d5&"000000000000"; e6<=m1*d3; e7<=m2*d4; e8<=d8(k)&d8(k)&d8&"000000000000"; ---------------------------------- vout<=s5(p+k downto p)+ofset5;
when "0100" =>
vin_4<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- f0<=e0; f1<=e1; f2<=e5+e6; f3<=e5-e6; f4<=e3+e8; f5<=e8-e3; f6<=e2+e7; f7<=e4+e7; ----------------------------------
vout<=s6(p+k downto p)+ofset6; when "0101" =>
vin_5<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- s0<=f0; s1<=f4+f7; s2<=f2; s3<=f5-f6; s4<=f1; s5<=f5+f6; s6<=f3; s7<=f4-f7; ----------------------------------
ofset0(k downto 1)<=(others=>'0'); ofset0(0)<=f0(p-1); ofset4(k downto 1)<=(others=>'0'); ofset4(0)<=f1(p-1); ofset2(k downto 1)<=(others=>'0'); ofset2(0)<=f2(p-1); ofset6(k downto 1)<=(others=>'0'); ofset6(0)<=f3(p-1);
---------------------------------- vout<=s7(p+k downto p)+ofset7;
---------------------------------- --if(rdy='1')then -- out_en<='1'; --end if;
when "0110" => vin_6<=vin(n)&vin(n)&vin(n)&vin;
---------------------------------- vout<=s0(p+k downto p)+ofset0; ----------------------------------
ofset1(k downto 1)<=(others=>'0'); ofset1(0)<=s1(p-1); ofset3(k downto 1)<=(others=>'0');
B - 15
ofset3(0)<=s3(p-1); ofset5(k downto 1)<=(others=>'0'); ofset5(0)<=s5(p-1); ofset7(k downto 1)<=(others=>'0'); ofset7(0)<=s7(p-1);
when others => vin_7<=vin(n)&vin(n)&vin(n)&vin;
---------------------------------- vout<=s1(p+k downto p)+ofset1; ----------------------------------
end case; if(cnt="0111") then
cnt<=(others=>'0'); rdy<='1';
else cnt<=cnt+1;
end if; end if; end if;
end process;
process(clk,rst,en_dct,cnt,rdy) begin if(rst='1') then
out_en<='0'; cnt_in<=(others=>'0'); cntr_out<=(others=>'0');
elsif(rising_edge(clk)) then if(cnt="0101" and rdy='1') then
out_en<='1'; end if; if(out_en='1') then
if(cnt="0101") then cntr_out<=cntr_out+1;
end if; end if; if(en_dct='1') then
if(cnt="0111") then cnt_in<=cnt_in+1;
end if; else
if(cntr_out=cnt_in) then out_en<='0';
end if; end if;
end if; end process; end behav;
Source code untuk DCT 1D kedua (dct_st2.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all;
B - 16
use ieee.numeric_std.all;
entity dct8b is generic(m:integer:=13;--MSB pengali
n:integer:=10;--MSB data input k:integer:=13;--MSB output h:integer:=27;--MSB hasil kali p:integer:=12);--pengali dikalikan 2^12
port( clk: in std_logic; rst: in std_logic; en_dct: in std_logic; vin: in std_logic_vector(n downto 0); cnt_out: out std_logic_vector(3 downto 0); en_out: out std_logic; vout:out std_logic_vector(k downto 0) );
end dct8b;
architecture behav of dct8b is
constant m1:std_logic_vector(m downto 0):="00101101010000"; --0.7071x4096 constant m2:std_logic_vector(m downto 0):="00011000100000"; --0.3827 constant m3:std_logic_vector(m downto 0):="00100010101001"; --0.5412 constant m4:std_logic_vector(m downto 0):="01010011101000"; --1.3066
signal rdy: std_logic; signal cnt: std_logic_vector(3 downto 0); signal vin_0: std_logic_vector(k downto 0); signal vin_1: std_logic_vector(k downto 0); signal vin_2: std_logic_vector(k downto 0); signal vin_3: std_logic_vector(k downto 0); signal vin_4: std_logic_vector(k downto 0); signal vin_5: std_logic_vector(k downto 0); signal vin_6: std_logic_vector(k downto 0); signal vin_7: std_logic_vector(k downto 0); signal b0: std_logic_vector(k downto 0); signal b1: std_logic_vector(k downto 0); signal b2: std_logic_vector(k downto 0); signal b3: std_logic_vector(k downto 0); signal b4: std_logic_vector(k downto 0); signal b5: std_logic_vector(k downto 0); signal b6: std_logic_vector(k downto 0); signal b7: std_logic_vector(k downto 0); signal c0: std_logic_vector(k downto 0); signal c1: std_logic_vector(k downto 0); signal c2: std_logic_vector(k downto 0); signal c3: std_logic_vector(k downto 0); signal c4: std_logic_vector(k downto 0); signal c5: std_logic_vector(k downto 0); signal c6: std_logic_vector(k downto 0); signal c7: std_logic_vector(k downto 0);
B - 17
signal d0: std_logic_vector(k downto 0); signal d1: std_logic_vector(k downto 0); signal d2: std_logic_vector(k downto 0); signal d3: std_logic_vector(k downto 0); signal d4: std_logic_vector(k downto 0); signal d5: std_logic_vector(k downto 0); signal d6: std_logic_vector(k downto 0); signal d7: std_logic_vector(k downto 0); signal d8: std_logic_vector(k downto 0);
signal e0: std_logic_vector(h downto 0); signal e1: std_logic_vector(h downto 0); signal e2: std_logic_vector(h downto 0); signal e3: std_logic_vector(h downto 0); signal e4: std_logic_vector(h downto 0); signal e5: std_logic_vector(h downto 0); signal e6: std_logic_vector(h downto 0); signal e7: std_logic_vector(h downto 0); signal e8: std_logic_vector(h downto 0);
signal f0: std_logic_vector(h downto 0); signal f1: std_logic_vector(h downto 0); signal f2: std_logic_vector(h downto 0); signal f3: std_logic_vector(h downto 0); signal f4: std_logic_vector(h downto 0); signal f5: std_logic_vector(h downto 0); signal f6: std_logic_vector(h downto 0); signal f7: std_logic_vector(h downto 0);
signal s0: std_logic_vector(h downto 0); signal s1: std_logic_vector(h downto 0); signal s2: std_logic_vector(h downto 0); signal s3: std_logic_vector(h downto 0); signal s4: std_logic_vector(h downto 0); signal s5: std_logic_vector(h downto 0); signal s6: std_logic_vector(h downto 0); signal s7: std_logic_vector(h downto 0); signal ofset0: std_logic_vector(k downto 0); signal ofset1: std_logic_vector(k downto 0); signal ofset2: std_logic_vector(k downto 0); signal ofset3: std_logic_vector(k downto 0); signal ofset4: std_logic_vector(k downto 0); signal ofset5: std_logic_vector(k downto 0); signal ofset6: std_logic_vector(k downto 0);
signal ofset7: std_logic_vector(k downto 0);
signal out_en:std_logic; signal cnt_in:std_logic_vector(7 downto 0); signal cntr_out:std_logic_vector(7 downto 0);
begin cnt_out<=cnt; en_out<=out_en; myproc: process(clk,rst) begin
if(rst='1') then
B - 18
cnt<="0000"; --out_en<='0'; rdy<='0'; vout<=(others=>'0');
b0<=(others=>'0'); b1<=(others=>'0'); b2<=(others=>'0'); b3<=(others=>'0'); b4<=(others=>'0'); b5<=(others=>'0'); b6<=(others=>'0'); b7<=(others=>'0'); c0<=(others=>'0'); c1<=(others=>'0'); c2<=(others=>'0'); c3<=(others=>'0'); c4<=(others=>'0'); c5<=(others=>'0'); c6<=(others=>'0'); c7<=(others=>'0'); d0<=(others=>'0'); d1<=(others=>'0'); d2<=(others=>'0'); d3<=(others=>'0'); d4<=(others=>'0'); d5<=(others=>'0'); d6<=(others=>'0'); d7<=(others=>'0'); d8<=(others=>'0'); e0<=(others=>'0'); e1<=(others=>'0'); e2<=(others=>'0'); e3<=(others=>'0'); e4<=(others=>'0'); e5<=(others=>'0'); e6<=(others=>'0'); e7<=(others=>'0'); e8<=(others=>'0'); f0<=(others=>'0'); f1<=(others=>'0'); f2<=(others=>'0'); f3<=(others=>'0'); f4<=(others=>'0'); f5<=(others=>'0'); f6<=(others=>'0'); f7<=(others=>'0'); s0<=(others=>'0'); s1<=(others=>'0'); s2<=(others=>'0'); s3<=(others=>'0'); s4<=(others=>'0');
B - 19
s5<=(others=>'0'); s6<=(others=>'0'); s7<=(others=>'0'); ofset0<=(others=>'0'); ofset1<=(others=>'0'); ofset2<=(others=>'0'); ofset3<=(others=>'0'); ofset4<=(others=>'0'); ofset5<=(others=>'0'); ofset6<=(others=>'0'); ofset7<=(others=>'0');
elsif(rising_edge(clk)) then if(en_dct='1' or out_en='1') then case cnt is when "0000" =>
vin_0<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- b0<=vin_0+vin_7; b1<=vin_1+vin_6; b2<=vin_3-vin_4; b3<=vin_1-vin_6; b4<=vin_2+vin_5; b5<=vin_3+vin_4; b6<=vin_2-vin_5; b7<=vin_0-vin_7; ---------------------------------- vout<=s2(p+k downto p)+ofset2;
when "0001" =>
vin_1<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- c0<=b0+b5; c1<=b1-b4; c2<=b2+b6; c3<=b1+b4; c4<=b0-b5; c5<=b3+b7; c6<=b3+b6; c7<=b7; ---------------------------------- vout<=s3(p+k downto p)+ofset3; ----------------------------------
when "0010" => vin_2<=vin(n)&vin(n)&vin(n)&vin;
---------------------------------- d0<=c0+c3; d1<=c0-c3; d2<=c2; d3<=c1+c4; d4<=c2-c5; d5<=c4; d6<=c5; d7<=c6; d8<=c7;
B - 20
---------------------------------- vout<=s4(p+k downto p)+ofset4;
when "0011" =>
vin_3<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- e0<=d0(k)&d0(k)&d0&"000000000000"; e1<=d1(k)&d1(k)&d1&"000000000000"; e2<=m3*d2; e3<=m1*d7; e4<=m4*d6; e5<=d5(k)&d5(k)&d5&"000000000000"; e6<=m1*d3; e7<=m2*d4; e8<=d8(k)&d8(k)&d8&"000000000000"; ---------------------------------- vout<=s5(p+k downto p)+ofset5;
when "0100" =>
vin_4<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- f0<=e0; f1<=e1; f2<=e5+e6; f3<=e5-e6; f4<=e3+e8; f5<=e8-e3; f6<=e2+e7; f7<=e4+e7; ----------------------------------
vout<=s6(p+k downto p)+ofset6; when "0101" =>
vin_5<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- s0<=f0; s1<=f4+f7; s2<=f2; s3<=f5-f6; s4<=f1; s5<=f5+f6; s6<=f3; s7<=f4-f7; ----------------------------------
ofset0(k downto 1)<=(others=>'0'); ofset0(0)<=f0(p-1); ofset4(k downto 1)<=(others=>'0'); ofset4(0)<=f1(p-1); ofset2(k downto 1)<=(others=>'0'); ofset2(0)<=f2(p-1); ofset6(k downto 1)<=(others=>'0'); ofset6(0)<=f3(p-1);
---------------------------------- vout<=s7(p+k downto p)+ofset7;
---------------------------------- --if(rdy='1')then -- en_out<='1';
B - 21
--end if; when "0110" =>
vin_6<=vin(n)&vin(n)&vin(n)&vin; ---------------------------------- vout<=s0(p+k downto p)+ofset0; ----------------------------------
ofset1(k downto 1)<=(others=>'0'); ofset1(0)<=s1(p-1); ofset3(k downto 1)<=(others=>'0'); ofset3(0)<=s3(p-1); ofset5(k downto 1)<=(others=>'0'); ofset5(0)<=s5(p-1); ofset7(k downto 1)<=(others=>'0'); ofset7(0)<=s7(p-1);
when others => vin_7<=vin(n)&vin(n)&vin(n)&vin;
---------------------------------- vout<=s1(p+k downto p)+ofset1; ----------------------------------
end case; if(cnt="0111") then
cnt<=(others=>'0'); rdy<='1';
else cnt<=cnt+1;
end if; end if; end if;
end process;
process(clk,rst,en_dct,cnt,rdy) begin if(rst='1') then
out_en<='0'; cnt_in<=(others=>'0'); cntr_out<=(others=>'0');
elsif(rising_edge(clk)) then if(cnt="0101" and rdy='1') then
out_en<='1'; end if; if(out_en='1') then
if(cnt="0101") then cntr_out<=cntr_out+1;
end if; end if; if(en_dct='1') then
if(cnt="0111") then cnt_in<=cnt_in+1;
end if; else
if(cntr_out=cnt_in) then out_en<='0';
end if; end if;
end if; end process; end behav;
B - 22
Source code transpose buffer dan zigzag buffer (ram.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
entity memori is generic(
lebar_data:integer:=13--lebar bus data memori );--pengali dikalikan 2^12
port( addr_baca: in std_logic_vector(7 downto 0); addr_tls: in std_logic_vector(7 downto 0); data_tls: in std_logic_vector(lebar_data downto 0); data_baca: out std_logic_vector(lebar_data downto 0); we:in std_logic; clk: in std_logic );
end entity;
architecture behav of memori is type ram is array (0 to 127) of
std_logic_vector(13 downto 0); signal mem:ram; begin mem_write: process(clk) begin if(falling_edge(clk) and we='1') then
mem(conv_integer(addr_tls)) <= data_tls; end if; end process; data_baca<=mem(conv_integer(addr_baca)); end;
Source code untuk quantizer (quantizer.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; entity quantizer is generic(
lebar_dct:integer:=13; lebar_rom:integer:=7;--lebar bus data rom
lebar_out:integer:=8; kali:integer:=21
); port(
dct_in:in std_logic_vector(lebar_dct downto 0);
B - 23
rom_in:in std_logic_vector(lebar_rom downto 0); quant_out: out std_logic_vector(lebar_out downto 0) );
end quantizer; architecture behav of quantizer is signal hasil_kali: std_logic_vector(kali downto 0); --signal ofset:std_logic_vector(lebar_out-1 downto 0); constant ofset:std_logic_vector(lebar_out-1 downto 0):="00000000"; begin hasil_kali<=dct_in*rom_in; quant_out<=hasil_kali(20 downto 12)+(ofset&hasil_kali(11)); end;
Source code untuk ROM quantizer (qrom.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity myqROM is generic( width: integer:=8; -- lebar bit tiap alamat
depth: integer:=64; -- ada berapa byte alamat addr: integer:=6); -- lebar bus alamat
port( --din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) --rd: in std_logic ); end myqROM;
architecture behav of myqROM is
-- use array to define the bunch of internal temparary signals
type ROMtipe is array (0 to depth-1) of std_logic_vector(width-1 downto 0);
signal tmp_rom: ROMtipe;
begin
tmp_rom(0)<="00100000"; tmp_rom(1)<="00100010"; tmp_rom(2)<="00100111"; tmp_rom(3)<="00011011"; tmp_rom(4)<="00010101"; tmp_rom(5)<="00010000"; tmp_rom(6)<="00010011"; tmp_rom(7)<="00011110"; tmp_rom(8)<="00011111"; tmp_rom(9)<="00010110"; tmp_rom(10)<="00010100"; tmp_rom(11)<="00010001"; tmp_rom(12)<="00001110"; tmp_rom(13)<="00001000";
B - 24
tmp_rom(14)<="00001011"; tmp_rom(15)<="00011000"; tmp_rom(16)<="00011100"; tmp_rom(17)<="00010110"; tmp_rom(18)<="00010011"; tmp_rom(19)<="00001110"; tmp_rom(20)<="00001010"; tmp_rom(21)<="00001001"; tmp_rom(22)<="00001010"; tmp_rom(23)<="00011001"; tmp_rom(24)<="00011111"; tmp_rom(25)<="00010010"; tmp_rom(26)<="00001111"; tmp_rom(27)<="00001101"; tmp_rom(28)<="00001001"; tmp_rom(29)<="00000110"; tmp_rom(30)<="00001010"; tmp_rom(31)<="00011001"; tmp_rom(32)<="00011100"; tmp_rom(33)<="00010001"; tmp_rom(34)<="00001011"; tmp_rom(35)<="00001000"; tmp_rom(36)<="00001000"; tmp_rom(37)<="00000110"; tmp_rom(38)<="00001001"; tmp_rom(39)<="00011000"; tmp_rom(40)<="00011011"; tmp_rom(41)<="00001101"; tmp_rom(42)<="00001001"; tmp_rom(43)<="00001001"; tmp_rom(44)<="00001000"; tmp_rom(45)<="00001000"; tmp_rom(46)<="00001011"; tmp_rom(47)<="00011010"; tmp_rom(48)<="00010011"; tmp_rom(49)<="00001011"; tmp_rom(50)<="00001001"; tmp_rom(51)<="00001001"; tmp_rom(52)<="00001001"; tmp_rom(53)<="00001010"; tmp_rom(54)<="00001111"; tmp_rom(55)<="00100010"; tmp_rom(56)<="00011010"; tmp_rom(57)<="00001111"; tmp_rom(58)<="00001111"; tmp_rom(59)<="00010000"; tmp_rom(60)<="00010001"; tmp_rom(61)<="00011000"; tmp_rom(62)<="00100001"; tmp_rom(63)<="01000100"; dout <= tmp_rom(conv_integer(address)); end behav;
Source code untuk ROM generator zigzag (rom_zigzag.vhd)
library ieee;
B - 25
use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity myROM is generic( width: integer:=6; -- lebar bit tiap alamat
depth: integer:=64; -- ada berapa byte alamat addr: integer:=6); -- lebar bus alamat
port( --din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) --rd: in std_logic ); end myROM;
architecture behav of myROM is
-- use array to define the bunch of internal temparary signals
type ROMtipe is array (0 to depth-1) of std_logic_vector(width-1 downto 0);
signal tmp_rom: ROMtipe;
begin
tmp_rom(0)<="000000"; tmp_rom(1)<="000001"; tmp_rom(2)<="001000"; tmp_rom(3)<="010000"; tmp_rom(4)<="001001"; tmp_rom(5)<="000010"; tmp_rom(6)<="000011"; tmp_rom(7)<="001010"; tmp_rom(8)<="010001"; tmp_rom(9)<="011000"; tmp_rom(10)<="100000"; tmp_rom(11)<="011001"; tmp_rom(12)<="010010"; tmp_rom(13)<="001011"; tmp_rom(14)<="000100"; tmp_rom(15)<="000101"; tmp_rom(16)<="001100"; tmp_rom(17)<="010011"; tmp_rom(18)<="011010"; tmp_rom(19)<="100001"; tmp_rom(20)<="101000"; tmp_rom(21)<="110000"; tmp_rom(22)<="101001"; tmp_rom(23)<="100010"; tmp_rom(24)<="011011"; tmp_rom(25)<="010100"; tmp_rom(26)<="001101"; tmp_rom(27)<="000110"; tmp_rom(28)<="000111"; tmp_rom(29)<="001110"; tmp_rom(30)<="010101";
B - 26
tmp_rom(31)<="011100"; tmp_rom(32)<="100011"; tmp_rom(33)<="101010"; tmp_rom(34)<="110001"; tmp_rom(35)<="111000"; tmp_rom(36)<="111001"; tmp_rom(37)<="110010"; tmp_rom(38)<="101011"; tmp_rom(39)<="100100"; tmp_rom(40)<="011101"; tmp_rom(41)<="010110"; tmp_rom(42)<="001111"; tmp_rom(43)<="010111"; tmp_rom(44)<="011110"; tmp_rom(45)<="100101"; tmp_rom(46)<="101100"; tmp_rom(47)<="110011"; tmp_rom(48)<="111010"; tmp_rom(49)<="111011"; tmp_rom(50)<="110100"; tmp_rom(51)<="101101"; tmp_rom(52)<="100110"; tmp_rom(53)<="011111"; tmp_rom(54)<="100111"; tmp_rom(55)<="101110"; tmp_rom(56)<="110101"; tmp_rom(57)<="111100"; tmp_rom(58)<="111101"; tmp_rom(59)<="110110"; tmp_rom(60)<="101111"; tmp_rom(61)<="110111"; tmp_rom(62)<="111110"; tmp_rom(63)<="111111";
dout <= tmp_rom(conv_integer(address));
end behav;
Source code untuk menghitung beda koefisien DC antar blok (dpcm.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
entity dpcm isgeneric(
lebar_ctr:integer:=5; lebar_dat:integer:=5; lebar_ot:integer:=8; lebar_max:integer:=13--lebar bus data memori );
port(clk: in std_logic;
B - 27
rst: in std_logic;dc: in std_logic;din: in std_logic_vector(lebar_ot downto 0);dout: out std_logic_vector(lebar_ot downto 0));
end dpcm;
architecture behav of dpcm iscomponent mux21 isport(
a: in std_logic_vector(8 downto 0);b: in std_logic_vector(8 downto 0);sel: in std_logic;y: out std_logic_vector(8 downto 0));end component;
signal ctr: std_logic_vector(lebar_ctr downto 0);signal dctemp: std_logic_vector(lebar_ot downto 0);signal mulai: std_logic;signal diff: std_logic_vector(lebar_ot downto 0);beginmuxpcm:
mux21 port map(din,diff,dc,dout);diff<=din-dctemp;
process(clk,rst,dc) begin if(rst='1') then
dctemp<=(others=>'0');elsif(rising_edge(clk) and dc='1')then
dctemp<=din;end if;end process;
end behav;
Source code penyandi entropi DC dan AC (fullcoder.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity fullcoder isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;data_in:in std_logic_vector(15 downto 0);cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);valid:out std_logic);
end fullcoder;architecture behav of fullcoder is
B - 28
component ac_coder isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;data_in:in std_logic_vector(15 downto 0);cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);valid:out std_logic);
end component;component huff_dc isport(
dc_cat: in std_logic_vector(3 downto 0);dc_code: out std_logic_vector(15 downto 0);len: out std_logic_vector(3 downto 0));
end component;component codemux isport(
alen: in std_logic_vector(3 downto 0);blen: in std_logic_vector(3 downto 0);ahuff: in std_logic_vector(15 downto 0);bhuff: in std_logic_vector(15 downto 0);sel: in std_logic;len: out std_logic_vector(3 downto 0);huff: out std_logic_vector(15 downto 0));
end component;signal tmpcat: std_logic_vector(3 downto 0);signal aclen: std_logic_vector(3 downto 0);signal dclen: std_logic_vector(3 downto 0);signal achuff: std_logic_vector(15 downto 0);signal dchuff: std_logic_vector(15 downto 0);
begincat<=tmpcat;coder_ac: ac_coder port map(clk,clr,dc,data_in,tmpcat,aclen,sym,achuff,valid);
coder_dc: huff_dc port map(tmpcat,dchuff,dclen);
mymux: codemux port map(aclen,dclen,achuff,dchuff,dc,len,huff);end behav;
Source code core penyandi AC (ac_coder.vhd)library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity ac_coder isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;data_in:in std_logic_vector(15 downto 0);
B - 29
cat:out std_logic_vector(3 downto 0);len:out std_logic_vector(3 downto 0);sym:out std_logic_vector(15 downto 0);huff:out std_logic_vector(15 downto 0);valid:out std_logic);
end ac_coder;
architecture behav of ac_coder iscomponent rle_ctr isport(
clk: in std_logic;clr: in std_logic;dc : in std_logic;data_in:in std_logic_vector(15 downto 0);run:out std_logic_vector(3 downto 0);valid:out std_logic);
end component;
component findcat isport(a: in std_logic_vector(15 downto 0);cat: out std_logic_vector(3 downto 0);sym: out std_logic_vector(15 downto 0)); end component;
component dataROM is generic( width: integer:=16; -- lebar bit tiap alamat
depth: integer:=256; -- ada berapa byte alamat addr: integer:=8); -- lebar bus alamat
port( dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) ); end component;
component lenROM is generic( width: integer:=4; -- lebar bit tiap alamat
depth: integer:=256; -- ada berapa byte alamat addr: integer:=8); -- lebar bus alamat
port( dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) ); end component;
signal romadr:std_logic_vector(7 downto 0);signal run:std_logic_vector(3 downto 0);signal cat_tmp:std_logic_vector(3 downto 0);begin
cat<=cat_tmp;romadr(7 downto 4)<=run;romadr(3 downto 0)<=cat_tmp;k1:rle_ctr port map(clk => clk,
clr => clr,dc => dc,data_in => data_in,run => run,
B - 30
valid => valid);
k2:findcat port map(a=>data_in,cat=>cat_tmp,sym=>sym);
k3:dataROM port map(dout=>huff,address=>romadr);
k4:lenROM port map(dout=>len,address=>romadr);
end behav;
Source code penghitung RLE (rle_ctr.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity rle_ctr isport(
clk: in std_logic;clr: in std_logic;dc: in std_logic;data_in:in std_logic_vector(15 downto 0);run:out std_logic_vector(3 downto 0);valid:out std_logic);
end rle_ctr;
architecture behav of rle_ctr issignal ctr: std_logic_vector(3 downto 0);signal data_tmp:std_logic_vector(15 downto 0);signal tmp_val: std_logic;signal run15: std_logic;begintmp_val<=data_tmp(15) or data_tmp(14) or data_tmp(13) or data_tmp(12) or data_tmp(11) or data_tmp(10) or data_tmp(9) or data_tmp(8) or data_tmp(7) or data_tmp(6) or data_tmp(5) or data_tmp(4) or data_tmp(3) or data_tmp(2) or data_tmp(1) or data_tmp(0) or run15 or dc;run<=ctr;valid<=tmp_val;data_tmp<=data_in;run15<=ctr(0) and ctr(1) and ctr(2) and ctr(3); process(clr,clk)begin
if((clr='1') or (dc='1')) then-- val<=(others=>'0');
ctr<=(others=>'0');-- tmp_val<='0';
elsif(rising_edge(clk)) then-- data_tmp<=data_in;
if(tmp_val='0') thenctr<=ctr+1;
elsectr<=(others=>'0');
B - 31
end if;end if;
end process;end behav;
Source code penghitung kategori (findcat.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all;
entity findcat isport(a: in std_logic_vector(15 downto 0);cat: out std_logic_vector(3 downto 0);sym: out std_logic_vector(15 downto 0)); end findcat;
architecture behav of findcat issignal atmp: signed(15 downto 0);signal b: signed(15 downto 0);signal tmp: signed(15 downto 0);signal state: std_logic_vector(3 downto 0);constant con1: signed:="0000000000000011";constant con2: signed:="0000000000000111";constant con3: signed:="0000000000001111";constant con4: signed:="0000000000011111";constant con5: signed:="0000000000111111";constant con6: signed:="0000000001111111";constant con7: signed:="0000000011111111";constant con8: signed:="0000000111111111";constant con9: signed:= "0000001111111111";constant con10: signed:="0000011111111111";constant con11: signed:="0000111111111111";constant con12: signed:="0001111111111111";constant con13: signed:="0011111111111111";constant con14: signed:="0111111111111111";beginatmp<=signed(a);b<=abs(atmp);sym<=std_logic_vector(tmp);process(atmp,b)begin
if(std_logic_vector(b(15 downto 0))="0000000000000000") thencat<=(others=>'0');
elsif(std_logic_vector(b(15 downto 0))="0000000000000001") thencat<="0001";if(atmp(15)='1')then
tmp<="0000000000000000";else
tmp<="0000000000000001";end if;
elsif(std_logic_vector(b(15 downto 1))="000000000000001") thencat<="0010";
B - 32
if(atmp(15)='1')thentmp<=con1-b;
elsetmp<=b;
end if;elsif(std_logic_vector(b(15 downto 2))="00000000000001") then
cat<="0011";if(atmp(15)='1')then
tmp<=con2-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 3))="0000000000001") thencat<="0100";if(atmp(15)='1')then
tmp<=con3-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 4))="000000000001") thencat<="0101";if(atmp(15)='1')then
tmp<=con4-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 5))="00000000001") thencat<="0110";if(atmp(15)='1')then
tmp<=con5-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 6))="0000000001") thencat<="0111";if(atmp(15)='1')then
tmp<=con6-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 7))="000000001") thencat<="1000";if(atmp(15)='1')then
tmp<=con7-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 8))="00000001") thencat<="1001";if(atmp(15)='1')then
tmp<=con8-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 9))="0000001") thencat<="1010";if(atmp(15)='1')then
B - 33
tmp<=con9-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 10))="000001") thencat<="1011";if(atmp(15)='1')then
tmp<=con10-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 11))="00001") thencat<="1100";if(atmp(15)='1')then
tmp<=con11-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 12)) ="0001") thencat<="1101";if(atmp(15)='1')then
tmp<=con12-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 13)) ="001") thencat<="1110";if(atmp(15)='1')then
tmp<=con13-b;else
tmp<=b;end if;
elsif(std_logic_vector(b(15 downto 14)) ="01") thencat<="1111";if(atmp(15)='1')then
tmp<=con14-b;else
tmp<=b;end if;
end if;end process;end behav;
Source code ROM untuk tabel huffmann (huff_rom.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity dataROM is generic( width: integer:=16; -- lebar bit tiap alamat
depth: integer:=256; -- ada berapa byte alamat addr: integer:=8); -- lebar bus alamat
port(
B - 34
--din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) --rd: in std_logic ); end dataROM;
architecture behav of dataROM is
-- use array to define the bunch of internal temparary signals
type ROMtipe is array (0 to depth-1) of std_logic_vector(width-1 downto 0);
signal tmp_rom: ROMtipe;
begin
tmp_rom(0)<="0000000000001010";tmp_rom(1)<="0000000000000000";tmp_rom(2)<="0000000000000001";tmp_rom(3)<="0000000000000100";tmp_rom(4)<="0000000000001011";tmp_rom(5)<="0000000000011010";tmp_rom(6)<="0000000001111000";tmp_rom(7)<="0000000011111000";tmp_rom(8)<="0000001111110110";tmp_rom(9)<="1111111110000010";tmp_rom(10)<="1111111110000011";tmp_rom(17)<="0000000000001100";tmp_rom(18)<="0000000000011011";tmp_rom(19)<="0000000001111001";tmp_rom(20)<="0000000111110110";tmp_rom(21)<="0000011111110110";tmp_rom(22)<="1111111110000100";tmp_rom(23)<="1111111110000101";tmp_rom(24)<="1111111110000110";tmp_rom(25)<="1111111110000111";tmp_rom(26)<="1111111110001000";tmp_rom(33)<="0000000000011100";tmp_rom(34)<="0000000011111001";tmp_rom(35)<="0000001111110111";tmp_rom(36)<="0000111111110100";tmp_rom(37)<="1111111110001001";tmp_rom(38)<="1111111110001010";tmp_rom(39)<="1111111110001011";tmp_rom(40)<="1111111110001100";tmp_rom(41)<="1111111110001101";tmp_rom(42)<="1111111110001110";tmp_rom(49)<="0000000000111010";tmp_rom(50)<="0000000111110111";tmp_rom(51)<="0000111111110101";tmp_rom(52)<="1111111110001111";tmp_rom(53)<="1111111110010000";tmp_rom(54)<="1111111110010001";tmp_rom(55)<="1111111110010010";tmp_rom(56)<="1111111110010011";tmp_rom(57)<="1111111110010100";
B - 35
tmp_rom(58)<="1111111110010101";tmp_rom(65)<="0000000000111011";tmp_rom(66)<="0000001111111000";tmp_rom(67)<="1111111110010110";tmp_rom(68)<="1111111110010111";tmp_rom(69)<="1111111110011000";tmp_rom(70)<="1111111110011001";tmp_rom(71)<="1111111110011010";tmp_rom(72)<="1111111110011011";tmp_rom(73)<="1111111110011100";tmp_rom(74)<="1111111110011101";tmp_rom(81)<="0000000001111010";tmp_rom(82)<="0000011111110111";tmp_rom(83)<="1111111110011110";tmp_rom(84)<="1111111110011111";tmp_rom(85)<="1111111110100000";tmp_rom(86)<="1111111110100001";tmp_rom(87)<="1111111110100010";tmp_rom(88)<="1111111110100011";tmp_rom(89)<="1111111110100100";tmp_rom(90)<="1111111110100101";tmp_rom(97)<="0000000001111011";tmp_rom(98)<="0000111111110110";tmp_rom(99)<="1111111110100110";tmp_rom(100)<="1111111110100111";tmp_rom(101)<="1111111110101000";tmp_rom(102)<="1111111110101001";tmp_rom(103)<="1111111110101010";tmp_rom(104)<="1111111110101011";tmp_rom(105)<="1111111110101100";tmp_rom(106)<="1111111110101101";tmp_rom(113)<="0000000011111010";tmp_rom(114)<="0000111111110111";tmp_rom(115)<="1111111110101110";tmp_rom(116)<="1111111110101111";tmp_rom(117)<="1111111110110000";tmp_rom(118)<="1111111110110001";tmp_rom(119)<="1111111110110010";tmp_rom(120)<="1111111110110011";tmp_rom(121)<="1111111110110100";tmp_rom(122)<="1111111110110101";tmp_rom(129)<="0000000111111000";tmp_rom(130)<="111111111000000";tmp_rom(131)<="1111111110110110";tmp_rom(132)<="1111111110110111";tmp_rom(133)<="1111111110111000";tmp_rom(134)<="1111111110111001";tmp_rom(135)<="1111111110111010";tmp_rom(136)<="1111111110111011";tmp_rom(137)<="1111111110111100";tmp_rom(138)<="1111111110111101";tmp_rom(145)<="0000000111111001";tmp_rom(146)<="1111111110111110";tmp_rom(147)<="1111111110111111";tmp_rom(148)<="1111111111000000";tmp_rom(149)<="1111111111000001";tmp_rom(150)<="1111111111000010";
B - 36
tmp_rom(151)<="1111111111000011";tmp_rom(152)<="1111111111000100";tmp_rom(153)<="1111111111000101";tmp_rom(154)<="1111111111000110";tmp_rom(161)<="0000000111111010";tmp_rom(162)<="1111111111000111";tmp_rom(163)<="1111111111001000";tmp_rom(164)<="1111111111001001";tmp_rom(165)<="1111111111001010";tmp_rom(166)<="1111111111001011";tmp_rom(167)<="1111111111001100";tmp_rom(168)<="1111111111001101";tmp_rom(169)<="1111111111001110";tmp_rom(170)<="1111111111001111";tmp_rom(177)<="0000001111111001";tmp_rom(178)<="1111111111010000";tmp_rom(179)<="1111111111010001";tmp_rom(180)<="1111111111010010";tmp_rom(181)<="1111111111010011";tmp_rom(182)<="1111111111010100";tmp_rom(183)<="1111111111010101";tmp_rom(184)<="1111111111010110";tmp_rom(185)<="1111111111010111";tmp_rom(186)<="1111111111011000";tmp_rom(193)<="0000001111111010";tmp_rom(194)<="1111111111011001";tmp_rom(195)<="1111111111011010";tmp_rom(196)<="1111111111011011";tmp_rom(197)<="1111111111011100";tmp_rom(198)<="1111111111011101";tmp_rom(199)<="1111111111011110";tmp_rom(200)<="1111111111011111";tmp_rom(201)<="1111111111100000";tmp_rom(202)<="1111111111100001";tmp_rom(209)<="0000011111111000";tmp_rom(210)<="1111111111100010";tmp_rom(211)<="1111111111100011";tmp_rom(212)<="1111111111100100";tmp_rom(213)<="1111111111100101";tmp_rom(214)<="1111111111100110";tmp_rom(215)<="1111111111100111";tmp_rom(216)<="1111111111101000";tmp_rom(217)<="1111111111101001";tmp_rom(218)<="1111111111101010";tmp_rom(225)<="1111111111101011";tmp_rom(226)<="1111111111101100";tmp_rom(227)<="1111111111101101";tmp_rom(228)<="1111111111101110";tmp_rom(229)<="1111111111101111";tmp_rom(230)<="1111111111110000";tmp_rom(231)<="1111111111110001";tmp_rom(232)<="1111111111110010";tmp_rom(233)<="1111111111110011";tmp_rom(234)<="1111111111110100";tmp_rom(241)<="1111111111110101";tmp_rom(242)<="1111111111110110";tmp_rom(243)<="1111111111110111";
B - 37
tmp_rom(244)<="1111111111111000";tmp_rom(245)<="1111111111111001";tmp_rom(246)<="1111111111111010";tmp_rom(247)<="1111111111111011";tmp_rom(248)<="1111111111111100";tmp_rom(249)<="1111111111111101";tmp_rom(250)<="1111111111111110";tmp_rom(240)<="0000011111111001";
dout <= tmp_rom(conv_integer(address));
end behav;
source code ROM untuk tabel panjang kode huffman (lenrom.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;
entity lenROM is generic( width: integer:=4; -- lebar bit tiap alamat
depth: integer:=256; -- ada berapa byte alamat addr: integer:=8); -- lebar bus alamat
port( --din: in std_logic_vector(width-1 downto 0); dout: out std_logic_vector(width-1 downto 0); address: in std_logic_vector(addr-1 downto 0) --rd: in std_logic ); end lenROM;
architecture behav of lenROM is
-- use array to define the bunch of internal temparary signals
type ROMtipe is array (0 to depth-1) of std_logic_vector(width-1 downto 0);
signal tmp_rom: ROMtipe;
begin
tmp_rom(0)<="0011";tmp_rom(1)<="0001";tmp_rom(2)<="0001";tmp_rom(3)<="0010";tmp_rom(4)<="0011";tmp_rom(5)<="0100";tmp_rom(6)<="0110";tmp_rom(7)<="0111";tmp_rom(8)<="1001";tmp_rom(9)<="1111";tmp_rom(10)<="1111";tmp_rom(17)<="0011";tmp_rom(18)<="0100";
B - 38
tmp_rom(19)<="0110";tmp_rom(20)<="1000";tmp_rom(21)<="1010";tmp_rom(22)<="1111";tmp_rom(23)<="1111";tmp_rom(24)<="1111";tmp_rom(25)<="1111";tmp_rom(26)<="1111";tmp_rom(33)<="0100";tmp_rom(34)<="0111";tmp_rom(35)<="1001";tmp_rom(36)<="1011";tmp_rom(37)<="1111";tmp_rom(38)<="1111";tmp_rom(39)<="1111";tmp_rom(40)<="1111";tmp_rom(41)<="1111";tmp_rom(42)<="1111";tmp_rom(49)<="0101";tmp_rom(50)<="1000";tmp_rom(51)<="1011";tmp_rom(52)<="1111";tmp_rom(53)<="1111";tmp_rom(54)<="1111";tmp_rom(55)<="1111";tmp_rom(56)<="1111";tmp_rom(57)<="1111";tmp_rom(58)<="1111";tmp_rom(65)<="0101";tmp_rom(66)<="1001";tmp_rom(67)<="1111";tmp_rom(68)<="1111";tmp_rom(69)<="1111";tmp_rom(70)<="1111";tmp_rom(71)<="1111";tmp_rom(72)<="1111";tmp_rom(73)<="1111";tmp_rom(74)<="1111";tmp_rom(81)<="0110";tmp_rom(82)<="1010";tmp_rom(83)<="1111";tmp_rom(84)<="1111";tmp_rom(85)<="1111";tmp_rom(86)<="1111";tmp_rom(87)<="1111";tmp_rom(88)<="1111";tmp_rom(89)<="1111";tmp_rom(90)<="1111";tmp_rom(97)<="0110";tmp_rom(98)<="1011";tmp_rom(99)<="1111";tmp_rom(100)<="1111";tmp_rom(101)<="1111";tmp_rom(102)<="1111";tmp_rom(103)<="1111";tmp_rom(104)<="1111";tmp_rom(105)<="1111";
B - 39
tmp_rom(106)<="1111";tmp_rom(113)<="0111";tmp_rom(114)<="1011";tmp_rom(115)<="1111";tmp_rom(116)<="1111";tmp_rom(117)<="1111";tmp_rom(118)<="1111";tmp_rom(119)<="1111";tmp_rom(120)<="1111";tmp_rom(121)<="1111";tmp_rom(122)<="1111";tmp_rom(129)<="1000";tmp_rom(130)<="1110";tmp_rom(131)<="1111";tmp_rom(132)<="1111";tmp_rom(133)<="1111";tmp_rom(134)<="1111";tmp_rom(135)<="1111";tmp_rom(136)<="1111";tmp_rom(137)<="1111";tmp_rom(138)<="1111";tmp_rom(145)<="1000";tmp_rom(146)<="1111";tmp_rom(147)<="1111";tmp_rom(148)<="1111";tmp_rom(149)<="1111";tmp_rom(150)<="1111";tmp_rom(151)<="1111";tmp_rom(152)<="1111";tmp_rom(153)<="1111";tmp_rom(154)<="1111";tmp_rom(161)<="1000";tmp_rom(162)<="1111";tmp_rom(163)<="1111";tmp_rom(164)<="1111";tmp_rom(165)<="1111";tmp_rom(166)<="1111";tmp_rom(167)<="1111";tmp_rom(168)<="1111";tmp_rom(169)<="1111";tmp_rom(170)<="1111";tmp_rom(177)<="1001";tmp_rom(178)<="1111";tmp_rom(179)<="1111";tmp_rom(180)<="1111";tmp_rom(181)<="1111";tmp_rom(182)<="1111";tmp_rom(183)<="1111";tmp_rom(184)<="1111";tmp_rom(185)<="1111";tmp_rom(186)<="1111";tmp_rom(193)<="1001";tmp_rom(194)<="1111";tmp_rom(195)<="1111";tmp_rom(196)<="1111";tmp_rom(197)<="1111";tmp_rom(198)<="1111";
B - 40
tmp_rom(199)<="1111";tmp_rom(200)<="1111";tmp_rom(201)<="1111";tmp_rom(202)<="1111";tmp_rom(209)<="1010";tmp_rom(210)<="1111";tmp_rom(211)<="1111";tmp_rom(212)<="1111";tmp_rom(213)<="1111";tmp_rom(214)<="1111";tmp_rom(215)<="1111";tmp_rom(216)<="1111";tmp_rom(217)<="1111";tmp_rom(218)<="1111";tmp_rom(225)<="1111";tmp_rom(226)<="1111";tmp_rom(227)<="1111";tmp_rom(228)<="1111";tmp_rom(229)<="1111";tmp_rom(230)<="1111";tmp_rom(231)<="1111";tmp_rom(232)<="1111";tmp_rom(233)<="1111";tmp_rom(234)<="1111";tmp_rom(241)<="1111";tmp_rom(242)<="1111";tmp_rom(243)<="1111";tmp_rom(244)<="1111";tmp_rom(245)<="1111";tmp_rom(246)<="1111";tmp_rom(247)<="1111";tmp_rom(248)<="1111";tmp_rom(249)<="1111";tmp_rom(250)<="1111";tmp_rom(240)<="1010";
dout <= tmp_rom(conv_integer(address));
end behav;
source code penyandi DC (dc_coder.vhd)
library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all; use ieee.std_logic_signed.all; use std.textio.all;
entity huff_dc isport(
dc_cat: in std_logic_vector(3 downto 0);dc_code: out std_logic_vector(15 downto 0);len: out std_logic_vector(3 downto 0)); end huff_dc;
architecture behav of huff_dc is
B - 41
beginprocess(dc_cat) beginif(dc_cat="0000") then
dc_code<="0000000000000000";len<="0001";
elsif(dc_cat="0001") thendc_code<="0000000000000010";len<="0010";
elsif(dc_cat="0010") thendc_code<="0000000000000011";len<="0010";
elsif(dc_cat="0011") thendc_code<="0000000000000100";len<="0010";
elsif(dc_cat="0100") thendc_code<="0000000000000101";len<="0010";
elsif(dc_cat="0101") thendc_code<="0000000000000110";len<="0010";
elsif(dc_cat="0110") thendc_code<="0000000000001110";len<="0011";
elsif(dc_cat="0111") thendc_code<="0000000000011110";len<="0100";
elsif(dc_cat="1000") thendc_code<="0000000000111110";len<="0101";
elsif(dc_cat="1001") thendc_code<="0000000001111110";len<="0110";
elsif(dc_cat="1010") thendc_code<="0000000011111110";len<="0111";
elsif(dc_cat="1011") thendc_code<="0000000111111110";len<="1000";
elsif(dc_cat="1100") thendc_code<="0000001111111110";len<="1001";
elsif(dc_cat="1101") thendc_code<="0000011111111110";len<="1010";
elsif(dc_cat="1110") thendc_code<="0000111111111110";len<="1011";
elsif(dc_cat="1111") thendc_code<="0001111111111110";len<="1100";
end if;end process;
end behav;
source code multiplekser kode antara DC dan AC (codemux.vhd)
B - 42
library IEEE; use IEEE.std_logic_1164.all; use IEEE.std_logic_arith.all; use ieee.std_logic_signed.all; use std.textio.all;
entity codemux isport(
alen: in std_logic_vector(3 downto 0);blen: in std_logic_vector(3 downto 0);ahuff: in std_logic_vector(15 downto 0);bhuff: in std_logic_vector(15 downto 0);sel: in std_logic;len: out std_logic_vector(3 downto 0);huff: out std_logic_vector(15 downto 0));end codemux;
architecture behav of codemux issignal temp_huff: std_logic_vector(15 downto 0);signal temp_len: std_logic_vector(3 downto 0);signal temp_huff_not: std_logic_vector(15 downto 0);signal temp_len_not: std_logic_vector(3 downto 0);
begintemp_huff<=sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel&sel;temp_len<=sel&sel&sel&sel;temp_huff_not<=not(temp_huff);temp_len_not<=not(temp_len);len<=(alen and temp_len_not) or (blen and temp_len);huff<=(ahuff and temp_huff_not) or (bhuff and temp_huff);
end behav;
source code byte stuffer , konverter kode entropi paralel ke serial (p2s.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; use ieee.numeric_std.all;
entity p2s isport(
clk: in std_logic;clr: in std_logic;en: in std_logic;addr_tls:in std_logic_vector(7 downto 0);addr: out std_logic_vector(7 downto 0);len:in std_logic_vector(3 downto 0);huff: in std_logic_vector(15 downto 0);cat:in std_logic_vector(3 downto 0);sym: in std_logic_vector(15 downto 0);rdy: out std_logic;ser: out std_logic);
end p2s;architecture behav of p2s issignal tmpser: std_logic;signal cnt,tmplen,tmpcat: std_logic_vector(3 downto 0);
B - 43
signal tmphuff,tmpsym: std_logic_vector(15 downto 0);signal addrtmp,addr_tls_tmp: std_logic_vector(7 downto 0);signal state: std_logic_vector(3 downto 0);signal tanda_tls,rdy1: std_logic;signal tanda_bc,first:std_logic;begin
ser<=tmpser;addr<=addrtmp;process(clk,clr) beginif(clr='1') then
tanda_bc<='0';tanda_tls<='0';tmpser<='0';cnt<=(others=>'0');tmpcat<=(others=>'0');
-- data<=(others=>'0');tmpsym<=(others=>'0');state<=(others=>'0');addrtmp<=(others=>'0');addr_tls_tmp<=(others=>'0');rdy1<='0';first<='0';rdy<='0';
elsif(rising_edge(clk)) thenif(first='1') then
rdy<=rdy1;end if;if(en='1') thenaddr_tls_tmp<=addr_tls;if(addr_tls_tmp="11111111" and addr_tls="00000000" ) then
tanda_tls<=not tanda_tls;end if;
case state iswhen "0000" => --akuisisi data
if(first='0')thenrdy1<='1';rdy<='1';
end if;tmplen<=len;tmphuff<=huff;if(cat="0000") then
tmpcat<=cat;else
tmpcat<=cat-1;end if;tmpsym<=sym;state<="0001";tmpser<=huff(conv_integer(len));cnt<=len-1;first<='1';
when "0001" => --keluarkan data hufftmpser<=tmphuff(conv_integer(cnt));if(cnt="0000") then
if(tmphuff="0000000000001010" or tmphuff="0000011111111001") then
state<="0000";
B - 44
if(addrtmp="11111111") thentanda_bc<=not tanda_bc;
end if;if((addrtmp>=(addr_tls-1) and (tanda_bc =
tanda_tls)) or (addrtmp="11111111" and addr_tls="00000000")) thenrdy1<='0';
elserdy1<='1';addrtmp<=addrtmp+1;
end if;else
state<="0010";cnt<=tmpcat;
end if;else
cnt<=cnt-1;end if;
when "0010" =>tmpser<=tmpsym(conv_integer(cnt));if(cnt="0000") then
state<="0000";--cnt<="0000";
if(addrtmp="11111111") thentanda_bc<=not tanda_bc;
end if;if((addrtmp>=(addr_tls-1) and (tanda_bc =
tanda_tls)) or (addrtmp="11111111" and addr_tls="00000000")) thenrdy1<='0';
elserdy1<='1';addrtmp<=addrtmp+1;
end if;else
cnt<=cnt-1;end if;
when others =>state<="0000";
end case;else
tmpser<=not(tmpser);rdy1<='0';
end if; end if;end process;
end behav;
Source code pengendali DCT-2D (controller.vhd)
library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_signed.all; use ieee.numeric_std.all;
B - 45
entity controller is port(
clk: in std_logic; rst: in std_logic; a_in: out std_logic_vector(7 downto 0); a_out: out std_logic_vector(7 downto 0); en_dct: out std_logic; en_dct2: out std_logic; we: out std_logic; ctr_en: in std_logic; dct_rdy2: in std_logic;--penanda dct2 sudah ready datanya dct_rdy: in std_logic; rom_rdy: out std_logic; --menandai apakah rom zigzag sudah bisa diakses we2: out std_logic;dc_en:out std_logic; a2in: out std_logic_vector(7 downto 0); a2out: out std_logic_vector(7 downto 0) );
end entity;
architecture behav of controller is signal en2,rom_rd: std_logic; signal a_in1,a_out1:std_logic_vector(7 downto 0); signal a_in2a,a_out2a:std_logic_vector(7 downto 0); signal cntia,cntoa:std_logic_vector(2 downto 0);signal cntib,cntob:std_logic_vector(7 downto 0);signal cnti1a,cnto1a:std_logic_vector(2 downto 0);signal cnti1b,cnto1b:std_logic_vector(7 downto 0);signal dc:std_logic;begindc_en<=dc; a_in<=a_in1; a2in<=a_in2a; a2out<=a_out2a; a_out(5 downto 3)<=a_out1(2 downto 0); a_out(2 downto 0)<=a_out1(5 downto 3); a_out(7 downto 6)<=a_out1(7 downto 6); rom_rdy<=rom_rd; dct_proc: process(clk,rst) begin if(rst='1')then
a_in1<=(others=>'1'); en_dct<='0'; en2<='0'; we<='1';cntia<=(others=>'0');cntib<=(others=>'0');cntoa<=(others=>'0');cntob<=(others=>'0');
elsif(rising_edge(clk))then en_dct<=ctr_en;
if(dct_rdy='1')then we<='1';if(cntia="111") then
cntib<=cntib+1;
B - 46
cntia<="000";else
cntia<=cntia+1;end if;
if(a_in1="00111111")then en2<='1'; a_in1<=a_in1+1;
elsif(a_in1="01111111")then a_in1<="00000000"; else
a_in1<=a_in1+1; end if;
else we<='0';if(cntib=cntob) then
en2<='0';end if;
end if;
if(en2='1') thenif(cntoa="111") then
cntob<=cntob+1;cntoa<="000";
elsecntoa<=cntoa+1;
end if;end if;
end if; end process;
dct2_proc: process(clk,rst,en2) begin if(rst='1')then
a_out1<="01111111"; en_dct2<='0';
elsif(rising_edge(clk))then if(en2='1') thenen_dct2<='1';
if(a_out1="01111111")then a_out1<="00000000"; else
a_out1<=a_out1+1; end if;
elseen_dct2<='0';
end if; end if; end process;
isi_dct2: process(clk,rst,dct_rdy2)begin --pengisian hasil dct2 ke ram2 if(rst='1')then
a_in2a<=(others=>'1'); rom_rd<='0'; we2<='1';
B - 47
dc<='0'; cnti1a<=(others=>'0');cnti1b<=(others=>'0');cnto1a<=(others=>'0');cnto1b<=(others=>'0');
elsif(rising_edge(clk)) then if(dct_rdy2='1')then
we2<='1'; if(cnti1a="111") then
cnti1b<=cnti1b+1;cnti1a<="000";
elsecnti1a<=cnti1a+1;
end if;if(a_in2a(5 downto 0)="011100")then
rom_rd<='1'; dc<='1';
a_in2a<=a_in2a+1; elsif(a_in2a="01111111")then a_in2a<="00000000";
dc<='0'; else
a_in2a<=a_in2a+1;dc<='0';
end if; else
we2<='0';if(cnti1b=cnto1b) then
rom_rd<='0';end if;
end if;if(rom_rd='1') then
if(cnto1a="111") thencnto1b<=cnto1b+1;cnto1a<="000";
elsecnto1a<=cnto1a+1;
end if;end if;
end if; end process;
zigzag: process(clk,rst,rom_rd) begin if(rst='1')then
a_out2a<=(others=>'0'); elsif(rising_edge(clk) and rom_rd='1')then
if(a_out2a="01111111")then a_out2a<="00000000"; else
a_out2a<=a_out2a+1; end if;
end if; end process; end behav;
B - 48
Lampiran C. Tabel Sandi Huffman untuk koefisien AC DCT
run,cat huffman code0,0 ( EOB) 10100,1 00,2 10,3 1000,4 10110,5 110100,6 11110000,7 111110000,8 11111101100,9 11111111100000100,10 11111111100000101,1 11001,2 110111,3 11110011,4 1111101101,5 111111101101,6 11111111100001001,7 11111111100001001,8 11111111100001101,9 11111111100001101,10 11111111100010002,1 111002,2 111110012,3 11111101112,4 1111111101002,5 11111111100010002,6 11111111100010102,7 11111111100010102,8 11111111100011002,9 11111111100011002,10 11111111100011103,1 111010
run, cat huffman code3,2 1111101113,3 1111111101013,4 11111111100011103,5 11111111100100003,6 11111111100100003,7 11111111100100103,8 11111111100100103,9 11111111100101003,10 11111111100101004,1 1110114,2 11111110004,3 11111111100101104,4 11111111100101104,5 11111111100110004,6 11111111100110004,7 11111111100110104,8 11111111100110104,9 11111111100111004,10 11111111100111005,1 11110105,2 111111101115,3 11111111100111105,4 11111111100111105,5 11111111101000005,6 11111111101000005,7 11111111101000105,8 11111111101000105,9 11111111101001005,10 11111111101001006,1 11110116,2 1111111101106,3 1111111110100110
run,cat huffman code6,4 11111111101001106,5 11111111101010006,6 11111111101010006,7 11111111101010106,8 11111111101010106,9 11111111101011006,10 11111111101011007,1 111110107,2 1111111101117,3 11111111101011107,4 11111111101011107,5 11111111101100007,6 11111111101100007,7 11111111101100107,8 11111111101100107,9 11111111101101007,10 11111111101101008,1 1111110008,2 1111111110000008,3 11111111101101108,4 11111111101101108,5 11111111101110008,6 11111111101110008,7 11111111101110108,8 11111111101110108,9 11111111101111008,10 11111111101111009,1 1111110019,2 11111111101111109,3 11111111101111109,4 11111111110000009,5 11111111110000009,6 11111111110000109,7 11111111110000109,8 11111111110001009,9 11111111110001009,10 111111111100011010,1 111111010
Kuesioner usia : 21 th pekerjaan : mahasiswa aturan main
1. ekstrak file survei.zip, akan anda dapatkan folder 'kuesioner' yang berisi folder 'resolusi240x320' dan 'resolusi480x640'. Di dalam masing-masing folder tersebut terdapat folder 'satu', 'dua', 'tiga' dan 'empat'.
2. Di dalam tiap folder 'satu', 'dua' dst terdapat 2 gambar yang hampir sama yaitu 'asli.bmp' dan 'rekonstruksi.bmp'
Pertanyaan : Untuk masing-masing folder 'resolusi....' , bandingkan gambar asli dan rekonstruksi pada setiap folder 'satu', 'dua', kemudian berilah tanda (tanda v atau x) pada tabel di bawah ini dengan kriteria sebagai berikut: excellent, jika menurut anda gambar asli sama persis dengan gambar rekonstruksi, tidak ada blur sedikitpun good, jika menurut anda ada perbedaan sedikit sekali gambar kanan dengan gambar kiri (misalnya sedikit blur – sekitar 10 objek yang mengalami blur), fair, jika pada gambar kanan terdapat objek yang blur (sekitar > 10 objek) dan sedikit distorsi (misalnya ada kotoran,artefak) tetapi tidak menggangu poor, jika pada gambar kanan terdapat distorsi yang menggangu penampilan unsatisfactory, jika gambar kanan terdapat banyak distorsi atau sudah sukar dikenali A. Resolusi 240x320 gambar excellent Good Fair Poor unsatisfactory Satu x dua x tiga x empat x B. Resolusi 480x640 gambar excellent Good Fair Poor unsatisfactory Satu x dua x tiga x empat x