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


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


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

----------------------------------


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



- -

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


A-6

4. Empat.bmpa. Citra asli

A-7

b. Hasil kompresi

rasio kompresi = 12.1% MSE (kompresi-citra asli) = 0.0082


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 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(


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(


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)


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



end component;

component memori is generic(

lebar_data:integer:=13--lebar bus data memori );


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


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)


entity dct8a is generic(m:integer:=13;--MSB pengali


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; ----------------------------------


---------------------------------- vout<=s7(p+k downto p)+ofset7;

---------------------------------- --if(rdy='1')then -- out_en<='1'; --end if;


---------------------------------- 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;


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



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; ----------------------------------


---------------------------------- d0<=c0+c3; d1<=c0-c3; d2<=c2; d3<=c1+c4; d4<=c2-c5; d5<=c4; d6<=c5; d7<=c6; d8<=c7;

B - 20


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; ----------------------------------



---------------------------------- --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;


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;


B - 22

Source code transpose buffer dan zigzag buffer (ram.vhd)


entity memori is generic(

lebar_data:integer:=13--lebar bus data memori );--pengali dikalikan 2^12


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


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


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




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)


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)


entity fullcoder isport(


end fullcoder;architecture behav of fullcoder is

B - 28

component ac_coder isport(


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


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


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)


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;


tmp<=con3-b;else

tmp<=b;end if;


tmp<=con4-b;else

tmp<=b;end if;


tmp<=con5-b;else

tmp<=b;end if;


tmp<=con6-b;else

tmp<=b;end if;


tmp<=con7-b;else

tmp<=b;end if;


tmp<=con8-b;else

tmp<=b;end if;


B - 33

tmp<=con9-b;else

tmp<=b;end if;


tmp<=con10-b;else

tmp<=b;end if;


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;


tmp<=con13-b;else

tmp<=b;end if;


tmp<=con14-b;else

tmp<=b;end if;

end if;end process;end behav;

Source code ROM untuk tabel huffmann (huff_rom.vhd)


entity dataROM is generic( width: integer:=16; -- lebar bit tiap 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




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


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";


end behav;

source code ROM untuk tabel panjang kode huffman (lenrom.vhd)


entity lenROM is generic( width: integer:=4; -- lebar bit tiap 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




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


B - 39


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";


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";















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)


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;


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

KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN …te.ugm.ac.id/~enas/tesis260199.pdf · Rangkaian...

Documents

Transcript of KOMPRESI CITRA JPEG BERBASIS FPGA XILINX SPARTAN …te.ugm.ac.id/~enas/tesis260199.pdf · Rangkaian...