Het ontwerpen van entropie-encodering op FPGA als onderdeel van een wavelet-gebaseerde video-encoder

Transcriptie

1 Faculteit Toegepaste Wetenschappen Vakgroep Elektronica en Informatiesystemen Voorzitter: Prof. dr. ir. J. Van Campenhout Het ontwerpen van entropie-encodering op FPGA als onderdeel van een wavelet-gebaseerde video-encoder door Michiel D Haene Promotor: Prof. dr. ir. D. Stroobandt Thesisbegeleider: dr. ir. M. Christiaens Afstudeerwerk ingediend tot het behalen van de academische graad van Burgerlijk Ingenieur Computerwetenschappen, optie: Computerarchitectuur Academiejaar

2 Toelating tot bruikleen De auteur geeft de toelating dit afstudeerwerk voor consultatie beschikbaar te stellen en delen van het afstudeerwerk te kopiëren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit dit afstudeerwerk. Michiel D Haene 26 mei 2004 i

3 Dankwoord Dit afstudeerwerk zou nooit tot stand gekomen zijn zonder de hulp van vele mensen. Al deze mensen wil ik hierbij van harte bedanken. In het bijzonder denk ik hierbij aan mijn promotor Dirk Stroobandt voor het uitschrijven van deze opdracht, mijn begeleider Mark Christiaens voor zijn deskundige begeleiding en om steeds open te staan voor vragen en suggesties. Ook de andere mensen van de afdeling waaronder Harald Devos, Philippe Faes, Hendrik Eeckhaut, Benjamin Schrauwen en Wim Meeus waren onmisbaar met hun goeie raad. Verder zijn er ook de mede-waveletcollega s Peter Bertels en Inge Doms waarmee ik aangenaam heb kunnen samenwerken, en mede-thesisstudenten/entertainers Brecht Caeckaert, Pol Brouckaert, Stijn Notebaert en Jan Decock waarmee ik vele en vooral late uurtjes heb doorgebracht in onze afdeling. Tenslotte wil ik de mensen bedanken die het ook geweten hebben dat ik een thesis heb gemaakt, en hierbij steeds het nodige geduld konden opbrengen: mijn broers, zussen, ouders, lief en vriend(inn)en. ii

4 Het ontwerpen van entropie-encodering op FPGA als onderdeel van een wavelet-gebaseerde video-encoder door Michiel D Haene Afstudeerwerk ingediend tot het behalen van de graad van Burgerlijk Ingenieur Computerwetenschappen, optie: Computerarchitectuur Academiejaar Universiteit Gent Faculteit Toegepaste Wetenschappen Promotor: Prof. dr. ir. D. Stroobandt Samenvatting Waveletgebaseerde video-encoders vormen de laatste jaren hèt onderwerp van onderzoek. Deze encoders bieden naast een goede compressiefactor ook uitstekende mogelijkheden tot schaalbaarheid van de videostroom, zowel in resolutie als in kwaliteit. Dit afstudeerwerk vormt de laatste trap in zo n waveletgebaseerde video-encoder. Fout- en referentiebeelden die reeds waveletgetransformeerd werden, dienen efficiënt en verliesloos gecomprimeerd te worden, waarbij ook gefocuseerd wordt op de schaalbaarheid van de encoder en van de bitstroom. Er wordt vertrokken van een bestaande C++-implementatie van een algoritme dat bestaat uit drie trappen. In de eerste trap wordt een quadtree-opdeling van de verschillende bitlagen in het beeld uitgevoerd waardoor reeds een significante reductie van de bitstroom ontstaat. In de volgende twee trappen wordt de resterende informatie via een context-gebaseerde aritmetische encoder verder gecomprimeerd. Het is de bedoeling dit software-algoritme verder uit te werken naar een hardware-implementeerbare vorm in SystemC waarbij vooral geoptimaliseerd wordt naar snelheid en daarnaast gezorgd wordt voor een efficiënte geheugenhiërarchie. Trefwoorden: quadtree-opdeling, contextgebaseerd model, aritmetische encoder, SystemC iii

5 Inhoudsopgave 1 Inleiding Probleemstelling Doel en plaatsing van dit afstudeerwerk De hardware Inhoud Principe en werking van de entropie-encoder De quadtree-opdeling Bepalen van de startdrempel Quadtree-gebaseerde veldsignificantie-codering Boomscan algoritme Codeer-algoritme voor de veldsignificantie-codering De quadtree-limited (QT-L) coder De aritmetische encoder Resolutie-underflow preventie Adaptieve modellering Specifiek gebruikte encoder in dit afstudeerwerk Contextgebaseerde modelselectie Quadtree-opdeling Opzet van de software-code De verschillende blokken De geheugenstructuur Uitwerking van het algoritme Verbeteren van de geheugenstructuur Implementatie in SystemC Encodeervolgorde aanpassen en geheugenafspraken iv

6 3.3.2 Optimaliseren van de significantiepas en introductie van een stack De modules en interfaces Flowcontrole en geheugentoegangen Synthese, meetresultaten en verdere optimalisatie op hardware niveau Contextgebaseerde modelselectie Opzet van de software-code De verschillende blokken De geheugenstructuur Snelheidsvereisten Uitwerking van het algoritme Verbeteringen en afwegingen aan het geheugenmodel Opmerkingen Uitwerking in SystemC Aritmetische encodering Opzet van de software-code Enkele overwegingen vooraf Snelheidsvereisten Probleemanalyse Nadere studie van het algoritme Gedragsbeschrijving Geheugenmodel Testbank Decompositie en verfijning Het geheugenmodel Vereenvoudigen algoritme Parallelliseren Kritisch pad Synthetiseren Meetresultaten Mogelijke verbeteringen v

7 6 Samenvoegen van de delen Het geheel Communicatie met het DDR-SDRAM Geheugengebruik Optimalisaties Mogelijke verbeteringen aan de codec Het eiland-algoritme De opzet Werking van het algoritme Een voorbeeld Uitvloeiend eiland Pseudo-code van de basisversie van het eiland-algoritme Vergelijking met het Quadtree-algoritme Codeer-efficiëntie Geheugenvereisten Snelheid Samenvattende vergelijking Verdere mogelijkheden en optimalisaties Besluit 77 A Het PCI Altera Stratix bord 79 A.1 Het bord A.2 De Quartus II ontwikkelingssoftware A.3 Het Stratix modulair top design B Verband compressie, resolutie- en waveletniveaus 83 C Resultaten quadtree-opdeling 86 D Meting van vereisten voor modelselectie 90 Bibliografie 93 vi

8 Lijst van figuren 1.1 Voorbeeld van schaalbaarheid in kwaliteit en in resolutie Wavelettransformatie van Lena op respectievelijk (a) 1 niveau, en (b) 3 niveaus Grafische interpretatie van een lagenvoorstelling in Lena Algemene opzet van de video-encoder Quadtree-opdeling met nulcriterium Deel van de bijhorende boom uit vorige figuur Schematische voorstelling van een drie niveaus wavelettransformatie Werking van een aritmetische encoder Schematische opzet van de volledige encoder Velden in een waveletgetransformeerd beeld Compressieresultaten van Lena pixels, 8 bit per pixel De verschillende mogelijkheden in een quadtree-deelboom Eenvoudig voorbeeld van de lijstenstructuur in de software-code Locatie in geheugen van een beeld (a) origineel (b) na aanpassing Voorbeeld van een geoptimaliseerde controle binnen een kwadrant Interne opzet van de quadtree-opdeling Detail afschakelen van het leveren en/of opnemen van symbolen Detail einde van de stream, automatische interne reset Bijwerken van een interval bij (a) selectie van een 0, of (b) selectie van een De verschillende stappen en hun volgorde in de eerste gedragsbeschrijving Signaalverloop in de eerste gedragsbeschrijving Geoptimaliseerde en gepijplijnde uitvoering van de aritmetische encoder Signaalverloop in de geparallelliseerde aritmetische encoder Laden van nieuwe modellen tijdens het encodeerproces Lange uitvoerprocedure na opeenvolgende underflow-protecties vii

9 6.1 Combinatie van de verschillende delen Voorspelling van niet-significante pixels in het quadtree-algoritme Voorspelling van niet-significante pixels in het eiland-algoritme Eerste pas van het eiland-algoritme Tweede pas van het eiland-algoritme Vervolg tweede pas van het eiland-algoritme Uitvloeien van een eiland Vervolg uitvloeien van een eiland Slechts denkbare scenario voor het basis-eiland-algoritme Totaal schema van de eiland-encoder Enkele nuttige eilandvormen bij het coderen van waveletbeelden Voorbeeld gebruik van relatieve coördinaten t.o.v. een bestaand eiland A.1 Het Altera Stratix PCI bord, gebruikt in dit afstudeerwerk B.1 Bits per pixel voor QCIF-beelden en voor CIF-beelden (laatste 3 waarden) C.1 Kloktikken gebruikt door geoptimaliseerde quadtree viii

10 Lijst van tabellen 1.1 Referentiemetingen encodeersnelheid op een PentiumIV 2,4 GHz Underflow preventie Haalbare beeldsnelheid van de eerste synthetiseerbare quadtree Aanpassingen doorgevoerd aan de hand van synthese-informatie Haalbare frame-snelheid van de geoptimaliseerde quadtree Mogelijke toestandsovergangen van StatH en SignH Synthese-informatie van de aritmetische encoder Geheugenvereisten van het quadtree-algoritme Voorbeeld mogelijke opcode-structuur Geheugenvereisten van het eiland-algoritme B.1 Resultaten van enkele testen op het eerste GOP van de Foreman-filmsequentie.. 85 C.1 Kloktikken gebruikt door eerste synthetiseerbare quadtree C.2 Kloktikken gebruikt door geoptimaliseerde quadtree D.1 Metingen van vereisten in contextgebaseerde modelselectie ix

11 Lijst van gebruikte afkortingen CIF DCT DDR DSP FIFO FPGA GOP JTAG LE PCI RAM ROM SNR SQP QCIF QT QT-L VHDL VHSIC ZBT Common Intermediate Format, pixels Discrete Cosine Transform Double Data Rate Digital Signal Processor First In First Out Field Programable Gate Array Group Of Pictures Joint Test Activation Group, boundary scan standaard Logical Element, basisblok in FPGA Peripheral Component Interconnect Random Access Memory Read Only Memory Signal Noise Ratio SQuare Partitioning Quarter CIF, pixels Quadtree Quadtree-Limited VHSIC Hardware Description Language Very High Speed Integrated Circuits Zero Bus Turn around x

12 Hoofdstuk 1 Inleiding Talloze algoritmes voor beeldcompressie werden in het verleden reeds ontwikkeld waarbij de compressiecapaciteiten steeds beter werden. De laatste jaren is er echter een nieuwe trend ontstaan naar schaalbare verliesloze videocompressie-algoritmes. De klassieke op DCT gebaseerde technieken geven weliswaar goede compressieresultaten maar zijn moeilijk bruikbaar voor verliesloze compressie gekoppeld aan kwaliteits- en resolutieschaalbaarheid (zie figuur 1.1). Bovendien neemt de kwaliteit sterk af bij lage bitrates, mede het gevolg van de blok-artefacten die dan optreden, veroorzaakt door de in essentie blokgebaseerde werking van deze algoritmes. Vandaar dat werd gezocht naar videocompressie-algoritmes die gelijkaardige compressiefactoren geven bij verliesloze compressie, maar waarbij schaalbaarheid reeds van bij het begin in de bitstroom van de verliesloze codering zit ingebakken, en die ook bij de laagste resolutieniveaus een aanvaardbare kwaliteit opleveren. De decoder kan hierbij zelf de gemiddelde bitsnelheid van de videostroom bepalen. Daarnaast wordt het mogelijk beelden progressief te versturen over datakanalen, waarbij men eerst een ruwe versie van de beelden zal doorsturen, waarna de beelden stapsgewijze kunnen worden verfijnd zonder dat hier extra informatieredundantie voor nodig is. Van belang is dat de beelden indien gewenst verliesloos kunnen gereconstrueerd worden aan de ontvangerszijde, zodat belangrijke details niet verloren gaan. Het gebruik van waveletgetransformeerde beelden gekoppeld met quadtree-opdeling in het waveletdomein is een antwoord op deze trend. Wavelettransformatie is een transformatietechniek waarbij een beeld wordt opgedeeld in een aantal frequentiebanden: de lage frequentieband bevat het originele beeld, maar aan een kwart van de oorspronkelijke resolutie, terwijl de 3 hogere frequentiebanden de verschil-informatie bevatten waarmee het oorspronkelijke beeld kan worden gereconstrueerd via een inverse wavelettransformatie. Schaalbaarheid op resolutieniveau is nu mogelijk door het weglaten van de hogere frequentiebanden waardoor men een beeld verkrijgt aan een kwart van de originele resolutie (zie figuur 1.2a). Praktisch wordt de wavelettransformatie enkele malen herhaald op de lage frequentieband waardoor het originele beeld steeds verder wordt opgedeeld (figuur 1.2b). Hierdoor kan de horizontale en verticale resolutie worden ingesteld volgens machten van 2. Het resulterende beeld wordt toegevoerd aan de quadtree-encoder. Deze analyseert en codeert de waveletcoëfficiënten bitlaag per bitlaag, beginnende bij de meestbeduidende bitlaag. Een bit- 1

13 1.1. PROBLEEMSTELLING 2 Figuur 1.1: Voorbeeld van schaalbaarheid in kwaliteit en in resolutie laag kan men zich het beste voorstellen door een beeld in 3 dimensies te bekijken, waarbij de hoogte correspondeert met de grootte van elke coëfficiënt. In figuur 1.3 is een lagenvoorstelling van Lena te vinden. De getoonde lijnen stellen hierbij de bitvlakken voor. Als gevolg van deze gelaagde beschouwing, ontstaat een beeld dat zich verfijnt naarmate men verder afdaalt naar de minder-beduidende bits. De bitstroom die uit de quadtree komt begint dus met informatie over de meestbeduidende bits, en eindigt met de minstbeduidende bits. Schaalbaarheid op kwaliteitsniveau in de decoder is nu eenvoudig mogelijk door de aangeboden bitstroom op het gewenste moment af te breken, waardoor de minderbeduidende bits verloren gaan. Doch gezien de belangrijkste informatie reeds verstuurd is, verkrijgt men steeds een beeld met een goede signaal-ruisfactor gegeven de beperkte bitstroom. 1.1 Probleemstelling Algoritmes die gebaseerd zijn op dit principe, werden reeds ontwikkeld en getest in software. Het probleem bij deze algoritmes echter is de hoge rekencomplexiteit. Hierdoor ligt de verwerkingssnelheid veel te laag bij de huidige generatie computers (kloksnelheden van meer dan 2 GHz) om een verwerking in ware tijd van beelden met een behoorlijke resolutie mogelijk te maken. Het encoderen van QCIF-beelden ( pixels) is reeds geen haalbare kaart. Een test van een bestaand algoritme op een moderne PentiumIV 2,4 GHz computer leverde een encodeersnelheid op van ongeveer 11,1 beelden per seconde. Mits optimalisatie van het algoritme naar de desbetreffende architectuur kunnen de prestaties wel nog wat opgetrokken worden, doch een aanvaardbare snelheid van 30 frames per seconde blijft praktisch moeilijk realiseerbaar met de huidige computertechnologie.

14 1.2. DOEL EN PLAATSING VAN DIT AFSTUDEERWERK 3 Figuur 1.2: Wavelettransformatie van Lena op respectievelijk (a) 1 niveau, en (b) 3 niveaus QCIF CIF Frames/sec 11,1 2,7 Tabel 1.1: Referentiemetingen encodeersnelheid op een PentiumIV 2,4 GHz Tevens dient hierbij opgemerkt te worden dat praktisch alle video-algoritmes tegenwoordig gebruik maken van een bewegingsschatter zoals beschreven in [6]. Metingen tonen aan dat die meer dan 80% van de benodigde rekentijd voor zijn rekening neemt. Hierdoor zal de snelheid van de volledige video-encoder minstens een factor 5 lager liggen. 1.2 Doel en plaatsing van dit afstudeerwerk In dit afstudeerwerk wordt de versnelling onderzocht die we kunnen verkrijgen door een bestaand software-algoritme naar een hardware-implementatie om te zetten. Het algoritme is grofweg in 3 delen op te splitsen: de bewegingsschatting, de wavelettransformatie en de entropieencodering. In figuur 1.4 wordt dit schematisch voorgesteld. Dit afstudeerwerk handelt enkel over de entropie-encodering. De twee andere delen worden gelijktijdig uitgewerkt door twee andere thesisstudenten in [6] en [7]. De uiteindelijke bedoeling is dat deze drie delen samen kunnen werken als één geheel, waardoor onderling ook enkele afspraken gemaakt dienen te worden omtrent de interne datavoorstelling en dergelijke. We bekijken bij het uitwerken tevens de mogelijkheden voor een encodering in ware tijd van QCIF- en CIF-beelden en wat de eventuele knelpunten hierbij zijn. Het aantal beelden per seconde die gemeten werden op een moderne PentiumIV 2,4 GHz (enkel de entropie-encodering) worden als referentie gebruikt voor de versnelling die we bereiken in hardware (zie tabel 1.1).

15 1.3. DE HARDWARE 4 Figuur 1.3: Grafische interpretatie van een lagenvoorstelling in Lena Voor de hardware-beschrijving maken we gebruik van SystemC, een alternatief voor VHDL. Deze biedt gezien de complexiteit van het algoritme en de broncode die in C++ staat enkele voordelen t.o.v. VHDL. Code kan stap per stap worden vertaald naar efficiënte hardware-algoritmes, terwijl de combinatie van C++-code en SystemC-code kan worden gecompileerd en uitgevoerd. In een laatste fase wordt de SystemC-code automatisch vertaald via het programma DC_SHELL naar VHDL-code. 1.3 De hardware De hardware zal gerealiseerd worden op een FPGA van Altera uit de Stratix familie. De voordelen van het gebruik van FPGA s bij ontwikkelen van dergelijke algoritmes zijn voor de hand liggend. Als eerste kan de codec onmiddellijk in hardware getest worden. Verder is de code die we gebruiken nog experimenteel van aard, zodat het niet uitgesloten is en zelfs waarschijnlijk is dat er nog wijzigingen in de code zullen worden doorgevoerd, die dankzij de herprogrammeerbaarheid van de FPGA zonder problemen kunnen worden uitgevoerd in dezelfde hardware. We maken specifiek gebruik van een Stratix EP1S25 [3]. Deze heeft reeds een behoorlijke hoeveelheid snelle RAM-blokjes aan boord (voor een totaal van bijna 2 Mbit), en beschikt bovendien over 80 ingebouwde 9 9-bits vermenigvuldigers die kunnen samengevoegd worden tot en bits vermenigvuldigers. Deze kunnen volgens de karakteristieken opgeven door Altera aan 200 MHz worden geklokt. De vermelde eigenschappen komen goed van pas in deze encoder, daar de entropie-encodering een geheugen-intensieve bewerking is waar snelle vermenigvuldigers van groot belang zijn voor de globale snelheid van het algoritme. De FPGA is ingebouwd in een PCI-kaart die nog enkele extra capaciteiten toevoegt. Meer informatie over deze PCI kaart is te vinden in [5]. In bijlage A is een schema van de kaart te vinden met de belangrijkste gegevens omtrent het gebruik van deze kaart en de bijhorende software. Voor ons is vooral de PCI-interface en het DDR-SDRAM voor een totaal van 256 MiB van belang. De PCI-interface wordt gebruikt voor de datacommunicatie met de PC. Met behulp van het DDR-

16 1.4. INHOUD 5 Videobeelden Fout- en referentiebeelden Bewegingsvectoren Bewegingsschatting Wavelettransformatie Entropieencoder Gecomprimeerde videostroom Figuur 1.4: Algemene opzet van de video-encoder SDRAM wordt het mogelijk enkele RAM-blokjes als buffer te gebruiken en het DDR-SDRAM als hoofdgeheugen zodat grote hoeveelheden data die sequentieel worden uitgelezen efficiënt kunnen worden bijgehouden terwijl de snelheid toch maximaal blijft. 1.4 Inhoud In wat volgt geven we in hoofdstuk 2 eerst een korte beschrijving van het gebruikte algoritme. Hierbij belichten we de principes en technieken waar de encoder op gebaseerd is. Verder wordt een algemeen beeld gegeven van de aanpak die we volgen bij de uitwerking van deze encoder. In hoofdstukken 3, 4 en 5 worden de drie grote delen van de encoder in detail besproken. Hierbij wordt eerst de opzet van de originele C++-code uitgelegd. Voor de verdere uitwerking analyseren we eerst de vereisten, waarbij we een overzicht van de mogelijkheden geven. Aan de hand hiervan worden de verantwoorde keuzes voorgesteld die in dit afstudeerwerk werden gevolgd. We geven dan kort een beschrijving van de praktische uitwerking van de code. Tenslotte worden de simulatieresultaten voorgesteld van de SystemC-code. In hoofdstuk 6 bespreken we de problematiek rond het samenkoppelen van de diverse modules, en worden enkele verdere mogelijkheden en denkrichtingen voor deze encoder gegeven. Als afsluiter van dit afstudeerwerk wordt in hoofdstuk 7 nog het eiland-algoritme voorgesteld, een alternatief algoritme dat werd uitgedacht om komaf te maken met de nadelen en knelpunten die het quadtree-algoritme met zich meebrengt. Hierbij blijven de positieve punten behouden, of worden ze zelfs nog versterkt. Omdat het onmogelijk is alle technische afwegingen en implementatiedetails in dit boek te beschrijven, wordt de lezer uitgenodigd om ook de code zelf eens nader te bekijken die op de bijgeleverde CD werd geplaatst. Hoewel hardware-code niet altijd eenvoudig te begrijpen is, kan de opzet en de commentaar in de code hierbij helpen een beter beeld te krijgen van de problematiek.

17 Hoofdstuk 2 Principe en werking van de entropie-encoder De meeste videocompressie-algoritmes bestaan uit twee delen: een verliesgevende of verliesloze encoder die de ruimtelijke en temporele redundanties wegwerkt, en een verliesloze entropieencoder die statistische redundanties reduceert. Ook in quadtree-gebaseerde codec waarmee we in deze thesis werken, wordt van beide technieken gebruik gemaakt. De bewegingsschatting zorgt hierbij voor een reductie van de temporele redundanties tussen de verschillende beelden. Hierna volgt een wavelettransformatie van de foutbeelden, waarna de entropie-encoder de beelden verder reduceert. Dit is tevens te zien in figuur 1.4. De entropie-encoder zelf is ook nog eens op te splitsen in drie delen: de quadtree, de contextgebaseerde modelselectie en de aritmetische encoder. De quadtree reduceert in de eerste plaats de ruimtelijke en temporele redundanties van het waveletgetransformeerde beeld binnen het beeldfragment. De resterende informatie wordt daarna doorgestuurd naar de volgende delen die de statistische redundanties trachten te verwijderen. In de volgende paragrafen lichten we de theoretische werking van de verschillende blokken van deze encoder nader toe. 2.1 De quadtree-opdeling Het basisprincipe van een quadtree-opdeling is eenvoudig. Men vertrekt van een volledig beeld. Naargelang al dan niet aan een bepaald criterium is voldaan, wordt het beeld opgesplitst in vier kwadranten. In elk kwadrant wordt het criterium opnieuw gecontroleerd en indien voldaan opnieuw opgesplitst, enz. Op deze manier ontstaat dus een boom waarbij elke knoop ofwel eindknoop is, ofwel 4 kinderen heeft. In figuur 2.1 is een eenvoudig voorbeeld te zien waarbij het nulcriterium wordt toegepast, m.a.w. opsplitsing gebeurt wanneer er elementen verschillend van nul aanwezig zijn. Deze techniek wordt vaak toegepast binnen bitlagen die hoofdzakelijk nullen bevatten. Een deel van de bijhorende boom is te vinden in figuur

18 2.1. DE QUADTREE-OPDELING Figuur 2.1: Quadtree-opdeling met nulcriterium Het idee om quadtree-opdeling toe te passen op beelden is niet nieuw. Klassieke algoritmes voor quadtree-opdeling in het spatiale domein werden reeds vroeger voorgesteld. Het voordeel van deze techniek, is de eenvoud gecombineerd met de goede compressieresultaten. In contrast met deze klassieke algoritmes wordt hier echter quadtree-decompositie in het waveletdomein toegepast. Hierbij wordt meer specifiek gebruik wordt gemaakt van een vorm van veldsignificantie-codering. We leggen eerst de werking van dit principe uit, waarbij we zullen zien waarom de gebruikte techniek in reële beelden efficiënt werkt. In paragraaf wordt dit principe verder verfijnd waarbij we komen tot het algoritme dat gebruikt wordt in dit afstudeerwerk Bepalen van de startdrempel Vooraleer de eigenlijke codering start, wordt eerst de grootste absolute waarde van alle waveletcoëfficiënten bepaald die voorkomen in het beschouwde beeld. Hiervan wordt de drempel bepaald als zijnde de waarde van de meestbeduidende van nul verschillende bit van deze coëfficiënt: bijvoorbeeld waarde 147 heeft binair de waarde De drempelwaarde hiervan is dan of 128 decimaal. Deze drempelwaarde wordt mee in de bitstroom verstuurd, zodat de decoder op de hoogte is van de startdrempel. Het encoderen start vanaf deze drempel. Dit verhoogt de efficiëntie van het coderen aanzienlijk, zowel in compressie als in tijd. De vorige bitlagen bevatten enkel nullen, zodat het weinig zin heeft deze ook te gaan coderen Quadtree-gebaseerde veldsignificantie-codering Bij veldsignificantie-codering wordt startende van de startdrempel per laag gekeken welke coëfficiënten significant zijn geworden in de huidig beschouwde bitlaag. Met een significante coëfficiënt bedoelen we een coëfficiënt die een absolute waarde heeft die groter is dan de huidige drempel bepaald door de beschouwde bitlaag. Bitlaag 7 bijvoorbeeld heeft een drempelwaarde van

19 2.1. DE QUADTREE-OPDELING 8 root Quadrant-nummering: Figuur 2.2: Deel van de bijhorende boom uit vorige figuur 2 7 = 128, wat betekent dat alle coëfficiënten met een absolute waarde groter dan 128 significant zijn in deze bitlaag. We beperken onze bespreking hier tot 2-dimensionale wavelettransformaties, gezien dit ook de gebruikte dimensie is in dit algoritme. Een meer algemene uiteenzetting is te vinden in [11]. Stel W is het 2-dimensionaal waveletgetransformeerd beeld waarmee we werken, dat tot op J niveaus werd getransformeerd. De verzameling van alle significanties van elke pixel uit het beschouwde beeld bij een gegeven drempel noemen we W p, de significante map. Definieer nu een matrix C met afmetingen v v die volledig binnen een subband van de wavelettransformatie is gelegen. Voor de eenvoud nemen we aan dat v een macht van twee is, of m.a.w.: v = 2 r, r Stel w(κ x, κ y ) een waveletcoëfficiënt met coördinaten (x, y) in W. Aan matrix C associëren we nu κ 0 = (κ 0 x, κ 0 x) met: κ 0 = min(κ x, κ y ) w(κ x, κ y ) C met andere woorden, de linkerbovenhoek van matrix C. In figuur 2.3 is dit schematisch weergegeven. Stel nu: Q(κ 0 x, κ 0 x, v) = [w(κ x, κ y ] κ 0 x,y κ x,y <κ 0 x,y+v Verder beschikken we nog over de significantie-operator σ p die gegeven drempel p de pixelwaarde w(κ x, κ y ) afbeeldt op een binaire waarde w p (κ x, κ y ) W volgens:

20 2.1. DE QUADTREE-OPDELING 9 (0,0) 0 K y K y A 3 0 K x v v K x Figuur 2.3: Schematische voorstelling van een drie niveaus wavelettransformatie (J = 3) met C een matrix die v 2 waveletcoëfficienten bepaalt; Hier is v = 4 w(κ x, κ y ) Q(κ 0 x, κ 0 x, v), w p (κ x, κ y ) = σ p (w(κ x, κ y )) = Deze binaire waarden worden bijgehouden in matrix Q p : 0 w(κ x, κ y ) < 2 p 1 w(κ x, κ y ) 2 p Q p (κ 0 x, κ 0 x, v) = [w p (κ x, κ y ] κ 0 x,y κ x,y <κ 0 x,y+v Als criterium voor opdeling hanteren we nu weerom het nulcriterium zoals te zien was in figuur 2.1. We noemen P de partitieregel. Formeel wordt dit: P : Q p (κ 0 x, κ 0 x, v) = [Q p (κ 0 x + α v 2, κ0 x + β v 2, v)] als wp (κ x, κ y ) Q p (κ 0 x, κ 0 x, v)met w p (κ x, κ y ) = 1 met α, β {0, 1} Het partitioneren stopt als alle van nul verschillende waarden van Q p (κ 0 x, κ 0 x, v) gelocaliseerd zijn, m.a.w. als alle niet-nul elementen de vorm hebben van Q p (κ 0 x, κ 0 x, 1), zoals ook te zien was in figuur 2.1. Hierbij is elk niet-nul element uniek bepaald in de boomstructuur Boomscan algoritme Op ieder codeerniveau p dient de positie van de significante coëfficiënten in W p vertaald te worden in een boomstructuur van deelmatrices. Hiertoe moeten zowel de encoder als de decoder de nulkwadranten en de niet-nulkwadranten op een ondubbelzinnige manier kunnen herkennen. Hiertoe zal de encoder de benodigde informatie includeren in de 1D bitstroom die uit de quadtree komt. We definiëren hiertoe een tweetal symbolen: Een kwadrant dat enkel nullen bevat wordt geïdentificieerd met een niet-significant symbool NSG.

21 2.1. DE QUADTREE-OPDELING 10 Elk kwadrant dat minstens één niet-nul element bevat wordt geïdentificieerd met een significant symbool SGN. In de boom zal dus elke knoop die gekenmerkt wordt met een SGN-symbool verder opgesplitst worden in vier deelbomen, tenzij we niet verder kunnen opsplitsen. In figuur 2.2 van pagina 8 werden de SGN-symbolen voorgesteld door een grijs vakje, de NSG-symbolen zonder. Om er voor te zorgen dat de decoder steeds ondubbelzinnig dezelfde boom kan reconstrueren uit de 1-dimensionale bitstroom, dient een bepaalde scanprocedure in acht te worden genomen waarmee de boom wordt afgelopen. Vooraleer over te gaan tot de beschrijving van de scanprocedure dienen enkele begrippen te worden gedefinieerd. Voor ieder SGN-symbool op niveau i in de boom, met 1 < i r + 1 corresponderen 4 symbolen op niveau i 1. We noemen deze de nakomelingen van de knoop. Elke willekeurige nakomeling heeft 3 buren die dezelfde ouder delen. Het scanprincipe dat hier wordt toegepast is diepte-eerst scannen. De pseudo-code hiervoor wordt gegeven in procedure A. Een andere mogelijkheid is breedte-eerst scannen, doch experimenten in [10] hebben aangetoond dat diepte-eerst betere prestaties levert. Procedure A: Diepte eerst scannen 1. Initialisatie: Start scannen van het root-symbool van de boom op niveau i = r + 1; (a) Als het symbool NSG is, stop scannen, geen verdere symbolen op lagere niveaus; (b) Als het symbool SGN is, voeg het toe aan de significantielijst en ga naar stap 2a; 2. Recursieve module: (a) Selecteer de 4 nakomelingen in niveau i 1 corresponderend met het huidige symbool uit niveau i; (b) Scan de 4 geselecteerde symbolen in vaste volgorde i. Voor ieder symbool uit niveau i, dat niet in de significantielijst zit doe: A. Voeg het huidige symbool toe aan de significantielijst; B. Als het huidige symbool SGN is: Als i 1 (huidig niveau is niet het laagste niveau) ga naar 2a, anders ga verder; ii. Als alle vier de symbolen van niveau i toegevoegd zijn aan de significantielijst: A. Beschouw de ouder van niveau i als het huidig symbool; B. i = i + 1; C. als i = r + 2 stop scannen; anders, selecteer de verzameling symbolen die het huidige symbool bevatten samen met de corresponderende buren en ga naar stap 2b Met dit algoritme worden de elementen die een 1 bevatten gelocaliseerd door de nullen te groeperen in groepen van variabele grootte. Als de significante coëfficiënten in bepaalde gebieden van de significantiemap zijn geclusterd, kunnen grote gebieden met niet-significante coëfficienten met weinig bits worden gecodeerd, zodat het quadtree-algoritme goede prestaties zal leveren. Wanneer we echter een willekeurige verdeling van significante en niet-significante coëfficiënten in de significantiemap W p hebben, zal het algoritme door de kost om de posities van de elementen te coderen slechter presteren dan zonder de quadtree-opdeling. Praktische situaties echter tonen aan dat de niet-nulwaarden in de significantiemap geclusterd zijn rond pieken in het beeld, terwijl de nulwaarden overeenkomen met de homogene gebieden in het beeld.

22 2.1. DE QUADTREE-OPDELING Codeer-algoritme voor de veldsignificantie-codering Het globale algoritme voor veldsignificantie-codering bestaat uit twee fasen. Deze worden opeenvolgend uitgevoerd voor iedere drempelwaarde gaande van de startdrempel tot drempel 1. Elke doorloop bij een gegeven drempel noemen we in het vervolg een pas. In de eerste fase wordt voorgaand opdelingsalgoritme toegepast. Hierbij worden de symbolen die nieuw significant geworden zijn in de huidige pas, doorgegeven naar de entropie-encoder (zie later). De reeds vroeger significant geworden symbolen werden immers reeds in vorige passen geëncodeerd zodat deze niet opnieuw verstuurd hoeven te worden. In de tweede fase worden de coëfficiënten die reeds significant waren vóór deze pas, verder verfijnd in de zogenaamde verfijningspas. Hiertoe wordt een tweede lijst bijgehouden met de te verfijnen symbolen. Merk op dat in de eerste pas nog geen verfijningspas nodig is. Naast de significantielijst en de verfijningslijst wordt nog een derde lijst bijgehouden die de teken-informatie bijhoudt. Een pseudo-code van dit algoritme voor zowel de encoder als de decoder is te vinden in [11]. Het algoritme hier beschreven is de eenvoudigste vorm voor quadtreecodering met veldsignificantie en wordt vandaag de dag frequent gebruikt, waarbij vele variaties rond ditzelfde basisprincipe bestaan. We refereren naar dit algoritme als de SQP-coder. Deze naamgeving wordt om historische redenen gebruikt. We gaan nu echter over naar een meer verfijnde vorm van dit algoritme, die eveneens het uitgangspunt vormt voor de encoder van dit afstudeerwerk. Dit algoritme levert zowel betere verliesloze als verlieshebbende prestaties De quadtree-limited (QT-L) coder Het basisprincipe van de QT-L-coder blijft hetzelfde: in een eerste fase wordt de startdrempel bepaald, en er wordt gebruik gemaakt van quadtree codering met significantiemappen. Op het startniveau wordt verder eveneens enkel een significantiepas uitgevoerd. Een belangrijk verschil met de SQP-coder echter is dat de quadtree-opsplitsing in de significantiepas niet gebeurd tot op pixel-niveau. Zodra het gebied v 2 kleiner is dan een bepaalde voorgedefiniëerde drempelwaarde, wordt het opdelingsproces stopgezet. De coëfficiënten binnen de onstane gebieden worden één voor één doorgestuurd naar de entropie-encoder, en tegelijkertijd afhankelijk van hun significantie bij de huidige drempelwaarde toegevoegd aan de nietsignificantielijst of de verfijningslijst. Deze twee lijsten worden straks verklaard. Het doel van deze aanpak is enerzijds de compressie te verbeteren. We hebben gezien dat de quadtree-opdeling informatie mee stuurt die de decoder in staat stelt de boom te reconstrueren. Hoe kleiner de beschouwde blokken zijn, hoe groter het aandeel van de positie-informatie wordt, en dus hoe inefficiënter het coderingsproces verloopt. Op een bepaald moment wordt het dus voordeliger de symbolen puur statistisch te gaan coderen. Vandaar de naam Quadtree-Limited encoder. Bij deze encoder is dus een belangrijkere rol weggelegd voor de navolgende entropie-encoderingsstappen. Bij de SQP-coder kon men volstaan met een aritmetische encoder die op basis van voorgaande symbolen een kans vooropstelt waarop een 1 dan wel een 0 zal voorkomen. Dit model werkt echter niet bijster efficiënt bij de QT-L encoder en kan sterk verbeterd worden door

23 2.1. DE QUADTREE-OPDELING 12 rekening te houden met de significantie van de omliggende buren. Op basis hiervan gaat men dan een bepaald contextmodel gaan laden waarmee het symbool wordt geëncodeerd. We komen hier uitgebreider op terug bij de uitleg van de aritmetische encoder in sectie 2.2 en bij de uitleg van de contextgebaseerde modelselectie in sectie 2.3. Anderzijds leidt deze aanpak, in combinatie met de gebruikte niet-significantielijst, tot een belangrijke verbetering van de verliesgevende prestatie van de encoder, doordat de coëfficiënten binnen iedere pas volgens een bepaalde prioriteitenklasse worden doorlopen. Om dit te verklaren bepalen we eerst de volgorde waarin de significantiepas en de verfijningspas dienen te worden uitgevoerd, wanneer we ons baseren op de reductie in distorsie die ieder nieuw geëncodeerde coëfficiënt met zich meebrengt. Volgorde bepaling tussen de significantie- en de verfijningspas We vertrekken van een willekeurige coëfficiënt die geëncodeerd wordt in significantiepas S p bij gegeven drempel 2 p. De waarde van die coëfficiënt noemen we x die een randomwaarde aanneemt binnen het interval [ 2 p, 2 p+1[. De verwachte kwadratische fout bij het reconstrueren van de coëfficient, als ( ˆx = 0), is: D 0 = E [ (x ˆx) 2] = E [ x 2] = 1 2 p 2 p+1 2 p x 2 dx = p Het reconstrueren van de waarde van de coëfficiënt in het midden van het onzekerheidsinterval, namelijk ˆx = p levert de volgende distortie op: D 1 = E [ (x ˆx) 2] = E (x 32 ) 2 2p = 12 2 p+1 p 2 p ( x p ) 2 dx = p Dus het coderen van de coëfficient gedurende significantiepas S p levert een distorsie-reductie D S P op van: D S P = D 0 D 1 = p Analoog voor de verfijningspas. Hierbij gaan we uit van het feit dat de coëfficiënt reeds verfijnd werd voor alle vorige drempelwaarden tot drempel 2 p+1. De verwachte kwadratische fout is dan: D 2 = E [ (x ˆx) 2] ( = E x 3 ) 2 2 2p+1 = 1 2 p+1 ( 2 p+1 x 3 ) 2 2 p 2 22(p+1) dx = (p+1) Hieruit volgt dat de totale reductie door het verfijnen van de coëfficiënt in de verfijningspas R p wordt gegeven door: D RP = D 2 D 1 = p

24 2.1. DE QUADTREE-OPDELING 13 M.a.w. de distorsie-reductie door het vinden van een nieuwe significante coëfficient is veel groter dan het verfijnen van een coëfficiënt in de verfijningspas. Intuïtief kunnen we dit ook reeds verwachten, gezien een nieuwe significante coëfficiënt geëncodeerd wordt met twee bits (een teken en een significantiebit) terwijl in de verfijningspas elke coëfficiënt slechts één bit gebruikt. De coëfficiënten in de significantiepas moeten dus een grotere prioriteit krijgen, vandaar dat de significantiepas vóór de verfijningspas dient plaats te vinden, zodat bij onderbreking van de bitstroom tijdens het encoderen, de belangrijkste coëfficiënten gecodeerd werden. De niet-significantiepas Een verdere verbetering van de efficiëntie kan worden bereikt door de positie van de nieuwe significante coëfficiënten te gaan voorspellen. Dit kan eenvoudig gebeuren door gebruik te maken van het clusteringsprincipe waarop ook de efficiënte werking van de quadtree-opdeling is gebaseerd. Dit clusteringsprincipe leert ons dat wanneer een bepaalde waveletcoëfficiënt groot/klein is, de kans groot is dat de naburige coëfficiënten ook groot/klein zijn. Hier belanden we dan weer bij de gelimiteerde quadtree-opdeling. Wanneer de significantiepas stopt met verder opdelen bij het bereiken van de minimale blokgrootte waarin minstens één coëfficiënt significant is, worden binnen dit minimale blok alle coëfficienten afgelopen, waarbij de significante coëfficiënten zoals steeds worden toegevoegd aan de verfijningslijst. De nietsignificante coëfficiënten worden nu echter toegevoegd aan een niet-significantielijst. Tijdens de volgende pas wordt eerst en vooral de niet-significantielijst verwerkt in de niet-significantiepas, daar deze coëfficiënten een grotere kans hebben om significant te worden dan de overige. Op deze manier krijgen deze coëfficiënten de grootste prioriteit om gecodeerd te worden. Een beperking bij deze methode is wel dat naburige coëfficiënten bepaald worden volgens de opdelingsstructuur van de quadtreeboom, zodat het kan voorkomen dat een significante pixel aan de rand ligt van een minimaal blok, waardoor slechts een deel van de omgevende coëfficiënten worden toegevoegd aan de niet-significantielijst. De overige coëfficiënten die worden toegevoegd, en dus de hoogste prioriteit krijgen zijn dan reeds de verder gelegen pixels. Dit komt omdat nieuwe kanshebbende coëfficiënten steeds worden toegewezen per minimaal blok. Een verdere verfijning zou erin kunnen bestaan om een hiërarchische prioriteiten-opdeling te maken bij deze coëfficiënten, namelijk de coëfficiënten die onmiddellijk grenzen aan een significante pixel, en de overige binnen het minimale blok. Doch in deze encoder werd zover niet gegaan. Dit zal ook slechts minimale invloed hebben op de prestaties van het algoritme, daar de minimale blokgrootte over het algemeen vrij klein wordt gekozen. Een gebruikelijke waarde, die ook in deze encoder wordt gebruikt is 16, m.a.w. blokken vanaf bijvoorbeeld 4 4 of 5 3 pixels worden niet verder opgedeeld. In de praktijk worden ook veel blokken verwerkt van bijvoorbeeld 4 3, 3 2 en zelfs 2 2 pixels doordat subblokken geheel worden opgesplitst. Bijvoorbeeld een 5 5-blok wordt verder opgedeeld in een 3 3, een 3 2, een 2 3 en een 2 2-subblok. De pseudo-code voor de encoder ziet er nu als volgt uit (nadat de startdrempel werd bepaald):

25 2.2. DE ARITMETISCHE ENCODER Procedure QT-L Niet-significantiepas() Voor elke coëfficiënt c q in de niet-significantielijst, doorlopen van begin tot einde doe: Als c q 2 p : Stuur symbool SGN naar entropie-encoder Stuur teken van c q naar entropie-encoder Voeg de coördinaten van q toe aan de verfijningslijst Verwijder qu uit de niet-significantielijst Anders: Stuur symbool NSG naar de entropie-encoder 2. Procedure QT-L Significantiepas Q p (κ x, κ y, v) Als c q Q(κ x, κ y, v) < 2 p 1 Als c q Q(κ x, κ y, v) 2 p Stuur SGN symbool naar entropie-encoder Als v 2 Minimum grootte Encodeer Blok(Q(κ x, κ y, v)) Anders: Voor elk kwadrant i van Q(κ x, κ y, v) doe: QT-L Significantiepas Q p (κ i,x, κ i,y, v/2) Anders: Stuur NSG symbool naar entropie-encoder Anders: als v 2 > Minimum grootte Voor elk kwadrant i van Q(κ x, κ y, v) doe: QT-L Significantiepas Q p (κ i,x, κ i,y, v/2) 3. Procedure Encodeer Blok(Q(κ x, κ y, v)) Voor elke coëfficiënt c q in Q(κ x, κ y, v) doe: Als c q 2 p : Stuur symbool SGN naar entropie-encoder Stuur teken van c q naar entropie-encoder Voeg de coördinaten van q toe aan de verfijningslijst Anders: Stuur symbool NSG naar de entropie-encoder Voeg de coördinaten van q toe aan de niet-significantielijst 4. Procedure QT-L Verfijningspas() Voor elke coëfficiënt c q die in vroegere codeerpassen in de verfijningslijst werd geschreven doe: Stuur de bit corresponderende met de huidige bitlaag uit c q naar entropie-encoder 2.2 De aritmetische encoder Data afkomstig van verschillende informatiebronnen hebben vaak een niet-uniforme probabiliteitsdistributie. Bij verliesloze codering verkrijgt men datacompressie op basis van deze nietuniforme probabiliteitsdistributie. Deze eigenschap wordt frequent toegepast in tekst, beeld en videocompressie. Hiervoor bestaan diverse technieken. Grofweg zijn deze in twee categorieën in te delen: de woordenboekgebaseerde algoritmes zoals gzip en winzip, en de statische algoritmes zoals de Huffmancodering [16]. Ook de aritmetische encoder is een statistisch algoritme zoals de Huffmancodering, maar is flexibeler van opzet. Woordenboekgebaseerde algoritmes vervangen groepen van variabele symbolen door vastelengte codes. Dit soort algoritmes is echter praktisch niet in hardware te realiseren, daar deze

26 2.2. DE ARITMETISCHE ENCODER 15 een enorme hoeveelheid geheugen gebruiken voor de opslag van het woordenboek. Statistische algoritmes doen net het omgekeerde: deze nemen één symbool per keer en coderen dit naar een variabele lengte uitvoercode. De lengte van de uitvoercode varieert, gebaseerd op de probabiliteit of de frequentie van het symbool in de symboolstroom. Weinig voorkomende symbolen worden gecodeerd met veel bits, en veel voorkomende symbolen met weinig bits. De maximale compressie die men theoretisch kan bereiken, wordt gegeven in het Shannon s theorema: Theorema 1 Shannon: De limiet voor datacompressie is de entropie van de symbolen, gegeven door log 2 (P) De totale entropie H(X) van de informatiestroom X die n verschillende symbolen bevat, kan dan berekend worden als volgt: H(X) = n P(x i ) log 2 P(x i ) i=1 Een voorwaarde voor compressie is dus een niet-uniforme verdeling van de symboolwaarschijnlijkheid. Wanneer we bijvoorbeeld een symboolstroom met twee statistisch onafhankelijke symbolen wensen te coderen, waarbij elk symbool een evengrote waarschijnlijkheid heeft, verkrijgen we voor de entropie van de informatie: H(X) = 2 i=1 1 2 log = 1 Aangezien er slechts 2 symbolen zijn, is de symboolgrootte 1 bit, en deze bevat ook 1 bit aan informatie, m.a.w. er is geen compressie mogelijk. Wanneer daarentegen het ene symbool probabiliteit 1 heeft, en het andere probabiliteit 0, dan is de entropie 0, gezien we met zekerheid weten dat het eerste symbool zal worden verstuurd. Er wordt dus in feite geen nuttige informatie verstuurd. Principe Huffmancodering Bij de Huffmancodering wordt aan ieder symbool een uitvoercode toegekend per geheel aantal bits, zodat de minimale lengte van een code 1 bit is. Bij Huffmancodering kan de optimale entropie dus slechts bereikt worden als de logaritmes van de probabiliteit van de symbolen een geheel getal vormen. Deze beperking laat zich merkbaar gelden wanneer de probabiliteit van een symbool hoog wordt. Bijvoorbeeld een symbool dat een probabiliteit heeft van 90%, heeft een optimale codelengte van 0,15 bits. De Huffmancode dient hier minstens 1 bit aan toe te kennen, wat ongeveer 6 keer te veel informatie levert dan nodig. Een ander probleem met Huffmancodering is de combinatie met een adaptief coderingsschema. Bij adaptieve modellering worden de symboolprobabiliteiten bepaald terwijl het encoderen bezig is, aan de hand van de gecodeerde symbolen, waarbij de probabiliteiten voortdurend worden aangepast. Bij vaste codeerschema s daarentegen wordt de codering in 2 fases uitgevoerd: in een eerste fase wordt de probabiliteit van alle te coderen symbolen berekend, waarna in de tweede fase

27 2.2. DE ARITMETISCHE ENCODER 16 de symbolen volgens een vast schema worden gecodeerd. In veel gevallen is dit echter niet mogelijk (bijvoorbeeld bij een bitstroom in ware tijd is de volledige stroom niet op voorhand gekend) of zou dit tot een onaanvaardbare vertraging leiden. Ook voor onze toepassing is een adaptief schema sterk aanbevolen. De beste adaptieve Huffmancoderingsalgoritmes die tot nog toe werden beschreven, verbruiken echter relatief veel tijd en geheugen. Principe aritmetische encodering Pas de laatste twee decennia is een respectabel alternatief ontwikkeld voor de Huffmancodering: de aritmetische codering, die reeds succesvol wordt toegepast. Bij de aritmetische encoder vertrekt men van een heel ander principe dan het vervangen van een invoersymbool door een specifieke uitvoercode. Hierdoor is men niet meer gebonden aan een geheel aantal bits per geëncodeerd symbool. Aritmetische codering kan op twee manieren worden uitgevoerd: met vlottende-komma-getallen [13], en met gehele getallen. We beperken ons hier tot de gehele versie van het algoritme, daar dit vanuit hardware oogpunt gezien ook de meest toepasbare versie is. Voor de duidelijkheid werken we in onze uitleg met decimale getallen. De werking met binaire getallen, zoals het in hardware wordt uitgevoerd, is echter volledig analoog. Het principe van een aritmetische encoder/decoder is gebaseerd op een interval dat verdeeld wordt in zones, evenveel als het aantal verschillende symbolen die moeten geëncodeerd worden. Hierbij is de grootte van elk subinterval evenredig met de kans dat elk symbool zich voordoet. In figuur 2.4(a) is een voorbeeld te zien met 4 symbolen a, b, c en d. We werken met een interval van 4 cijfers. Symbool c heeft hier een waarschijnlijkheid van 1/2, a en d van 1/5 en b van 1/10. Bij het begin van het encoderen wordt het interval op de uiterste grenzen ingesteld. Bij het encoderen van een symbool wordt het huidige interval verkleind tot een subinterval overeenstemmend met het corresponderend interval van dit symbool (zie figuur 2.4(b)). Hierbij dienen de binnengrenzen van elk deelinterval opnieuw te worden bepaald relatief ten opzichte van de nieuwe boven- en ondergrenzen. De boven- en ondergrenzen van dit nieuwe interval worden nu na elke iteratie bekeken. Wanneer de meestbeduidende cijfers van de boven- en ondergrens gelijk zijn, weten we dat deze niet meer kunnen veranderen gedurende verdere opdeling van het interval. Dit komt doordat bij het verkleinen van het interval, de grenzen enkel naar elkaar kunnen toegroeien. De encoder geeft dan deze cijfers vrij, waarna de overige cijfers worden opgeschoven naar links, waarbij nullen worden ingeschoven op de vrijgekomen plaatsen. Dit is te zien in stap (c) van figuur 2.4. Het eerste cijfer van de boven- en ondergrens is nu gelijk, namelijk 4, en wordt verstuurd naar de uitvoer. Hierna wordt het interval aangepast door alle grenzen opnieuw te berekenen zoals te zien in figuur 2.4(d). Vergelijking met Huffmancodering Aangezien het aantal bits dat voor elk symbool wordt gebruikt nu niet meer noodzakelijk een geheel getal is, kan steeds een optimaal aantal bits worden bereikt. Dit in tegenstelling tot de Huffmancodering, waar het aantal bits per symbool een geheel getal dient te zijn Resolutie-underflow preventie Telkens wanneer een nieuw symbool wordt geëncodeerd, wordt het interval verkleind, terwijl het aantal bits of cijfers waarmee we het interval voorstellen gelijk blijft. Wanneer een symbool wordt

28 2.2. DE ARITMETISCHE ENCODER d d d d d c c c c c b b b b b a a a Cijfer 4 uitsturen a a 0 (a) 3000 (b) 4000 (c) 0 (d) 0 (e) Figuur 2.4: Werking van een aritmetische encoder uitgestuurd, vergroot dit interval weer, doch onder bepaalde omstandigheden kan er een verlies aan nauwkeurigheid optreden in het interval, als gevolg van het beperkt aantal cijfers waarmee we het interval voorstellen. Stel dat we bij het decimale geval op een bepaald moment op een bovengrens van 6004 uitkomen bij een ondergrens van Op dit punt is het interval waarin we de symbolen dienen voor te stellen slechts één digit groot. Na enkele iteraties kunnen we zelfs tot het interval komen. Op dit punt zijn de waarden vastgelopen. Het interval tussen boven- en ondergrens is te klein geworden, zodat berekeningen steeds dezelfde waarde zullen terug geven. Omdat de meest beduidende cijfers van het interval niet gelijk zijn, kunnen echter geen symbolen worden uitgestuurd. Om dit te vermijden, treden we preventief op, zodat we nooit in zulke situatie kunnen verzeild geraken. In het originele algoritme werd enkel gekeken naar de meest beduidende cijfers. Wanneer deze gelijk waren, werden ze uitgestuurd. Hieraan wordt nu nog een tweede test gekoppeld: indien de meest beduidende cijfers opeenvolgend zijn, wordt eveneens gekeken naar de tweede meest beduidende cijfers. Wanneer deze van de ondergrens een 9 is en die van de bovengrens een 0, hebben we kans dat in één van de volgende iteraties een resolutie-underflow zal optreden. We voeren nu een extra variabele in: de underflow-variabele. Wanneer we in voorgaande situatie terechtkomen, worden de 2de meest beduidende bits verwijderd, waarbij de rest van de cijfers wordt opgeschoven. Rechts wordt nu in de bovengrens een 9 ingeschoven, en in de ondergrens een 0. Tegelijkertijd wordt de underflow-variabele met 1 verhoogd. Een voorbeeld is te zien in tabel 2.1. Praktisch gezien blijft de waarde van de underflow-variabele zeer beperkt. Het aantal

29 2.2. DE ARITMETISCHE ENCODER 18 voor na bovengrens ondergrens underflow 0 1 Tabel 2.1: Underflow preventie underflows zal zelden het aantal digits gebruikt om het interval voor te stellen overtreffen. Deze controle-berekening wordt eventueel herhaald tot de tweede meest beduidende cijfers geen 0 resp. 9 meer bevatten. Wanneer in een volgende iteratie de meest beduidende cijfers naar eenzelfde waarde convergeren, voeren we nu eerst dit cijfer uit. Daarna worden alle underflow - cijfers uitgevoerd die eerder werden verwijderd. Het decodeerproces doet net het omgekeerde van het encodeerproces. De decoder moet nu wel drie getallen bijhouden in plaats van twee: de boven- en ondergrens, en tevens de codewaarde, die de huidig gelezen cijfers uit de gecodeerde invoerstroom bevat. De waarde van deze cijfers liggen altijd tussen de boven- en ondergrens. Wanneer de grenzen dichter komen, zullen nieuwe schuifoperaties plaatsvinden, waardoor boven- en ondergrens opnieuw groter worden Adaptieve modellering Om de aritmetische encoder geschikt te maken voor datacompressie, moet deze accuraat kunnen voorspellen wat de frequentie of de waarschijnlijkheid van de symbolen is in de invoer. Hiertoe wordt gebruik gemaakt van een frequentietabel, waarin de frequentie van elk symbool wordt opgeslagen. Het opstellen van deze tabel gebeurt in onze encoder additief, d.w.z. dat de waarschijnlijkheidsinformatie van de symbolen, en dus de grootte van elk symboolinterval gedurende de uitvoering van de encodering stelselmatig wordt opgebouwd, aan de hand van de geëncodeerde informatie. Men vertrekt hiertoe van een tabel waarin alle symbolen frequentie 1 hebben, en dus alle even waarschijnlijk zijn. Men kan niet starten met een frequentie van 0 voor een symbool, daar dit gelijk staat met een 0-interval en dus een symbool dat niet kan voorkomen. Telkens een symbool wordt geëncodeerd, wordt de tabel bijgewerkt door het verhogen van de frequentie van dit symbool Specifiek gebruikte encoder in dit afstudeerwerk Het beschreven algoritme tot nog toe betreft een orde-0 implementatie. Hiermee bedoelt men dat voor het selecteren van een bepaalde symboolwaarschijnlijkheid, men enkel uitgaat van de waarschijnlijkheid dat het huidig symbool zich voordoet, ongeacht de onmiddellijke voorgaande symbolen. In veel datastromen, zoals bijvoorbeeld tekst, zijn er echter ook veel onderlinge afhankelijkheden tussen de symbolen. Bijvoorbeeld de letter e is de meest voorkomende letter in het nederlands, en heeft een kans van voorkomen van De kans dat het symbool r zich voordoet in een nederlandse tekst, bedraagt ongeveer 0,0590. Wanneer echter gegeven is dat de huidige letter

30 2.2. DE ARITMETISCHE ENCODER 19 een e is, dan is de kans dat de volgende een r is reeds gestegen tot Algoritmes die gebruik maken van dit soort informatie, zijn hogere orde-implementaties. Een orde-1 implementatie houdt rekening met het huidig en het vorig symbool. Een orde-2 implementatie houdt rekening met het huidig en de vorige twee symbolen, enz. Het nadeel van deze hogere orde implementaties is het geheugenverbruik voor de frequentietabellen. Wanneer men uitgaat van ASCII-symbolen, zijn er 256 mogelijke symbolen. In een orde-0 implementatie is dan een tabel nodig die 256 symboolfrequenties kan bijhouden. Bij een orde-1 implementatie is reeds een orde-0 tabel nodig die de orde-0 frequenties bijhoudt, en een orde-1 tabel die combinaties moet bijhouden, en dus waarden moet kunnen bevatten. Vandaar dat hogere orde algoritmes in hardware moeilijk realiseerbaar zijn. De symboolstroom die uit de quadtree komt, is echter zeer willekeurig, wanneer men kijkt naar de afhankelijkheden tussen de symbolen onderling. Het heeft daarom weinig zin om met hogere ordes te gaan werken. Vandaar dat men hier gekozen heeft voor een eenvoudige orde-0 implementatie. De symbool-eenheid is hierbij 1 bit, gezien de quadtree ook symbolen van deze omvang codeert. Een interval wordt dus slechts ingedeeld in een onderste en een bovenste deelinterval. Dit maakt dat de bijwerkoperaties die nodig zijn per geëncodeerd symbool, beperkt blijven tot het berekenen van de nieuwe middengrens, waardoor het algoritme betrekkelijk eenvoudig blijft, en de hoeveelheid benodigd geheugen eveneens zeer beperkt is. De keerzijde van de medaille is natuurlijk dat het algoritme in zijn pure vorm zou leiden tot een zeer povere compressie, daar dan enkel gekeken wordt naar de globale frequentie van het aantal nullen en enen in de bitstroom. Via het Shannon s theorema vinden we bij een waarschijnlijkheid P(0) = 0, 65 en P(1) = 0, 35 een entropie van: H(X) = P(0) log 2 P(0) P(1) log 2 P(1) = 0.65 log 2 P(0.65) P(0.35) log 2 P(0.35) = wat dus overeenkomt met een compressie van ongeveer 6,6%. De sterkte van het algoritme zit echter in de extra trap van het algoritme die zich bevindt tussen de quadtree en de aritmetische encoder: de contextgebaseerde modelselectie. Intern worden in de aritmetische encoder verschillende frequentietabellen bijgehouden, waarbij een contextselectie ervoor zorgt dat voor elk type data die uit de quadtree komt, een ander model wordt geselecteerd. Data waarvan men weet dat deze veel enen bevat worden met een ander model gecodeerd dan data die statistisch gezien veel nullen zal bevatten. Op deze manier zorgt de contextgebaseerde modelselectie ervoor dat de aritmetische encoder de aangeboden data efficiënt zal coderen. Het verschil met een hogere orde codering is nu dat een hogere orde gaat kijken naar afhankelijkheden tussen de symbolen onderling. De contextgebaseerde modelselectie daarentegen gaat afhankelijk van lokale informatie uit het beeld een bepaald model gaat kiezen. Dit is dus een coderingstechniek die zich specifiek toelegt op het coderen van beelden. In de volgende sectie wordt deze trap verder uit de doeken gedaan. 1 Deze gegevens worden algemeen gebruikt in cryptografische toepassingen, en kunnen op het internet worden gevonden door te zoeken naar cryptografie

31 2.3. CONTEXTGEBASEERDE MODELSELECTIE Contextgebaseerde modelselectie Zoals reeds besproken bij het quadtree-algoritme, gebeurt de codering in drie herhalende fasen: de niet-significantiepas, de significantiepas en de verfijningspas. In alle drie de passen worden symbolen naar buiten gebracht die de noodzakelijke informatie bevatten voor een volledige (schaalbare) reconstructie van het originele beeld. De symbolen uit de passen bevatten echter verschillende soorten data, en bezitten dus een andere statistiek. Het is daarom zeer inefficiënt om hetzelfde statistisch model te gebruiken voor de symbolen uit de verfijningspas en de symbolen uit de significantiepas, of voor de significantiesymbolen en de tekensymbolen uit de (niet-)significantiepas. Vandaar dat in deze encoder gezorgd wordt voor afzonderlijke modellen voor de types data. Men onderscheid in totaal vier types data: de tekenbits, de significantiebits, de verfijningsbits en de bloksignificantiebits. Deze laatste horen bij de symbolen in de uitvoerstroom die aangeven of de huidige tak in de boom al dan niet significant is, zodat de decoder weet dat deze tak al dan niet verder wordt opgesplitst. Naast deze indeling gaat men nog een stuk verder. Per type data worden nog eens verschillende modellen gebruikt. Voor de selectie van die modellen baseert men zich op twee grootheden die de statistiek beïnvloeden: De significantie van de buren Aan de hand van het aantal buren die reeds significant zijn, worden een aantal verschillende modellen gebruikt. De kans dat een symbool significant wordt, wanneer al zijn buren reeds significant zijn, is groter dan wanneer bijvoorbeeld slechts één buur significant is. Het waveletkwadrant De waveletgebieden worden gevormd door het uitvoeren van een tweedimensionale wavelettransformatie op het beeld. Hierbij ontstaan 4 kwadranten, waarbij het linkerbovenkwadrant een aantal keer recursief verder wordt getransformeerd. De overige 3 kwadranten vertonen elk een verschillend statistisch gedrag: Het linkeronderkwadrant (LO) en het rechterbovenkwadrant (RB) bevatten de hogere orde-coëfficiënten van de horizontale resp. de verticale transformatie op het beeld. Het rechteronderkwadrant (RO) bevat een invloed van beide transformaties. Om deze afhankelijkheden te modelleren, wordt de buren-informatie opgedeeld in horizontale, verticale en diagonale buren. Bij het RO-kwadrant spelen vooral de diagonale buren een rol, terwijl de LO- en RB-kwadranten hetzelfde gedrag vertonen, maar dan met gespiegelde horizontale en verticale buren. Deze indeling heeft vooral zijn nut bij het bepalen van de significant geworden symbolen in de niet-significantiepas en de significantiepas. Een schets van de totale opzet is te vinden in figuur 2.5. Concreet worden er per kwadrant 9 significantiemodellen gebruikt, 9 blokcontextmodellen en 5 tekenmodellen. Het toepassen van meer modellen bleek nauwelijks meer lonend te zijn. De verfijning van de coëfficiënten in de verfijningspas is statistisch gezien minder voorspelbaar, daar de minderbeduidende bits van een getal zich relatief random gedragen tot de meestbeduidende bits. Vandaar dat het geen zin heeft om ook hier een uitgebreide modellenstructuur te gaan gebruiken. Hier werd gekozen voor 3 verfijningsmodellen: een model dat gebruikt wordt voor de in vorige pas toegevoegde coëfficiënten, een tweede model voor de andere coëfficiënten

32 2.3. CONTEXTGEBASEERDE MODELSELECTIE 21 Niet- Quadtreealgoritme significantiepas Significantiepas Contextgebaseerde modelselectie Aritmetische encoder Uit Verfijningspas Modelselectie op basis van bureninformatie en waveletkwadrant Figuur 2.5: Schematische opzet van de volledige encoder die nog geen horizontaal of verticaal significante buren hebben, en een derde model voor alle overige coëfficiënten. In totaal worden dus per kwadrant = 26 modellen verschillende frequentietabellen gebruikt om de aritmetische encoder aan te sturen. Het coderen gebeurt zoals gezien per resolutieniveau. Het basisresolutieniveau, dit is het linkerboven subkwadrant op het diepste waveletniveau die de laagste frequentiecomponenten bevat, bestaat uit één kwadrant. Alle hogere resolutieniveaus die de informatie bevatten om het beeld met grotere resolutie te reconstrueren, bestaan telkens uit drie kwadranten. Per resolutieniveau worden dan in totaal 3 26 = 78 modellen gebruikt. De structuur van een drie-niveaus waveletgetransformeerd beeld is te zien in figuur 2.6. Het resultaat van deze aanpak is een zeer goede compressie die bereikt wordt met bescheiden middelen. Het voorgestelde algoritme voor de contextselectie gebruikt echter wel een behoorlijke hoeveelheid geheugen om de buren-informatie bij te houden, wat het niet eenvoudig maakt om te implementeren in hardware. In hoofdstuk 4 wordt dit uitgebreider uit de doeken gedaan. Tot slot van dit hoofdstuk geven we in figuur 2.7 enkele meetresultaten van een grijswaardenbeeld van met 8 bits per pixel van Lena. We zien dus dat de entropie-encodering hier superieure prestaties levert t.o.v. een woordenboekgebaseerd algoritme zoals winzip. De entropie-encodering zorgt voor dit referentiebeeld voor ongeveer 12 % extra compressie. Om de invloed van de contextselectie te bekijken, bepalen we even de compressie die zou mogelijk zijn zonder deze module. De quadtree stuurt voor dit beeld in totaal bits naar de entropie-encodering, waarvan enen, of P(1) = 0.39 en P(0) = Wanneer we het Shannon s theorema hierop toepassen vinden we een limiet van: H(X) = 0.61 log 2 P(0.61) P(0.39) log 2 P(0.39) = wat slechts een extra compressie van 3,5 % zou betekenen.

33 2.3. CONTEXTGEBASEERDE MODELSELECTIE 22 Basisblok level 1 LOblok level 1 RBblok level 1 ROblok level 1 RB-blok level 2 RB-blok level 3 LO-blok level 2 RO-blok level 2 LO-blok level 2 RO-blok level 3 Figuur 2.6: Velden in een waveletgetransformeerd beeld omvang (bytes) origineel winzip op origineel waveletgetransformeerd (18 bits) quadtree zonder entropie quadtree met entropie quadtree met winzip beeldtype Figuur 2.7: Compressieresultaten van Lena pixels, 8 bit per pixel

34 Hoofdstuk 3 Quadtree-opdeling De quadtree-opdeling vormt de centrale module van deze encoder. Deze voert de eerste codereductie uit, en stuurt de andere modules op een intelligente manier aan. In dit hoofdstuk wordt de uitwerking van de quadtree-opdeling in hardware besproken. We vertrekken hierbij van de software-code. 3.1 Opzet van de software-code De verschillende blokken Het algoritme is in hoofdzaak in te delen in vijf grote blokken: Initialiseren Dit blok zorgt voor het bepalen van de startdrempel. Bij het basisblok wordt hierbij eerst het gemiddelde van alle waarden berekend, waarna deze wordt afgetrokken van alle waarden in het basisblok. De gemiddelde waarde wordt eveneens mee verzonden naar de decoder zodat deze de originele waarden kan herstellen. Er zijn twee belangrijke redenen waarom deze truc wordt toegepast: Doordat de absolute waarde van de getallen met de helft vermindert, is ook de startdrempel 1 waarde lager, waardoor minder informatie moet worden geëncodeerd. Het basisblok is namelijk het enige blok dat enkel positieve waarden bevat (dit zijn de laagste frequentiecomponenten van het origineel beeld), de andere blokken kunnen zowel positieve als negatieve waveletcoëfficiënten bevatten. De decoder start met een basisbeeld waarbij alle pixels als waarde de gemiddelde waarde hebben. Dit is een veel betere schatting dan wanneer men van een nulbeeld vertrekt. Op het einde van het decodeerproces, of na het afbreken ervan, wordt de gemiddelde waarde weer bij de verkregen pixels opgeteld. Codeersturing Deze procedure stuurt de volgende drie procedures aan, waarbij begonnen wordt bij de startdrempel en zo monotoon per cyclus de drempel wordt verlaagd tot de drempel 1 bedraagt. Dit is het einde van de encodeercyclus. Binnen elke procedure worden de drie kwadranten van het resolutieniveau (uitgezonderd het basisresolutieniveau dat slechts één kwadrant bevat) achtereenvolgens behandeld. 23

35 3.1. OPZET VAN DE SOFTWARE-CODE 24 vorige drempel huidige drempel 1 x opdelen 1 x Doe niets, werd reeds vroeger significant geen minimum blok 0 minimum blok Bloksignificantie(0), niet verder opdelen Bloksignificantie(0), niet verder opdelen x Bloksignificantie(1), opdelen Bloksignificantie(1), minimumblok aflopen, coëfficiënten uitvoeren Figuur 3.1: De verschillende mogelijkheden in een quadtree-deelboom Niet-significantiepas Dit blok wordt per drempelniveau als eerste opgeroepen, en verwerkt de niet-significantielijst. Hierbij worden de significant geworden waarden uit de lijst verwijderd en toegevoegd aan de verfijningslijst. Per kwadrant wordt een afzonderlijke lijst bijgehouden, ook voor de verfijningslijst. Significantiepas Deze pas implementeert de eigenlijke quadtree-opdeling. De procedure gaat hierbij afhankelijk van de gegevens zichzelf viermaal recursief oproepen tot een niet-significant blok of de minimale blokgrootte wordt bereikt. Bij het bereiken van de minimale blokgrootte, worden de coëfficiënten in het blok sequentieel verwerkt. Het bepalen of een blok significant is, wordt bereikt in twee cycli: in de eerste cyclus wordt gekeken of het blok reeds significant was bij het vorige drempelniveau. Indien dit zo is, wordt indien nodig verder opgesplitst. Anders, als het volledige blok in het vorige drempelniveau niet significant was, wordt gekeken naar het huidige drempelniveau. Indien deze significante waarden bevat, wordt eveneens opgesplitst. In het andere geval hebben we te maken met een blok dat nog niet significant is. Een schematisch overzicht wordt gegeven in figuur 3.1. Tijdens deze bewerkingen worden ook blokcontextsymbolen verzonden waarmee de decoder de boom opnieuw kan reconstrueren. Verfijningspas Deze pas wordt telkens op het einde van iedere pas uitgevoerd, en gaat alle symbolen die reeds eerder significant zijn geworden en zich dus in de verfijningslijst bevinden verfijnen. Dit gebeurt door de bit die overeenkomt met het huidige drempelniveau van iedere coëfficiënt te coderen.

36 3.2. UITWERKING VAN HET ALGORITME 25 x start verfijningslijst start niet-significantie lijst y Figuur 3.2: Eenvoudig voorbeeld van de lijstenstructuur in de software-code De geheugenstructuur Het algoritme dat we hier gebruiken is zoals eerder besproken een gelimiteerde versie van een boomopdelingsalgoritme. Er dienen twee lijsten te worden bijgehouden: de niet-significantielijst en de verfijningslijst. In de softwarecode worden deze lijsten opgezet als een 2D-matrix waarin elk element een wijzer bevat naar het volgend element. Gezien de elementen in de verfijningslijst en de elementen in de niet-significantielijst mutueel exclusief zijn, kan dezelfde 2D-matrix worden gebruikt voor beide lijsten. Twee wijzers wijzen naar het startelement van de twee lijsten in de matrix. In figuur 3.2 is dit schematisch weergegeven. Daarnaast is een structuur aanwezig die de grenzen tussen de verschillende waveletniveaus bijhoudt. Het doel van deze lijst is de volgende: men kan in het gegeven algoritme het aantal waveletniveaus en het aantal resolutieniveaus apart instellen, waarbij het aantal resolutieniveaus natuurlijk steeds kleiner of gelijk moet zijn dan het aantal waveletniveaus. Door het aantal resolutieniveaus kleiner te kiezen, ontstaat in het laagste resolutieniveau een gefragmenteerd beeld dat nog enkele waveletdecomposities bevat. Bij het bepalen van de buren in deze structuur, is het onzinnig om informatie te gebruiken van buren die in een ander waveletkwadrant liggen. De grenzenstructuur dient er nu voor om zulke situaties te detecteren. 3.2 Uitwerking van het algoritme Het algoritme in de huidige vorm is praktisch onmogelijk in de hardware te krijgen die ons ter beschikking werd gesteld, wegens de te grote geheugenvereisten. Daarnaast is het algoritme ook zeer onefficiënt opgesteld. Voor de bepaling van de geheugenvereisten gaan we steeds uit van CIF-beelden. Deze hebben een resolutie van wat ook nog kan geschreven worden als ( ) (9 2 5 ). Dit geeft een totaal van pixels. In wat volgt bespreken we kort de verschillende wijzigingen die werden doorgevoerd aan het algoritme zonder dat hiermee echter de globale (uitwendig waarneembare) werking van het algoritme werd veranderd.

37 3.2. UITWERKING VAN HET ALGORITME Verbeteren van de geheugenstructuur Resolutieniveaus serialiseren In de originele code is het hele encodeerproces opgevat als een groot blok dat alle resolutieniveaus codeert, en hierbij dus ook geheugen voor alle resolutieniveaus gelijktijdig voorziet. De codering van de afzonderlijke resolutieniveaus daarentegen vindt na elkaar plaats vinden. Gezien het encodeerproces voor elk resolutieniveau identiek verloopt, is het eenvoudiger een encoder te implementeren die slechts één resolutieniveau verwerkt, maar een aantal malen wordt opgeroepen. Dit bespaart verder reeds een kwart van het geheugen. Gelinkte lijsten De gelinkte lijstenstructuur stelt een groot probleem. Deze is onmogelijk in de oorspronkelijke vorm volledig in de RAM-blokjes van de FPGA onder te brengen. Elke pixel vereist namelijk ruimte voor een wijzer naar een volgende pixel. Uitgaande van CIF ( pixels) zijn 9 bits voor zowel de x- als de y-component nodig (of 17 bits wanneer we de adresruimte ééndimensionaal benaderen: = < 2 17 ). Het geheugen deels onderbrengen in het externe DDR-SDRAM van het PCI-bord is eveneens een slechte optie, daar de geheugenplaatsen zoals te zien in figuur 3.2 willekeurig worden benaderd. DDR-SDRAM is enkel snel wanneer opeenvolgende geheugenplaatsen worden uitgelezen, willekeurig benaderen van dit soort geheugens levert zeer slechte prestaties op. Een oplossing voor de verfijningslijst werd gevonden door rekening te houden met het feit dat bij verfijningslijst enkel elementen achteraan worden toegevoegd, en gedurende de verfijningspas alle elementen steeds vanaf het begin tot de in huidige pas toegevoegde elementen worden doorlopen. Door de 2D-gelinkte lijst te vervangen door enkele 1D-lijsten waarbij opeenvolgende elementen de opeenvolgende pixels uit de originele lijst bevatten, verkrijgen we een lijst waarin alle elementen sequentieel na elkaar worden uitgelezen. Op deze manier wordt het wèl mogelijk om het DDR-SDRAM geheugen te gaan gebruiken als thuisbasis voor de gegevens. Nu worden enkel twee kleine M512-RAM-blokjes gebruikt die de data gaan bufferen. Terwijl data uit de eerste buffer wordt verwerkt, wordt de tweede geladen met de volgende elementen uit de lijst vanuit het DDR-SDRAM. Op deze manier kan het algoritme op volle snelheid verder werken. Gezien per kwadrant een lijst wordt bijgehouden, dienen per kwadrant dus twee dergelijke buffers te worden voorzien. Voor de niet-significantielijst is de situatie iets complexer. Elementen worden hier zowel verwijderd uit de lijst als achteraan toegevoegd. Doch een equivalente oplossing kan hier gebruikt worden door twee lijsten te gebruiken. Terwijl de ene lijst wordt gelezen, worden enkel de gegevens die behouden dienen te blijven, naar de tweede lijst geschreven. Op het einde van de pas wordt de tweede lijst eenvoudig de nieuwe eerste lijst, en wordt de eerste lijst gewist. Waveletniveaus en resolutieniveaus Het volgend probleem betreft de mapstructuur. In het oorspronkelijke algoritme gebruikt men hiervoor een soort getallenmap, waarbij elke pixel een nummer krijgt, uniek voor elk waveletkwadrant. Wanneer de naburige pixel een ander nummer heeft dan het huidige kwadrant weet men dat die pixel tot een ander kwadrant behoort, en dus niet moet worden beschouwd. Een grote verbetering wordt verkregen door de getallenmappen te vervangen door een grenzenstructuur die enkel de kwadrantgrenzen opslaat.

38 3.3. IMPLEMENTATIE IN SYSTEMC 27 Bij het coderen van een pixel, wordt dan gekeken of de positie overeenkomt met een van de ingestelde grenzen. Doch we kunnen ons de vraag stellen of het expliciet wel nodig is een dergelijke optie te voorzien waarbij meer waveletniveaus kunnen worden gekozen dan resolutieniveaus. Gezien de extra complexiteit door de controles die telkens uitgevoerd dienen te worden, is het wenselijk de gehele structuur indien mogelijk overbodig te maken. Daarom werden eerst enkele metingen verricht voor verschillende waveletniveaus en resolutieniveaus bij verschillende types beelden. De resultaten zijn te vinden in tabel B.1 op pagina 85. Hierbij merken we dat er relatief weinig verschil is in de bitrate wanneer we bij een gelijkblijvend aantal waveletniveaus, meer resolutieniveus gaan gebruiken. Gemiddeld worden bij QCIF bijvoorbeeld 7, 606 bits per pixel gebruikt voor 2 resolutieniveaus en 3 waveletdecomposities. Bij 3 resolutieniveaus en gelijkblijvend aantal waveletdecomposities wordt dit bits per pixel. Anderzijds heeft het kiezen van meer waveletdecomposities dan nodig voor het bereiken van het aantal resolutieniveaus zelfs een negatieve invloed op de compressie. Bij QCIF worden bijvoorbeeld bits per pixel gebruikt bij 2 resolutieniveaus en 2 waveletniveaus. Bij het verhogen van het aantal waveletdecomposities bij gelijkblijvend aantal resolutieniveaus, wordt het gemiddelde bits per pixel. M.a.w. het heeft geen zin deze optie in te bouwen, waardoor de code eveneens een stuk doorzichtiger wordt, en het geheugengebruik verder wordt terug gedrongen. Het aanbrengen van deze verandering bracht nog enkele bugs in de originele code aan het licht, die bij lagere resolutieniveaus niet zichtbaar waren. De bug werd veroorzaakt door een niet-consistente controle op addresseringen buiten de grenzen van het beeld. Het verwijderen van de mappenstructuur in zowel de encoder als de decoder loste de bug uiteindelijk op. 3.3 Implementatie in SystemC Encodeervolgorde aanpassen en geheugenafspraken Gezien de encoder de beelden steeds volledig dient te encoderen, speelt het geen rol in welke volgorde de verschillende resolutieniveaus worden verwerkt. Om de quadtree-encoder beter te laten aansluiten bij de wavelet-encoder, werd daarom besloten de encodeervolgorde om te keren. We beginnen nu met de hoogste resolutieniveaus te encoderen (dit zijn ook de meest tijdsconsumerende niveaus). Gezien de wavelet-encoder recursief te werk gaat, waarbij eerst de hoogste resolutieniveaus worden berekend, levert dit kortere wachttijden op wanneer de twee modules moeten samenwerken. De quadtree-encoder kan dan reeds beginnen met het hoogste resolutieniveau te comprimeren, terwijl de wavelet-encoder nog bezig is met het berekenen van de lagere resolutieniveaus. Tevens werd met Inge, de collega die de wavelet-encoder bouwt [7] de geheugenstructuur vastgelegd waarin de beelden zullen worden uitgewisseld. De oorspronkelijke manier van opslaan is te zien in figuur 3.3(a). De afgesproken geheugenstructuur in figuur 3.3(b) zorgt er nu voor dat de adressering een stuk eenvoudiger en doorzichtiger wordt. Bij elk resolutieniveau kan nu eenvoudig met een basiswijzer worden gewerkt die wijst naar het eerste blok van het huidige resolutieniveau in het DDR-SDRAM. De addressering kan dan relatief gebeuren t.o.v. deze wijzer.

39 3.3. IMPLEMENTATIE IN SYSTEMC a) b) Figuur 3.3: Locatie in geheugen van een beeld (a) origineel (b) na aanpassing Het volledige beeld zal worden bijgehouden in het DDR-SDRAM, waarbij de benodigde gegevens gebufferd worden in snelle RAM-blokjes op de FPGA. Gezien het beeld binnen elk kwadrant willekeurig kan worden benaderd, is het nodig om een volledig kwadrant in het intern geheugen te laden. Het is anderzijds niet nodig alle drie de kwadranten gelijktijdig in het geheugen te hebben (weerom uitzondering voor het basisblok dat slechts één kwadrant bevat), omdat de drie kwadranten na elkaar worden verwerkt. Door de laaggeoriënteerde verwerking van de beelden, is er gelukkig slechts weinig informatie nodig over elke coëfficiënt: met drie bits per pixel kan worden volstaan: een tekenbit, een significantiebit in het huidig drempelniveau en een significantiebit in het vorige drempelniveau. Een CIF-kwadrant beslaat = pixels. Een M4K RAM-blok beschikt zoals in bijlage A is te vinden over bits. We configureren de blokken als bit, waarbij we telkens 3 blokken parallel gebruiken. Om aan geheugenplaatsen te komen, zijn 6 blokken nodig. In totaal gebruiken we dan 18 M4K RAM-blokken per kwadrant. Om ervoor te zorgen dat de encoder na het verwerken van een kwadrant niet moet wachten tot een volgend kwadrant werd ingelezen vanuit het DDR-SDRAM geheugen, wordt het volgend kwadrant reeds voorgeladen in een 2de groep van 18 M4K RAM-blokken Optimaliseren van de significantiepas en introductie van een stack De significantieberekeningen in het gegeven algoritme verlopen zeer inefficiënt waarbij vaak dezelfde controles opnieuw worden uitgevoerd. In eerste instantie wordt het beeldkwadrant overlopen op zoek naar significante coëfficiënten in het vorige drempelniveau. Daarna wordt indien het volledige vorige kwadrant niet significant is, het volledige beeld nog eens doorlopen op zoek naar

40 3.3. IMPLEMENTATIE IN SYSTEMC 29 Kwadrant 0 Kwadrant ? 0 1 Kwadrant 2 Kwadrant 3?? 1? x? Significante coëfficient gevonden in het vorig drempelniveau Stop verder onderzoeken, opdelen Kwadrant 0 vereist geen controles meer, bloksignificantie(0) Kwadrant 1: bloksignificantie(1), kan onmiddellijk verder opgedeeld worden indien geen minimum blok, waarbij reeds gekend dat vorig drempelniveau niet significant is, anders coëfficiënten uitvoeren Kwadrant 2: kan ook onmiddellijk verder opgedeeld worden indien geen minimum blok, anders niets doen Enkel kwadrant 3 dient nader onderzocht te worden. Figuur 3.4: Voorbeeld van een geoptimaliseerde controle binnen een kwadrant significante coëfficiënten in het huidige drempelniveau. Het combineren van deze twee controles in één lus, levert reeds een grote besparing op. Wanneer de procedure zichzelf recursief oproept, worden alle controles in de vier deelkwadranten opnieuw uitgevoerd, wat zorgt voor veel overbodige controles. Daarom werden de controleberekeningen anders georganiseerd: het doorlopen van een kwadrant gebeurt nu reeds per subkwadrant. Zodra een significante coëfficiënt wordt tegengekomen, wordt gekeken in welk subkwadrant de controle reeds bezig is. De vorige kwadranten bevatten dan enkel nullen. Een voorbeeld van de werking is gegeven in figuur 3.4. Door rekening te houden met bovenstaande bevindingen, wordt het aantal controleberekeningen gemiddeld gezien met meer dan 75% gereduceerd. Een ander probleem dat zich nog stelt, is de recursieve oproep van de procedure. In hardware kan dit niet. Dit werd opgelost door een stapel bij te houden waarbij de recursieve aanroep wordt vervangen door vier oproepen op de stapel te plaatsen. Bij het eindigen van de procedure, wordt het vorig element van de stapel genomen. Het encoderen gaat verder tot de stapel opnieuw leeg is. Om rekening te kunnen houden met bovenstaande bevindingen, dienen volgende gegevens op de stapel te worden geplaatst per deelblok: de blokafmetingen: de linkerboven x-waarde, de linkerboven y-waarde, de breedte en de hoogte van het deelblok dat beschouwd moet worden. In totaal vergt dit voor CIF-kwadranten 4 15 = 60 bits data. Controleren van de significantie in de vorige bitlaag: indien dit niet moet gebeuren, wordt ondersteld dat de vorige bitlaag binnen het deelblok niet significant is, waardoor indien nodig enkel wordt gekeken naar significantie in de huidige bitlaag.

41 3.3. IMPLEMENTATIE IN SYSTEMC 30 start bezig Quadtree-kernmodule - niet-significantiepas -significantiepas - verfijningspas statistische modelselectie drempel & gemiddelde Beeld module - startdrempel - laaginformatie -voorladen Lijsten -NS-lijsten - VF-lijsten -voorladen Stapel module Intern geheugen Lagen buffer Lijsten buffer Stapel geheugen DDR geheugen Beeldframe Lijsten Figuur 3.5: Interne opzet van de quadtree-opdeling Controleren significantie in de huidige bitlaag: indien dit niet dient te gebeuren, wordt gekeken naar de laatste variabele op de stapel die aangeeft of het blok significant is of niet. Hierdoor wordt het controleren van het huidig deelblok volledig overbodig. Significantie van de huidige bitlaag: deze variabele bevat enkel een relevante waarde indien de controle van de huidige bitlaag af staat. In totaal worden dan (60+3) bits per recursieve oproep gebruikt. Doordat diepte-eerst recursie wordt toegepast, is het maximum aantal geneste oproepen gelijk aan de diepte van de quadtree. Bij een CIF-kwadrant van waarbij opgesplitst wordt tot minimum blokken van 16 bits, is de maximale diepte van de boom gelijk aan De modules en interfaces De SystemC implementatie van de quadtree werd opgesplitst in een aantal modules die elk onafhankelijk werken en communiceren met elkaar via data- en controlesignalen. De quadtreekernmodule laat zich steunen door enkele modules die zorgen voor de communicatie met het geheugen, en een module die de stapel verzorgd. In figuur 3.5 is een schematisch overzicht te vinden van de modules die samenwerken om het volledige quadtree-algoritme te implementeren.

42 3.3. IMPLEMENTATIE IN SYSTEMC Flowcontrole en geheugentoegangen De quadtree-kernmodule vormt het communicatiecentrum voor allerlei data: Beelddata wordt uit het gebufferd geheugen gelezen Data wordt van en naar de niet-significantie- en verfijningslijsten gelezen of geschreven Data wordt van en naar de stapelmodule gelezen en geschreven Symbolen moeten uitgevoerd worden naar de contextgebaseerde modelselectie Op diverse plaatsen dient bovendien flowcontrole ingebouwd te worden. De communicatie met de niet-significantielijsten en de verfijningslijsten gebeurt bij normale werking op een voorspelbare manier. Doch wanneer het DDR-SDRAM geheugen lange tijd door een ander proces op de FPGA werd bezig gehouden (b.v. de wavelettransformatie), kan het gebeuren dat een volgend blok niet tijdig kan worden gebufferd, waardoor de quadtree moet wachten op de nieuwe data. Ook de communicatie met de contextgebaseerde modelselectie dient op een gecontroleerde manier te gebeuren, waarbij de contextgebaseerde modelselectie dient aan te geven wanneer het klaar is om een nieuw symbool te ontvangen. Tenslotte wordt de beeldinformatie zoals eerder besproken ook voorgeladen vanuit het DDR-geheugen, waardoor een veiligheid dient ingebouwd te worden voor het geval het DDR-geheugen de data niet op tijd kan aanbieden. De hogergenoemde communicatieprocessen worden simultaan uitgevoerd tijdens de werking van de significantiepas in de quadtree-opdeling, zodat de snelheid hoog kan worden gehouden. Het interne geheugen kan elke kloktik data uitvoeren, maar er zit echter wel een vertraging van twee kloktikken tussen het invoeren van het adres en het beschikbaar zijn van de data. Dit betekent dat er in feite drie klokperioden nodig zijn om data uit een bepaald geheugenadres te lezen. Wegens de flowcontrole en de vele simultane processen in de significantiepas, dient er intern in de encoder constant gesynchroniseerd te worden, waardoor het niet mogelijk is reeds een volgend adres op de geheugenadreslijnen te plaatsen voordat bevestigd wordt dat de huidige data wordt ingelezen. Dit zou betekenen dat bij een normale flowcontrole, waarbij een signaal aangeeft dat de data wordt genomen, slechts om de drie kloktikken nieuwe data zou kunnen worden uitgevoerd. De flowcontrole hier maakt daarom gebruik van een signaal datatobetaken, waarmee de quadtree weet dat het symbool in de volgende kloktik zal worden ingelezen, zodat deze tijdens die volgende kloktik reeds een nieuw adres in het geheugen kan laden. Door een goed opgezet en afgestemd geheugenbeheer wordt het zo mogelijk om elke twee kloktikken de significantie van een symbool ingelezen uit het beeldgeheugen naar buiten te voeren waarbij het symbool ook aan één van de twee lijsten wordt toegevoegd. Het controleren van een pixelblok op significantie in het vorige en huidige drempelniveau gebeurt simultaan op volle geheugensnelheid, zodat elke kloktik een pixel kan worden gescand Synthese, meetresultaten en verdere optimalisatie op hardware niveau De code van de kern van de quadtree en de stapelmodule zijn nu volledig synthetiseerbaar. De overige twee modules (de beeldmodule en de lijstenmodule) zijn synthetiseerbaar behalve wat betreft de communicatie met het DDR-geheugen. De complexe communicatie die hiervoor nodig is,

43 3.3. IMPLEMENTATIE IN SYSTEMC 32 QCIF YUV CIF YUV Kloktikken A-frame Kloktikken gemiddeld (A+E-frames) Frames/sec bij 85 MHz 80,6 19,3 Frames/sec referentie 11,1 2,7 Tabel 3.1: Haalbare beeldsnelheid van de eerste synthetiseerbare quadtree Versie DSP LEs Max klok Kloktikken Omschrijving blokken (MHz) QCIF A-fr. 1 8/ Eerste synthetiseerbare versie 2 8/ Centraliseren adrestoekenning 3 8/ Volgorde binnen if/then aanpassen 4 6/ Adresberekening met minder signalen 5 5/ Wegwerken optelling in kritisch pad 6 5/ Signalen naar ECoder 1D versturen + eerste significanie-check gekend 7 7/ Interne adressering volledig 1D + optimalisatie significance-pass 8 5/ Spreiden kritische pad berekening over 2 toestanden Tabel 3.2: Aanpassingen doorgevoerd aan de kern van de quadtree aan de hand van de synthese-informatie werd niet meer uitgewerkt in dit afstudeerwerk. Er wordt gebruik gemaakt van een soort simulatie van het DDR-geheugen, zodat de volledige code toch realistisch gesimuleerd kan worden. In tabel 3.1 zijn de resultaten te vinden van een simulatie van de quadtree-opdeling uitgevoerd op enkele QCIF en CIF referentieframes en foutframes. De gedetailleerde informatie van deze testen zijn te vinden in tabel C.1 op pagina 88. Deze simulaties werden uitgevoerd met een geïdealiseerde modelselectie (die dus steeds snel genoeg is), zodat effectief enkel de snelheid van de quadtree-opdeling wordt berekend. De kern van de quadtree module werd eveneens omgezet naar VHDL en van hieruit gesynthetiseerd naar hardware-code met behulp van QUARTUSII (zie bijlage A). In tabel 3.2-versie 1 zijn de resultaten te vinden van de floorplanner en de frequentie-analyse die de software uitvoerde op de code. Aan de hand van de resultaten van de synthese werd de code verder geoptimaliseerd. In de eerste plaats is het gebruik van vermenigvuldigers inefficiënt omdat de berekening van het 1Dadres uit de 2D-blokcoördinaten in elke module afzonderlijk gebeurt. Om dit op te lossen, werd de adresberekening naar een centrale module gebracht, doch zoals te zien in tabel 3.2-versie 2 had dit niet het verhoopte effect. Deze centrale module introduceerde in de plaats een langer kritisch pad, zodat de maximale klokfrequentie naar beneden werd gehaald tot 82,5 MHz.

44 3.3. IMPLEMENTATIE IN SYSTEMC 33 QCIF YUV CIF YUV Kloktikken A-frame Kloktikken gemiddeld (A+E-frames) Frames/sec bij 100 MHz 99,9 23,9 Frames/sec software-referentie 11,1 2,7 Tabel 3.3: Haalbare frame-snelheid van de geoptimaliseerde quadtree Studie van dit kritisch pad toonde aan dat de combinatie van een if/then-statement met een vermenigvuldiging uitgevoerd op een optelling van twee getallen (nodig voor de berekening van de totale y-waarde bij het doorlopen van een blok in de significantiepas) de oorzaak was. Het veranderen van de volgorde in het if/then-statement en het wegwerken van de optelling door de y- waarde in het blok absoluut in plaats van relatief t.o.v. de linkerbovenhoek te addresseren leverde reeds een snelheidsverbetering tot 90 MHz, terwijl nu efficiënter met de vermenigvuldigers wordt omgesprongen. Doch dit kon nog beter door de vermenigvuldiging helemaal overbodig te maken. Hiervoor werd volledig afgestapt van de 2D-adressen in de blokken die steeds een vermenigvuldiging van de vorm adres = y kolombreedte + x vereisen bij het omzetten van het 2D-blokadres naar een 1D-adres in het geheugen. De interne adresseringsstructuur diende hierbij volledig aangepast te worden, waarbij ook nog enkele optimalisaties aan het licht kwamen binnen de significantiepas. Het resultaat van deze omzetting is te zien in tabel 3.2-versie 7. Het nieuwe kritische pad nu bestond uit een éénmalig uitgevoerde vermenigvuldiging en optelling binnen een klokcyclus waarvan het resultaat slechts 2 klokcycli later werd gebruikt. Het uitsplitsen van deze berekening over 2 klokcycli leverde tenslotte een code op die aan meer dan 100 MHz kan worden geklokt. Deze kloksnelheid is belangrijk voor het algoritme door de in hoofdzaak sequentiële werking. Dit is eigen aan coderingsalgoritmes in het algemeen. De resultaten van een simulatie op de geoptimaliseerde code zijn te zien in tabel 3.3 (Aframe is een referentiebeeld, E-frame een foutbeeld). De gedetailleerde gegevens zijn te vinden in tabel C.2 (zie pagina 89). We zien dat we door de optimalisaties uitgevoerd aan de hand van de synthese-informatie nog een extra snelheidswinst halen van (99, 9 80, 6)/80, = 24% bij QCIF (eveneens 24% bij CIF). De versnelling ten opzichte van de software bedraagt ongeveer een factor 9. We halen hierbij ruimschoots een encodering in ware tijd van QCIF beelden, maar CIF-beelden blijken net niet in ware tijd codeerbaar te zijn. De snelheidsmetingen zijn enkel gebaseerd op de kern van de quadtree-module. Men kan zich de vraag stellen of de overige modules de haalbare kloksnelheid niet zullen verlagen. De stapelmodule die geen communicatie met het DDR-SDRAM vereist werd hiertoe ook gesynthetiseerd. Deze leverde een haalbare kloksnelheid van meer dan 190 MHz op (en gebruikt 136 van de beschikbare LE s). Gezien er geen vermenigvuldigingen of andere complexe berekeningen optreden in de overige modules, zullen deze qua kloksnelheid ook in deze buurt liggen. Ze zullen dus zeker geen belemmering vormen voor de haalbare kloksnelheid van de volledige quadtree-module. In hoofdstuk 6 worden nog enkele mogelijkheden besproken om de codering sneller te maken.

45 Hoofdstuk 4 Contextgebaseerde modelselectie Data afkomstig van de quadtree-opdeling wordt eerst opgedeeld in een aantal modellen, vooraleer deze aan de aritmetische encoder door te geven. Dit gebeurt in de contextgebaseerde modelselectie die in dit hoofstuk wordt besproken. 4.1 Opzet van de software-code Door het gelijkstellen van het aantal waveletniveaus en het aantal resolutieniveaus in de quadtreeopdeling, werd de code van de contextgebaseerde modelselectie mee vereenvoudigd, doordat deze trap nu geen binnengrenzen meer in zijn basisresolutieniveaus moet controleren De verschillende blokken Wat overblijft is een eenvoudige code die enkele matrices bevat waarin statistische informatie over elke coëfficiënt wordt bijgehouden, en enkele procedures die aan de hand van die statistische informatie, en van de binnengekregen gegevens van de quadtree een model gaan selecteren waarmee de aritmetische encoder het symbool tenslotte codeert. Voor de selectie van het model bij de significantiesymbolen, wordt rekening gehouden met het kwadrant waarin men momenteel werkt. De indeling van de modellen wordt hierbij zo gekozen dat optimaal rekening wordt gehouden met de karakteristieken van elk kwadrant: bij het kwadrant linksonder bijvoorbeeld zijn het in de eerste plaats de horizontale, daarna de verticale en pas in laatste instantie de diagonale buren die van belang zijn. Voor het kwadrant rechtsboven geldt een analoge prioriteit waarbij de rollen van verticaal en horizontaal zijn omgewisseld. Bij het kwadrant rechtsonder zijn het vooral de diagonale buren die een rol spelen (zie ook figuur 2.6 van pagina 22). Het basisresolutieniveau tenslotte heeft geen uitgesproken kenmerken, omdat dit niveau gewoon de laagste frequentiecomponenten van het beeld bevat. In deze encoder werd ervoor gekozen dit niveau met dezelfde regels te modelleren als het kwadrant linksonder. Zoals vroeger reeds gezien worden in totaal 9 modellen voorzien voor deze symbolen. De selectie van het model voor de tekensymbolen gebeurt op basis van het teken van de horizontale en verticale buren: wanneer die overwegend positief zijn, is de kans groot dat ook het 34

46 4.1. OPZET VAN DE SOFTWARE-CODE 35 huidige tekensymbool positief zal zijn, en omgekeerd. Voor de tekensymbolen worden 5 modellen gebruikt. Voor het selecteren van een blokmodel, wordt het model voor elke coëfficiënt binnen het blok bepaald. Het model dat hierbij het meest voorkomt, wordt geselecteerd als blokmodel. Voor de verfijningssymbolen tenslotte zijn slechts 3 modellen voorzien. Er wordt hierbij weinig rekening gehouden met de buren, gezien de verfijningssymbolen statistisch weinig afhankelijk zijn van de buren. Voor de symbolen die voor het eerst worden verfijnd, wordt een apart model voorzien. Verder worden de overige verfijningssymbolen ingedeeld in een model voor symbolen die nog geen significante buren hebben, en de symbolen die wel reeds significante buren hebben De geheugenstructuur In de originele code worden per coëfficiënt de volgende waarden bijgehouden: Teken Het teken van de huidige coëfficiënt wordt bewaard. Voor het bepalen van de tekens van de buren, dienen dus de naburige waarden opgevraagd te worden. Er zijn 2 bits voorzien voor het teken omdat er 3 mogelijkheden zijn: geen teken wanneer de coëfficiënt nog niet significant is, positief en negatief. Significantie van de buren Om te voorkomen dat voor het bepalen van een significantiemodel telkens 8 buren moeten worden opgevraagd, wordt per coëfficiënt de benodigde informatie op voorhand bepaald en bijgehouden. Telkens een nieuw significant symbool wordt toegevoerd, wordt hiertoe onmiddellijk het nieuwe aantal buren voor de 8 omliggende pixels berekend. Dit gebeurt door elke coëfficiënt die significant wordt, de informatie bij zijn 8 buren onmiddellijk bij te werken. Er zijn hiervoor 7 bits voorzien: 3 voor het aantal diagonale buren, 2 voor het aantal horizontale, en 2 voor het aantal verticale buren. Het algoritme zou vele malen trager werken wanneer die informatie niet zou worden bijgehouden, doordat bij het bepalen van de blokcontext een significantiemodel voor elke coëfficiënt binnen het blok wordt bepaald. Nieuw verfijningssymbool Tenslotte is één bit voorzien om te bepalen of een coëfficiënt reeds eerder werd verfijnd of niet. Bij aanvang van het algoritme wordt deze bit op nul geïnitialiseerd. Tijdens de eerste verfijning wordt de bit op 1 gezet, zodat de volgende keer in een van de andere modellen wordt gekeken. De nieuwe informatie die verkregen wordt tijdens het encoderen van nieuwe symbolen, wordt slechts tijdens de volgende encodeerpas in rekening gebracht. Daarom zijn twee afzonderlijke geheugens nodig. Het oude geheugenmodel waaruit de statistische informatie wordt gelezen, en een nieuw model waarin de nieuw verkregen statistische data wordt verwerkt. Op het einde van elke encodeerpas gebeurt dan een bijwerkoperatie waarin het nieuwe model in het oude wordt gekopieerd. We komen dan in totaal uit op 2 10 bits per coëfficiënt.

47 4.2. SNELHEIDSVEREISTEN Snelheidsvereisten Als uitgangspunt voor de vereiste snelheid nemen we de verwerkingssnelheid van de quadtree. We wensen dat de contextgebaseerde modelselectie het tempo van de quadtree kan volgen. Om hiervoor concreet eisen te kunnen stellen aan de module, werd de datastroom opgemeten die de quadtree genereert bij verschillende beeldframes. Eveneens werd intern het aantal geheugenbenaderingen bij het zoeken naar de blokcontext opgemeten voor die beeldframes. De resultaten van deze metingen zijn te vinden in tabel D.1 (pagina 91). 4.3 Uitwerking van het algoritme Verbeteringen en afwegingen aan het geheugenmodel De bit die gebruikt wordt voor de verfijningsmodellen kan komen te vervallen wanneer we die informatie meezenden vanuit de quadtree-trap. De verfijningslijst bevat namelijk de symbolen die verfijnd moeten worden, waarbij een grens bijhoudt welke symbolen in de huidige pas werden toegevoegd en dus nog niet verfijnd moeten worden, en welke symbolen er reeds langer inzitten. Na elke pas wordt die grens bijgewerkt door hem naar het huidige einde van de lijst te laten wijzen. Door nu een extra grens te introduceren die de oude waarde van die grens bevat, kan men aan de hand daarvan bepalen welke symbolen voor het eerst worden verfijnd: eens voorbij de grens, werden de symbolen reeds eerder verfijnd. Uit de voorgaande paragraaf kan onmiddellijk worden opgemerkt dat de berekening van informatie niet op een consistente manier gebeurt: informatie over de significantie van de buren wordt reeds op voorhand berekend, terwijl de teken-informatie van de buren niet als dusdanig wordt bijgehouden. Laten we eerst kijken naar de significantiemodellen. Het bijwerken van het geheugen vergt hier 8 geheugenaanvragen, terwijl het opvragen van informatie dan met 1 geheugenaanvraag wordt verkregen. Wanneer men daarentegen de buren-informatie zou opvragen tijdens het berekenen van een model, zou dit telkens 8 geheugenaanvragen vergen. De bijwerkactie daarentegen bestaat dan slechts uit het hoogzetten van de significantiebit, en kan dus met één geheugentoegang worden uitgevoerd. Bij de tekenmodellen geldt een gelijkaardige redenering, maar dan met 4 geheugenaanvragen of toegangen in plaats van 8 gezien de diagonale informatie hier niet gebruikt wordt. Wanneer we echter voor beide modellen hetzelfde systeem gebruiken, en we de significantieen teken-informatie in dezelfde geheugenplaats bijhouden, kunnen de geheugentoegangen en aanvragen gecombineerd worden, wat leidt tot een grote verbetering van het aantal geheugentoegangen. Het is dus in ieder geval beter om ofwel alle buren-informatie op voorhand te berekenen, of om alle buren-informatie simultaan op te vragen. Op vlak van snelheid is het hierbij duidelijk beter om te kiezen voor de eerste optie, omdat het bijwerken van de modellen slechts bij het encoderen van een nieuw symbool dat

48 4.3. UITWERKING VAN HET ALGORITME 37 symbol StatH in SignH in StatH out SignH out 1 0 x x x x Tabel 4.1: Mogelijke toestandsovergangen van StatH en SignH eveneens significant is, dient te geschieden. Het encoderen van een niet-significant symbool vergt natuurlijk geen aanpassing van de buren. Verder wordt de buren-informatie ook gebruikt in de verfijningspas. Aanvragen gebeuren dus veel frequenter dan aanpassingen. Een andere afweging is het geheugenverbruik. Wanneer we kiezen om de buren-informatie op voorhand te berekenen, dienen 2 (2+2+3) bits voor de significantie, en 2 (4 2) bits voor de tekens te worden bijgehouden (2 bits voor het teken van elke buur). Totaal geeft dit dus 2 15 bits. Door echter slim om te gaan met de informatie kunnen we dit beperken tot 2 9 bits: hierbij definiëren we andere variabelen om de informatie bij te houden: De tekenbits SignH en SignV zijn 1 bit breed en houden het totale teken bij van de horizontale en verticale buren StatH en StatV zijn 2 bit breed en kunnen volgende waarden aannemen: 0 : geen buren 1 : één buur, teken bepaald door teken-bit 2 : twee buren, zelfde teken bepaald door teken-bit 3 : twee buren, tegengesteld teken, dus neutraal In tabel 4.1 zijn de verschillende toestandsovergangen afgebeeld die kunnen optreden bij het bijwerken van de horizontale buren. De verticale component is volledig analoog. Wanneer we gebruik maken van het simultaan opvragen van de buren-informatie, dient per pixel enkel een tekenbit en een significantiebit te worden bijgehouden. Een goede verbetering op gebied van snelheid kan hierbij verkregen worden door een extra bit toe te voegen die bijhoudt of één van de horizontale of verticale buren reeds significant is geworden. Deze bit reduceert dan het aantal geheugen-aanvragen in de verfijningspas van 4 tot 1. Aangezien deze pas veruit voor het meeste symbolen zorgt is dit een verantwoorde keuze. In totaal zijn dan per pixel 2 3 bits nodig, dit is een factor 3 beter dan bij het op voorhand berekenen van de buren. De snelheid zal echter nog steeds een stuk lager liggen omdat het selecteren van een contextmodel nu steeds 8 geheugen-aanvragen vergt. Aangezien bij het bepalen van de blokcontext in WriteSymbol_Block_Significance voor elke pixel binnen dit blok de context wordt opgevraagd, zal dit ondanks de even snelle verfijningspas toch resulteren in een veel trager algoritme. Om te beslissen welke manier gebruikt dient te worden, bekijken we de effectieve encodeersnelheid die we kunnen halen met beide manieren. We maken hierbij een ruwe schatting

49 4.3. UITWERKING VAN HET ALGORITME 38 van het aantal benodigde kloktikken op basis van het aantal geheugen-aanvragen, waarbij steeds twee kloktikken voor het verwerken van een symbool wordt gerekend. In tabel D.1 van pagina 91 vinden we de volgende gemiddelde waarden: QCIF significantie- en verfijningssymbolen, tekensymbolen en bloksymbolen waarbij keer het model van een symbool wordt opgevraagd. Om geen knelpunt te vormen voor de quadtree, moet de verwerking in minder dan kloktikken te gebeuren. CIF significantie- en verfijningssymbolen, tekensymbolen en bloksymbolen waarbij keer het model van een symbool wordt opgevraagd. Om geen knelpunt te vormen voor de quadtree, moet de verwerking in minder dan kloktikken te gebeuren. Bekijken we eerst de snelste manier. Het aantal symbolen die aanpassingen aan het geheugenmodel vragen, zijn die symbolen die eveneens een tekensymbool meesturen. Voor QCIF hebben we dan = kloktikken. Dit is kleiner dan de beschikbare kloktikken, en dus in orde. Voor CIF vinden we = kloktikken. Ook dit is kleiner dan het aantal kloktikken van de quadtree. Voor de geheugenefficiëntere manier hebben we bij QCIF alleen voor het bepalen van de blokcontext al = geheugen-aanvragen, en voor CIF = geheugen-aanvragen nodig. Dit is dus duidelijk boven het aantal beschikbare kloktikken. Vandaar dat voor dit afstudeerwerk de code werd omgewerkt naar de eerste en snelste manier. Bovendien kan dit geheugen net per kwadrant in de FPGA gebufferd worden door de aanwezigheid van de twee grote M-RAM-blokken. Deze zijn geknipt voor de taak van het bijhouden van deze informatie, en zijn eveneens adresseerbaar per 9 bits. We hebben dan 64 KiB geheugenplaatsen tot onze beschikking (zie Stratix-informatiesheet [4]) zodat dit voldoende is om de huidige en nieuwe waarde van een CIF-kwadrant bij te houden (2 9 bits). In het andere M-RAM-blok kan ondertussen het volgende kwadrant worden ingeladen zodat dit reeds klaar staat Opmerkingen In het voorgaande hebben we de kopieer-actie die het bijgewerkte geheugenmodel in het oude model kopieert niet in rekening gebracht. Deze zal opnieuw extra tijd in beslag nemen. We merken eerst op dat voor dit afstudeerwerk de mogelijkheid niet open stond om wijzigingen aan het algoritme aan te brengen, daar deze dan zowel in de encoder als in de decoder moeten worden doorgevoerd, wat helaas (wegens tijdgebrek) buiten het bestek van dit afstudeerwerk valt. Wat echter een belangrijke verbetering zou betekenen zowel op vlak van geheugengebruik als op vlak van snelheid is de nieuwe buren-informatie die verkregen wordt tijdens het encoderen reeds onmiddellijk in rekening te brengen in het huidig gebruikte model. Hierdoor zijn er geen twee aparte geheugenruimtes nodig om enerzijds de nieuwe informatie in

50 4.3. UITWERKING VAN HET ALGORITME 39 te bewaren, en anderzijds niet-bijgewerkte informatie op te vragen. Dit reduceert de benodigde hoeveelheid geheugen met de helft. Verder elimineert dit ook de kopieer-actie van de bijgewerkte informatie op het einde van iedere pas, wat de snelheid en complexiteit ten goede komt. Het model zelf zal hier niet slechter door werken, integendeel, aangezien het steeds de meest accurate statistische informatie kan gebruiken. Wanneer we zouden kiezen voor de tragere versie, die slechts 2 3 bits per pixel vergt, wordt het mogelijk deze informatie in de kleinere M4K-RAM-blokjes van de Stratix-FPGA [3] op te slaan. Gezien de aard van het geheugenprobleem, waarbij steeds naast elkaar gelegen pixels worden opgevraagd, en omdat er verschillende M4K-RAM-blokjes per geheugenkwadrant dienen te worden gebruikt, kan het geheugen een factor 2.67 sneller opgevraagd worden door opeenvolgende pixels interleaved op te slaan, met een interleaveafstand van 3. Dit is geen probleem gezien per kwadrant en per bit 6 M4K-RAM-blokjes bij CIF worden gebruikt. Daardoor kunnen 3 naast elkaar gelegen pixels simultaan worden opgevraagd en geschreven, waardoor nog slechts 3 geheugen-aanvragen nodig zijn bij het bepalen van de buren-informatie. Dit zal echter nog steeds niet volstaan om het algoritme in de huidige vorm snel genoeg te maken voor de quadtree Uitwerking in SystemC De implementatie van de contextgebaseerde modelselectie in SystemC werd in zoverre uitgewerkt dat de bovenstaande verbeteringen geïmplementeerd zijn, en dat deze trap op een flowgecontroleerde manier communiceert met enerzijds de quadtree-trap en anderzijds de aritmetische encoder. Het geheugenbeheer wordt echter uitgevoerd in software, omdat het weinig zin had hier een geoptimaliseerd implementeerbaar geheugenmodel voor uit te werken, gezien zoals in de eerste opmerking werd vermeld door enkele aanpassingen in de werking van het algoritme, nog belangrijke verbeteringen mogelijk zijn. Doordat de externe communicatie wel op een correcte manier geschiedt, is het toch mogelijk het geheel te simuleren.

51 Hoofdstuk 5 Aritmetische encodering In dit hoofdstuk wordt de aritmetische encoder uitgewerkt. Dit algoritme is sterk sequentieel opgezet, waardoor een efficiënte hardware-implementatie niet eenvoudig is. Vandaar dat waar mogelijk, de code sterk werd geoptimaliseerd om toch een behoorlijke snelheid te kunnen realiseren. De hardware van deze encoder is net als de vorige twee modules opgezet als zelfstandige module. 5.1 Opzet van de software-code In de theorie hebben we reeds gezieb dat bij een aritmetische encoder/decoder compressie wordt bereikt op basis van de waarschijnlijkheid van voorkomen van symbolen. Het principe is gebaseerd op een interval dat verdeeld wordt in zones, evenveel als het aantal symbolen, en met groottes evenredig met de waarschijnlijkheid van elk symbool. De intervalgrenzen in deze encoder worden bijgehouden door 16-bit getallen waarbij het startinterval [0,65.535] is. De software is opgezet als enkele procedures die elk hun eigen taak hebben in het encoderingsproces: een eerste procedure berekent de nieuwe interne intervalgrenzen door de tellerwaarde van elk symbool in de frequentietabellen te delen door de totale tellerwaarde van alle symbolen, en vermenigvuldigt dit met het globale intervalbereik (bovengrens ondergrens). Een update-procedure zorgt voor het bijwerken van de frequentietabellen, waarbij eveneens de kans op een underflow wordt voorzien. Het getelde aantal symbolen in de frequentietabellen wordt hierbij beneden de 4096 gehouden. Dit gebeurt door bij het bereiken van 4096 geëncodeerde symbolen alle bits in de frequentietabellen naar rechts te schuiven, waardoor het aantal aanwezige symbolen weer halveert. De uitvoerprocedure tenslotte voert een symbool uit, en kijkt hierbij of er eveneens underflowbits uitgevoerd dienen te worden. 40

52 5.2. ENKELE OVERWEGINGEN VOORAF Enkele overwegingen vooraf Snelheidsvereisten Al snel bleek dat de aritmetische encoder het meest tijdskritische deel van de entropie-encoder is. De vorige twee delen komen in de buurt van encodering in ware tijd van CIF-beelden. In eerste instantie willen we dat deze encoder het in ieder geval sneller doet dan de softwareversie. Een test van het originele algoritme op een PentiumIV 2,4 GHz levert een codeersnelheid op van ongeveer 3.3 miljoen symbolen per seconde. Voor een verwerking in ware tijd van CIF-beelden zouden we ongeveer 27 miljoen symbolen per seconde moeten kunnen verwerken. Gezien het sterk sequentieel karakter en de beperkte kloksnelheid van ongeveer 100 MHz van de FPGA kunnen we al aanvoelen dat dit geen haalbare kaart zal zijn. Wanneer we uitgaan van een klok van 66 MHz (een veilige waarde, gezien de vele delingen en vermenigvuldigingen die uitgevoerd moeten worden) en van een verwerkingssnelheid die we zeker hoger willen krijgen dan 3.3 miljoen symbolen per seconde, dienen we gemiddeld gezien in minder dan 20 kloktikken een symbool te verwerken. Het uiteindelijke doel is echter om de aritmetische encoder even snel te krijgen als de rest van de encoder, doch met het huidig algoritme zal dit niet haalbaar zijn Probleemanalyse Hieronder geven we kort de belangrijkste beslissingen en overwegingen die gemaakt werden als vertrekpunt bij de uitwerking naar hardware. Uit enkele tests die werden uitgevoerd is gebleken dat eenzelfde frequentiemodel ongeveer 1.8 keer na elkaar wordt gebruikt, een model zal dus meestal nog een keer hergebruikt worden voor een volgend symbool. Het is daarom zinvol om enkel een nieuw model te laden wanneer een modelwijziging optreedt. Hierbij dient ook het oude model terug geschreven te worden. Om de communicatie met de rest van de encoder eenvoudig te houden, werd gekozen voor een aanpak waarbij de aritmetische encoder zelf controleert wanneer een ander model wordt gekozen a.d.h.v. de adres-ingang. Op deze manier zijn geen extra stuursignalen nodig om aan te geven dat van tabel verwisseld moet worden. Zowel aan de ingang als aan de uitgang is een flowcontrole voorzien. De flowcontrole aan de ingang zorgt ervoor dat de aritmetische encoder telkens wacht tot een nieuw symbool beschikbaar is aan de ingang. Per ingelezen symbool kunnen er 0, 1 of meerdere symbolen uitgevoerd worden. De encoder moet dus ook synchroniseren op de uitvoer, zodat geen uitgevoerde symbolen verloren kunnen gaan. Vooraleer men begint te encoderen, dient de encoder geïnitialiseerd te worden. Dit gebeurt met een stijgende flank op de reset-ingang. De encoder blijft in de reset-toestand tot het

53 5.3. NADERE STUDIE VAN HET ALGORITME 42 initialiseren is beëindigd en de reset-ingang weer laag wordt. Bij het initialiseren worden de frequentietabellen gereset, de interne signalen worden op hun initiële waarde gezet en de relevante uitvoersignalen worden op een laag niveau gebracht. Elk statistisch model bestaat uit 4 tabellen: frequentietabel : bevat het aantal keer dat elk symbool werd gezien. De symbolen zijn gesorteerd volgens toenemende frequentie. cumulatieve frequentietabel : houdt de som van de frequenties van alle symbolen hogerop in de tabel bij. Het eerste element in de rij bevat dus de totale som van alle symbolen, welke gebruikt wordt bij het indelen van een interval in een deelinterval. symb to index : Beeldt een symbool af op zijn index in de frequentietabel. Deze tabel is noodzakelijk om bij te houden waar elk symbool zich bevindt in de tabel, aangezien symbolen gesorteerd worden volgens stijgende frequentie. index to symb : De omgekeerde afbeelding van symb to index. Het doel van deze aanpak is dat elke berekening met een minimum aan zoekwerk kan gerealiseerd worden, wat de snelheid ten goede komt. De totale grootte van de tabel in deze implementatie bedraagt 192 bits. We komen hier onmiddellijk op terug bij de studie van het geheugenmodel. 5.3 Nadere studie van het algoritme Gedragsbeschrijving In de originele C++-code wordt de aritmetische encoder 78 maal gecreëerd, wat in hardware onnodige verspilling van plaats zou betekenen. Vandaar dat het algoritme werd omgewerkt naar één module, die aan de hand van een adres beslist met welk model intern wordt gewerkt Geheugenmodel Aangezien het wisselen van modellen frequent optreedt (hergebruik bedraagt ongeveer 1,8 keer) moet deze wisseling zo snel mogelijk gebeuren opdat dit geen kritisch pad zou vormen. Dit is een geknipte taak voor de snelle interne M512 RAM-blokjes die we ter beschikking hebben op de FPGA. Deze leveren reeds 2 klokcycli na het instellen van het adres de gevraagde waarden. Op die manier duurt een tabelverwisseling slechts 3 klokcycli (wegschrijven oud model + ophalen nieuw model). In de SystemC code wordt net als in de vorige trappen een simulatie van deze RAM-blok gebruikt die zich net zo gedraagt. Een frequentiemodel neemt in de originele code 192 bits in beslag: 16 bits per waarde, 3 waarden per tabel, 4 tabellen. Dit is nogal verspilling van geheugenruimte en zal in de volgende stappen verfijnd worden.

54 5.4. DECOMPOSITIE EN VERFIJNING 43 Time SystemC.AE.reset_done=0 SystemC.Tester.reset=0 SystemC.AE.Done_Out=0 SystemC.AE.reset_done=0 SystemC.Sink.SymbOut=0 SystemC.Sink.SymbOut_Ready=0 SystemC.Sink.SymbOut_Taken=0 SystemC.Source.SymbIn=0 SystemC.Source.SymbIn_Ready=0 SystemC.Source.SymbIn_Taken=0 SystemC.Tester.Done_In=0 SystemC.Tester.Start_Sink=1 SystemC.Tester.Start_Source=1 SystemC.clk=0 638 ns 1276 ns 1914 ns Figuur 5.1: Detail afschakelen van het leveren en/of opnemen van symbolen Testbank Wegens de complexiteit die vooral tijdens de verdere uitwerking bij het algoritme komt kijken, is het zeker geen overbodige luxe om een aparte testbank voor deze module op te zetten in SystemC. Signalen tijdens het testproces kunnen in SystemC naar een.vcd-bestand worden weggeschreven. Met een programma als gtkwave kunnen deze dan gevisualiseerd worden. Wanneer grote bestanden geëncodeerd worden, wordt de grootte van het.vcd-bestand echter vlug zeer groot. Daarom werd via de compilerdirectief TRACEFILE de mogelijkheid voorzien om het genereren van het.vcd-bestand achterwege te laten. Belangrijk bij het testen is, dat steeds een reset wordt gegenereerd waarbij de frequentiemodellen in de ramblokjes gevuld worden met initiële waarden. Dit reset-proces neemt 80 kloktikken in beslag (78 modellen te resetten + 2 cycli wachttijd voor geheugen). In figuur 5.1 is het gedrag weergegeven wanneer de encoder moet wachten op een symbool, of moet wachten tot wanneer opnieuw symbolen kunnen worden opgenomen. Duidelijk te zien is dat de encoder na het stoppen van de sourcestream nog enkele symbolen aan het uitschrijven is, en daarna wacht op een nieuw symbool. Op het einde laat de testbank aan de encoder weten dat er verder geen symbolen meer volgen door het hoog zetten van het done_in-signaal (zie figuur 5.2). De encoder zal dan het encoderingsproces afwerken door afhankelijk van zijn interne toestand de overige symbolen naar buiten te brengen. Daarna maakt hij zijn done_out-signaal hoog om aan de volgende trap te laten weten dat alle symbolen uitgevoerd zijn en voert een interne reset uit. 5.4 Decompositie en verfijning In wat volgt wordt het algoritme in stappen verder geoptimaliseerd tot een snellere en efficiëntere variant die minder geheugen in beslag neemt.

55 5.4. DECOMPOSITIE EN VERFIJNING 44 Time SystemC.AE.reset_done=0 SystemC.Tester.reset=0 SystemC.AE.Done_Out=0 SystemC.AE.reset_done=0 SystemC.Sink.SymbOut=0 SystemC.Sink.SymbOut_Ready=0 SystemC.Sink.SymbOut_Taken=0 SystemC.Source.SymbIn=0 SystemC.Source.SymbIn_Ready=0 SystemC.Source.SymbIn_Taken=0 SystemC.Tester.Done_In=0 SystemC.Tester.Start_Sink=1 SystemC.Tester.Start_Source=1 SystemC.clk= ns ps ps Figuur 5.2: Detail einde van de stream, automatische interne reset Het geheugenmodel Een eerste verfijning situeert zich rond het geheugenmodel. Oorspronkelijk waren er 192 bits per model nodig, waarbij er 3 waarden per tabel gebruikt werden: struct Model { //Variables of one model: short freq [3]; short cum_freq [3]; short index_to_symb [3]; short symb_to_index [3]; }; Het aanspreken van het geheugenmodel werd lichtjes aangepast zodat niet-veranderende velden in de tabellen overbodig werden (b.v. de laatste waarde in cum freq bevatte altijd waarde nul, de tabel index to symb werd enkel aangesproken op index 1 en 2, dit werd veranderd naar 0 en 1... ) Doordat we nu de index van de tabel beginnen bij 0 en de symbolen ook de waarden 0 en 1 aannemen, bevatten de tabellen index_to_symb en symb_to_index nu slechts 2 waarden: 0 en 1. Wanneer de index 0 naar symbool 1 wijst, zal symbool 0 zich op index 1 bevinden, m.a.w. beide afbeeldingen bevatten dezelfde inhoud en kunnen dus gecombineerd worden in 1 tabel van 2 waarden die elk 1 bit groot zijn. Verder wordt de maximale totale frequentie van alle symbolen in het algoritme zoals vroeger vermeld beneden de 4096 gehouden. Op deze manier is de benodigde databreedte in de frequentietabel en de cumulatieve frequentietabel 12 bits. Tenslotte bevat de laatste waarde van de cumulatieve frequentietabel dezelfde inhoud als de laatste waarde van de frequentietabel (omdat nog geen andere frequenties gecumuleerd zijn). De cumulatieve frequentietabel bevat dan nog slechts 1 nuttige waarde: de som van de frequenties van de symbolen 0 en 1. Het aangepast geheugenmodel gebruikt nog slechts 38 bits per model en ziet er als volgt uit:

56 5.4. DECOMPOSITIE EN VERFIJNING 45 hoog hoog mid mid 1 x 1 mid 1 y 1 mid laag x hoog mid mid hoog laag mid laag y hoog laag mid laag laag laag mid laag (a) (b) Figuur 5.3: Bijwerken van een interval bij (a) selectie van een 0, of (b) selectie van een 1 struct Model { //Variables of one model: sc_uint<12> freq [2]; sc_uint<12> sum; sc_uint< 1> SymbolIndex [2]; }; Vereenvoudigen algoritme In het gegeven algoritme worden per symbool een nieuwe bovengrens en een nieuwe ondergrens berekend van het interval door de de cumulatieve frequenties van het huidige symbool en het vorige symbool te vermenigvuldigen met de range van het interval en daarna het geheel te delen door de totale cumulatieve frequentie. In onze specifieke implementatie bevinden er zich zoals gezien slechts 2 symbolen in het interval. Bij het opsplitsen van het interval zal dus afhankelijk van het symbool enkel de bovengrens verkleinen of de ondergrens vergroten. Dit wordt geïllustreerd in figuur 5.3. Door rekening te houden met het symbool dat geëncodeerd wordt, dient slechts één vermenigvuldiging en deling worden uitgevoerd. Dit levert een grote besparing op spatiaal gebied op, zonder verlies aan snelheid Parallelliseren Het algoritme dat na voorgaande optimalisaties wordt verkregen, is een sterk sequentieel algoritme (zie figuur 5.4). Dit is ook te zien in het signaalverloop van de eerste gedragsbeschrijving waarbij telkens een symbool wordt ingelezen, en vervolgens verwerkt alvorens een nieuw symbool aan te nemen. (figuur 5.5). Opgepast, de tijdsnotie in het encoderingsproces is nog niet relevant in deze implementatie.

57 5.4. DECOMPOSITIE EN VERFIJNING 46 De volgende stap in het optimaliseren van het algoritme is dan ook het zoeken naar mogelijkheden om delen code te parallelliseren of de uitvoering deels gepijplijnd uit te voeren. Het probleem met dit soort encoderingsalgoritmen in het algemeen, is dat de verschillende blokken gebruik maken van resultaten uit de vorige blokken. De codering van elk symbool is daarnaast ook afhankelijk van het resultaat van het vorig gecodeerde symbool. Een bijkomende moeilijkheid tenslotte vormt de variabele duur van sommige blokken uit figuur 5.4. Veel stukken code kunnen m.a.w. niet geparallelliseerd worden, terwijl eenvoudig pijplijnen ook niet vanzelfsprekend is. Figuur 5.4: De verschillende stappen en hun volgorde in de eerste gedragsbeschrijving Uit de studie van de dataflow en het bekijken van de timing van de verschillende onderdelen zien we dat er toch enkele zaken kunnen geoptimaliseerd worden:

58 5.4. DECOMPOSITIE EN VERFIJNING 47 Time SystemC.Sink.SymbOut SystemC.Sink.SymbOut_Ready SystemC.Sink.SymbOut_Taken SystemC.Source.SymbIn SystemC.Source.SymbIn_Ready SystemC.Source.SymbIn_Taken SystemC.clk 5409 ns ps ps ps ps Figuur 5.5: Het signaalverloop bij het inlezen van symbolen en uitvoeren van de geëncodeerde bits in de eerste gedragsbeschrijving Het inlezen van een nieuw symbool en daarop volgend eventueel het wisselen van een model kan gebeuren in parallel met de rest van het encoderingsproces wanneer we het eerder ingelezen symbool bufferen zodat het beschikbaar blijft in het encoderingsproces. Ook het aanpassen van het frequentiemodel (= het aanpassen van de indexen in het model) is onafhankelijk van het nieuw interval dat berekend dient te worden, en kan onmiddellijk gebeuren nadat een nieuw frequentiemodel werd ingeladen. In de laatste stap van onze gedragsbeschrijving wordt gekeken of symbolen uitgevoerd kunnen worden (b.v. wanneer de meest beduidende bits gelijk zijn) en wordt het interval na het versturen van symbolen aangepast (door schuifoperaties). We kunnen deze trap dubbel uitvoeren, waarbij het nieuw interval zowel berekend wordt met wachten op het opnemen van de symbolen (neemt steeds 2 klokcycli in beslag door de flowcontrole) en daarnaast ook onmiddellijk, zonder symbolen uit te voeren, wat dus sneller gebeurd. Zodra het nieuw interval namelijk gekend is, kan de nieuwe range van het interval berekend worden zodat reeds een volgend symbool kan worden verwerkt terwijl het uitvoeren van het vorig symbool nog aan de gang is. Deze optimalisatie is duidelijk een spatiale benadering. De flowchart van het programma na het in rekening brengen van voorgaande optimalisaties is te zien in figuur 5.6. Om deze optimalisaties te kunnen realiseren, dienen we volledig af te stappen van het globaal gestuurd gedragsmodel uit de eerste gedragsbeschrijving. We creëren aparte toestandsautomaten voor elk afzonderlijk blok. Concreet hebben we een 8-tal afzonderlijke blokken: De reset-machine: zorgt voor het initialiseren van de 78 frequentiemodellen. Symbool 0 en 1 in elk model krijgen hierbij elk een frequentie 1. De close-stream-machine: nadat het encoderingsproces beëindigd is, dienen nog enkele symbolen uitgestuurd te worden met betrekking tot de interne toestand van de encoder. Nadien wordt ook een interne reset gegenereerd zodat de encoder klaar staat voor een nieuw encoderingsproces. Het inlezen van symbolen: in dit proces wordt gewacht tot een nieuw symbool beschikbaar komt. Dit symbool wordt ingelezen zodra het vorig symbool door de rest van het encoderingsproces werd gebufferd. Daarna wordt gekeken of van model gewisseld dient te worden vooraleer het nieuw symbool beschikbaar te stellen aan de rest van de encoder.

59 5.4. DECOMPOSITIE EN VERFIJNING 48 Figuur 5.6: Geoptimaliseerde en geparallelliseerde/gepijplijnde uitvoering van de aritmetische encoder Model verwisseling: Wanneer een nieuw symbool geëncodeerd moet worden met een frequentiemodel verschillend van het huidig, wordt zodra het huidig model bijgewerkt is dit

60 5.4. DECOMPOSITIE EN VERFIJNING 49 opnieuw naar het geheugen geschreven en vervangen door het nieuwe model, zodat dit klaar staat wanneer het encoderingsproces klaar is met het huidig symbool. Indexen aanpassen: Het aanpassen van het frequentiemodel gebeurt normaal gezien nadat het huidig symbool werd verwerkt. Door ook hier weer de benodigde frequentiewaarden te bufferen, kunnen de nieuwe indexen van het frequentiemodel parallel met de andere berekeningen worden bepaald. Berekenen van het nieuw interval: Deze toestandsautomaat omvat de eigenlijke berekening van de nieuwe grenzen van het interval. Er wordt eerst een vermenigvuldiging uitgevoerd van de range van het interval met de frequentie van het symbool met de kleinste frequentie. Nadien wordt dit resultaat gedeeld door de totale cumulatieve frequentie. Zo verkrijgen we de nieuwe bovengrens of ondergrens van ons interval. In de laatste stap wordt gekeken welke grens aangepast moet worden afhankelijk van het symbool dat geëncodeerd wordt (dit betekent m.a.w. het nemen van het onderste of het bovenste subinterval uit het huidige interval). Bijwerken interval: hier wordt gekeken of de boven- en ondergrenzen gelijke meestbeduidende bits hebben. Indien dit het geval is worden deze naar buiten geschoven zodat het interval weer vergroot. Er wordt ook gecontroleerd of er geen kans bestaat op een underflow in het interval. Vervolgens wordt het nieuwe bereik van het interval bepaald als het verschil van de bovengrens met de ondergrens. Uitvoeren symbolen: In dit proces gebeurt net hetzelfde als bij het bijwerken van het interval, maar de uit te voeren bits worden hier daadwerkelijk naar buiten gebracht, waarbij gewacht wordt tot een extern proces de bits opneemt. Dit proces neemt meer tijd in beslag. Het effect van het optimaliseren kunnen we zien in figuur 5.7 waarin de belangrijkste signalen weergegeven worden. In tegenstelling tot de sequentiële uitvoering (zie figuur 5.5 van pagina 47) kunnen we het inlezen en uitschrijven van symbolen niet meer als een afzonderlijk tijdsbestek waarnemen. Voor de gecoördineerde aansturing van de verschillende processen zijn ook extra controle-signalen nodig Kritisch pad Het kritisch pad in het geoptimaliseerd algoritme wordt gevormd door de berekening van het nieuwe interval, samen met het bijwerken van het interval. Dit gedeelte kan enkel sequentieel worden uitgevoerd. De vermenigvuldiging, het berekenen van de nieuwe bovenof ondergrens en het bepalen van de nieuwe range nemen elk 1 kloktik in beslag. De duur van het bijwerken van het interval is afhankelijk van de nieuwe boven- en ondergrens, maar duurt gemiddeld gezien ook 1 kloktik. De meeste tijd wordt echter gebruikt door de deler. Deze voert een deling van een 28 bits getal door een 12 bits uit. In hardware gebruiken we hiervoor een combinatorisch circuit. Dit wordt automatisch gegenereerd via de Mega-Plugin-Wizard van QuartusII (zie bijlage A.2). Bij tijdsduurtesten van de deler bleek deze op onze FPGA ongeveer 90 ns te duren, en neemt hierbij 653 van de geschikbare logische elementen in. Dit betekent dat

61 5.4. DECOMPOSITIE EN VERFIJNING 50 Time SystemC.AE.Do_Calc_Interval SystemC.AE.Do_Load_Model SystemC.AE.Do_Output_Symbols SystemC.AE.Do_Reset SystemC.AE.Done_Out SystemC.AE.Interval_WaitCycle SystemC.AE.Load_Model_Done SystemC.AE.Local_Load_Model SystemC.AE.NewSymbol_Ready SystemC.AE.New_Output SystemC.AE.Output_Done SystemC.AE.SymbolStream_Done SystemC.AE.Symbol_Buffered SystemC.AE.UpdateModel_Done SystemC.AE.bitAndFollow_Do SystemC.AE.bitAndFollow_Do_Ending SystemC.AE.bitAndFollow_Ready SystemC.AE.bitAndFollow_Symb SystemC.AE.reset_done SystemC.Sink.SymbOut SystemC.Sink.SymbOut_Ready SystemC.Sink.SymbOut_Taken SystemC.Source.ModelNr[4:0] SystemC.Source.SymbIn SystemC.Source.SymbIn_Ready SystemC.Source.SymbIn_Taken SystemC.Tester.Done_In SystemC.Tester.reset SystemC.clk $ ps ps ps 681 ns p Figuur 5.7: Signaalverloop binnen de geoptimaliseerde en geparallelliseerde aritmetische encoder met de veronderstelde kloksnelheid van 66 Mhz, we 6 kloktikken dienen te wachten op het resultaat van de deling. Daarom werd gekeken of hier nog optimalisaties mogelijk zijn. Het probleem met de deling echter is dat zowel het deeltal als de deler per symbool quasi willekeurig variëren, afhankelijk van het model waarmee gewerkt wordt (dat per symbool kan veranderen) en van het symbool dat geëncodeerd wordt. Er bestaan wel enkele snellere deel-algoritmes die gebruik maken van fixed-point notatie, en via een tabel te werk gaan. De deling wordt dan vervangen door een vermenigvuldiging met een voorberekende waarde uit de tabel. We moeten echter rekening houden met de hoeveelheid geheugen die deze algoritmes vragen voor de tabel. De eenvoudigste manier is alle deeltallen op voorhand uit te rekenen, doch dit vraagt een onaanvaardbare hoeveelheid geheugen: 2 12 getallen 28 bits per getal (in fixed point notatie), m.a.w. ongeveer 115 kbits. Een deling zou dan slechts bestaan uit één vermenigvuldiging. Meer geoptimaliseerde algoritmes nemen 2 à 3 klokcycli in beslag en verkleinen de benodigde hoeveelheid geheugen drastisch door enkel de meest beduidende bits van het deeltal in een tabel op te slaan[8]. De benodigde hoeveelheid geheugen blijft echter in de grootte-orde van enkele kilobits. Het implementeren van zo n geoptimaliseerd deler-algoritme valt buiten het kader van deze thesis. Er dient hiervoor eerst een studie te gebeuren naar de benodigde resolutie voor de fixed-point-getallen, want de beschreven algoritmes zijn uitgewerkt voor delingen die werken met een gelijk aantal bits voor deler en deeltal. Hiermee gepaard moet gecontroleerd worden of voor alle getallen de deling correct wordt afgerond. Er mag volstrekt geen

62 5.4. DECOMPOSITIE EN VERFIJNING 51 Time SystemC.AE.Do_Load_Model=0 SystemC.AE.Load_Model_Done=1 SystemC.AE.Local_Load_Model=0 SystemC.AE.NewSymbol_Ready=1 SystemC.AE.Symbol_Buffered=0 SystemC.Source.ModelNr[4:0]=$07 SystemC.Source.SymbIn=1 SystemC.Source.SymbIn_Ready=1 SystemC.Source.SymbIn_Taken=0 SystemC.clk= ps ps ps ps ps $02 $03 $01 $05 Figuur 5.8: Laden van nieuwe modellen tijdens het encodeerproces Time SystemC.AE.Do_Calc_Interval=0 SystemC.AE.Do_Load_Model=0 SystemC.AE.Do_Output_Symbols=0 SystemC.AE.Interval_WaitCycle=0 SystemC.AE.NewSymbol_Ready=1 SystemC.AE.New_Output=0 SystemC.AE.Output_Done=1 SystemC.AE.Symbol_Buffered=0 SystemC.AE.UpdateModel_Done=1 SystemC.AE.bitAndFollow_Do=0 SystemC.AE.bitAndFollow_Ready=1 SystemC.AE.bitAndFollow_Symb=1 SystemC.Sink.SymbOut=0 SystemC.Sink.SymbOut_Ready=0 SystemC.Sink.SymbOut_Taken=0 SystemC.Source.SymbIn=1 SystemC.Source.SymbIn_Ready=1 SystemC.Source.SymbIn_Taken=0 SystemC.clk= ps ps 2588 ns ps ps Figuur 5.9: Lange uitvoerprocedure na intern uitvoeren van opeenvolgende underflow-protecties afwijking optreden in het resultaat. Het verwisselen van frequentiemodel is nooit kritisch in de geparallelliseerde code. In figuur 5.8 is te zien dat het wisselen van model steeds ruim geëindigd is vooraleer een nieuw symbool kan verwerkt worden. Uit enkele simulaties was ook te zien dat het verwisselen van modellen niet kritisch blijft voor een snellere deler die slechts 2 kloktikken in beslag neemt. Wat echter wel kritisch pad kan worden, is het proces dat de symbolen uitvoert. Wanneer namelijk een grote hoeveelheid bits dienen uitgevoerd te worden voor één gecodeerd symbool, kan dit uitvoerproces langer duren dan de tijd nodig om een symbool volledig te encoderen. Dit kan bijvoorbeeld optreden na enkele underflow maatregelen. Zoals eerder vermeld werkt het algoritme met een underflowprotectie door het interval aan te passen waarbij een variabele bits_to_follow wordt verhoogd. Tijdens het eerstvolgende uitschrijfproces worden dan de extra bits to follow-bits uitgevoerd, zie figuur 5.9. Een verdere optimalisatie die zou kunnen worden doorgevoerd, bestaat erin het encoderingsproces verder onafhankelijk te maken van het uitvoerproces door het invoegen van een wachtrij voor de module die de uitvoer verzorgt. De winst die hiermee geboekt zou worden

63 5.5. MEETRESULTATEN 52 DSP LEs Max klok blokken (MHz) 2/80 958/ ,63 Tabel 5.1: Synthese-informatie van de aritmetische encoder is echter verwaarloosbaar bij een deling die reeds 6 kloktikken in beslag neemt. Bij gebruik van snellere deleralgoritmes kan hiermee echter nog een kleine winst worden geboekt in de orde van 1/3 tot 1/2 klokcyclus per symbool. Dit vergt dan echter weer extra geheugen en de complexiteit om een wachtrij te implementeren. Rekening houdend met de eigenschappen van het algoritme kunnen we echter volstaan met een wachtrij die slechts één symbool buffert, gezien een lange uitvoerprocedure nooit twee keer na elkaar kan plaatsvinden Synthetiseren Na uitvoeren van voorgaande stappen verkrijgen we synthetiseerbare code. Via het programma dc_shell 1 wordt de SystemC-code omgezet naar synthetiseerbare vhdl-code die kan ingevoegd worden in een FPGA-design. De benodigde RAM-modules worden nu gecreëerd met behulp van de MegaPlugin-Wizard van QuartusII, en worden via het topdesign gekoppeld aan de VHDL-code van de aritmetische encoder. Ook de deler is zoals werd vermeldt uitgevoerd als een externe module, die aan de signalen result, numerator en denominator wordt gekoppeld. De beschrijving van dit circuit gebeurt eveneens automatisch via de MegaPlugin-Wizard. We gebruiken hierbij geen gepijplijnde deler daar in dit algoritme hier onmogelijk voordeel mee kan worden gehaald (door de afhankelijkheden tussen invoer en resultaat). Bij het omzetten naar VHDL bleek verder dat nog enkele namen aangepast dienden te worden. Bijvoorbeeld het gebruik van de variabele range is toegelaten in SystemC, maar is een gereserveerd woord in VHDL. Het programma dc_shell vertaalt echter letterlijk. 5.5 Meetresultaten De gegevens van de gesynthetiseerde VHDL-code in QuartusII zijn te vinden in tabel. Door het goede gebruik van de vermenigvuldigers, en door het ontkoppelen van de deler van de klok, halen we een kloksnelheid die boven de 100 MHz ligt. De aritmetische encoder zal dus samen met de quadtree en de contextgebaseerde modelselectie aan een gemeenschappelijke klok van 100 MHz kunnen worden gelegd. Er dient nu echter gelet te worden op het aantal wachtcycli voor de deler. Aan 66 Mhz bedroeg dit 6 cycli (90 ns verwerkingstijd). Aan 100 MHz worden dit 9 wachtcycli. De totale versnelling van het algoritme bedraagt hierdoor slechts 15% terwijl de kloksnelheid 50% hoger ligt. De simulatie-resultaten die hier worden gegeven, zijn gebaseerd op een 66 Mhz klok. Er worden hierbij ongeveer 10, 1 kloktikken per te encoderen symbool gebruikt. Dit komt overeen 1 de dc shell die hier werd gebruikt, draait onder Linux of Unix en behoort bij Synopsys

64 5.6. MOGELIJKE VERBETERINGEN 53 met het verwerken van 6, 5 miljoen symbolen per seconde. Dit is ongeveer dubbel zo snel als de software-versie op een moderne computer. 5.6 Mogelijke verbeteringen De uitgewerkte code kan zoals besproken, eenvoudig worden versneld door een betere deler te gebruiken, en de kloksnelheid op te trekken tot 100 MHz. Simulaties met een (fictieve) geoptimaliseerde deler die slechts 2 of 3 klokcycli in beslag neemt (onafhankelijk van de kloksnelheid!) geven volgende resultaten: bij 2 klokcycli voor de deler krijgen we 6,35 kloktikken per symbool en bij 3 klokcycli ongeveer 7,28 kloktikken per symbool. De kleine extra overhead die groter wordt naarmate ons kritisch pad korter wordt is vooral te wijten aan het uitvoeren van symbolen: hoe korter het kritisch pad, hoe vaker het voorkomt dat het uitvoeren van symbolen dit pad overtreft. De invloed blijft echter globaal gezien beperkt tot 1/3 van een kloktik. Op die manier kunnen we tot (100/6, 35) = 15, 75 miljoen symbolen per seconde verwerken. Voor CIF vinden we echter uit tabel D.1 (pagina 91) dat er gemiddeld = symbolen per beeld worden uitgevoerd. Bij 30 beelden per seconde levert dit een symbolenstroom op van 25 miljoen symbolen per seconde. Bij de gehaalde 24 beelden per seconde in de quadtree-encoder hebben we nog steeds 20 miljoen symbolen per seconde. Het algoritme in de huidige vorm blijft dus mits alle optimalisaties te traag in vergelijking met de overige delen. Modellen voorladen Een mogelijke optimalisatie op gebied van compressie is, om in plaats van de modellen te resetten op een frequentie van 1 voor elk symbool, de modellen voor te laden met een bepaald frequentiemodel. Gezien de contextgebaseerde modelselectie de symbolen volgens de verwachte kansverdeling in verschillende frequentiemodellen indeelt, weet men in de meeste modellen reeds grofweg wat de statistische verdeling van de modellen zal zijn. Hierdoor verbetert de compressie-efficiëntie van de encoder, doordat onmiddellijk met een efficiënt model wordt gecodeerd. Anders moeten via de adaptieve werking reeds een reeks symbolen worden geëncodeerd vooraleer het model zich goed heeft ingesteld. Statische modellen Voor de meeste modellen kunnen we zonder veel prestatieverlies deze lijn verder doortrekken en met een statisch model gaan werken. Een model dat wordt opgeroepen wanneer bijvoorbeeld 5 buren significant zijn, zal een relatief vast kansverdelingspatroon vertonen, dat weinig afhangt van het type beeld. Op deze manier kan de codering voor die modellen een stuk worden versneld, doordat de deling veel sneller kan gebeuren: we delen dan steeds door een vast getal. Door een goede keuze van de som van de frequenties kan de deling vervangen worden door een schuifactie. Aangezien een schuifactie in hardware geen tijd in beslag neemt (de uitgangen worden gewoon verschoven doorgelust), kan de vermenigvuldiging en de deling zelfs volledig in één actie gebeuren. Gezien de indexen dan eveneens niet aangepast hoeven te worden, verkort het kritisch pad voor zulke symbolen gemiddeld tot 3 klokcycli(!). Bij deze snelheid wordt het wel sterk aangeraden een wachtrij voor het uitvoerproces te plaatsen, omdat die anders de totale prestaties te sterk zou aantasten.

65 5.6. MOGELIJKE VERBETERINGEN 54 Wanneer we dit zouden toepassen op alle modellen, rekening houdend met eventuele vertragingen, kan men tot een gemiddelde verwerkingssnelheid komen die beneden de 4 klokcycli per symbool ligt. Bij 100 MHz verkrijgen we dan een capaciteit van meer dan 25 miljoen symbolen per seconde, ruim voldoende voor verwerking van CIF-beelden in ware tijd. Gezien er enkel compressie wordt bereikt wanneer de kans dat een 1 zich voordoet verschillend is van de kans dat een 0 zich voordoet, heeft het geen zin om te proberen modellen te comprimeren die een gelijke probabiliteit vertonen voor beide symbolen. Ook dit kan nog voor een verdere versnelling zorgen. Deling uitstellen Wanneer ervoor wordt gekozen om niet alle modellen van een statisch model te voorzien, kunnen de overige modellen eventueel worden versneld door de deling te cumuleren over meerdere symbolen. Hierdoor dient de deling slecht om de 2 of meer symbolen te worden berekend. Het nadeel hiervan is de veel complexere pijplijning van het codeerproces die dan ontstaat.

66 Hoofdstuk 6 Samenvoegen van de delen Tot nu toe werden de drie delen van deze encoder als afzonderlijke modules beschouwd. De in- en uitgangen van de modules zijn hierbij voorzien van een flow-controle, zodat het algoritme correct blijft werken, ongeacht de verwerkingssnelheid van de diverse onderdelen. Het eenvoudig samenvoegen van de drie modules tot één geheel is de meest eenvoudige, maar ook de minst efficiënte oplossing. In dit hoofdstuk worden daarom enkele mogelijkheden voorgesteld om tot een efficiënter geheel te komen. Ook bij de communicatie met het DDR-SDRAM dienen enkele zaken in acht te worden genomen. Ten slotte worden nog enkele verbeteringen besproken die enkele trappen in de codering gevoelig kunnen versnellen. 6.1 Het geheel In figuur 6.1 is het blokschema van de totale opzet van de encoder te vinden. Hierin zijn duidelijk de drie hoofddelen terug te vinden. Het blok dat zich links van de quadtree-opdeling bevindt, zorgt ervoor dat de gecodeerde bits eerst worden gebufferd in een M512 RAM-blokje, waarna de gegevens per blok kunnen worden weggeschreven naar het DDR-SDRAM Communicatie met het DDR-SDRAM In het schema is te zien dat er verschillende processen met het DDR-SDRAM communiceren. Tijdens het uitwerken van de encoder, werd er steeds zorg voor gedragen dat de communicatie met het DDR-SDRAM in blokken gebeurt, wat een grote bandbreedte mogelijk maakt. DDR-SDRAM geheugen kan namelijk zeer snel gegevens in blok versturen en ontvangen, maar de toegangstijd tot het geheugen is veel trager, waardoor het zeer inefficiënt is om data element per element uit te wisselen. Het DDR-SDRAM-geheugen kan maar één communicatie per keer verzorgen. Daarom dient een soort busmaster te worden geïmplementeerd die beslist welk proces toegang krijgt tot het DDR-SDRAM. In het referentie-ontwerp (zie A.3) werd reeds een bus voorzien waarop de diverse processen kunnen worden gekoppeld. Naast de entropie-encoder is het de bedoeling dat de 55

67 6.1. HET GEHEEL 56 start bezig Quadtree opdeling - niet-significantiepas -significantiepas - verfijningspas Statistische Model selectie Aritmetische encoder Symbolen aannemen Beeld module - startdrempel - laaginformatie - voorladen Lijsten -NS-lijsten - VF-lijsten - voorladen Stapel module -voorladen - huidig en vorig kopiëren Deler Intern geheugen Uitvoer buffer Lagen buffer Lijsten buffer Stapel geheugen Quadrant Buffer 3x26 modellen DDR geheugen Gecodeerde uitvoer Beeldframe Lijsten H, V, Sign, D Figuur 6.1: Combinatie van de verschillende delen wavelettransformatie, en eventueel ook de bewegingsschatting op dezelfde FPGA worden geprogrammeerd. Een goed opgezette busmaster is dus van het grootste belang om de verschillende processen zonder al te grote vertragingen met het DDR-SDRAM te laten communiceren. In de entropie-encoder is overal een een zekere marge aanwezig. Hierdoor zullen vertragingen bij het communiceren met het DDR-SDRAM in normale omstandigheden geen invloed hebben op de snelheid van het encodeerproces. De datablokken worden steeds voorgeladen, terwijl de rest van de entropie-encoder gewoon verder blijft werken. De databus naar het DDR-SDRAM is 128 bits breed, en kan in blokmode per kloktik aan 133 MHz nieuwe data versturen (of ontvangen wanneer het proces data verstuurd). In deze encoder werken we overal met een klok van 100 MHz. Om te zorgen dat dit niet tot conflicten leidt, maken we dankbaar gebruik van het twee-poorts-geheugen dat met twee aparte klokken kan worden aangestuurd. Omdat tijdens het voorladen van een blok, nooit data wordt gelezen of geschreven door de entropie-encoder, kunnen geen conflicten optreden. In het beeldgeheugen wordt de data bijvoorbeeld per kwadrant gebufferd. De coëfficiënten worden door de wavelettransformatie met een resolutie van 18 bits bewaard. Het DDR-SDRAM kan dus per kloktik ongeveer 7 coëfficiënten (128/18) versturen. De entropie-encoder verwerkt deze data gemiddeld aan een tempo van iets meer dan 3 kloktikken per coëfficiënt. Globaal gezien duurt de verwerking van een beeldkwadrant dus 133/ keer langer dan het bufferen ervan. Hier is dus een grote marge aanwezig.

68 6.1. HET GEHEEL 57 Een ander voorbeeld zijn de lijsten. Deze worden gebufferd in M512 RAM-blokken. Elk element in de lijst bevat een adres van een coëfficiënt binnen het beschouwde kwadrant. Voor CIF moeten er dan 15 bits ( /4 = < 2 15 ) per element worden voorzien. We lijnen dit af op de voorziene databreedte van 16 bits. Op die manier kunnen telkens 32 waarden worden gebufferd. Rekening houdend met de 128-bits brede databus van het DDR-SDRAM, kan een M512 RAM-blok in 4 kloktikken worden geladen. Door de kleine hoeveelheid data, speelt echter toegangstijd naar het DDR-SDRAM nu een belangrijke rol. We onderstellen dat het DDR-SDRAM ongeveer 5 kloktikken aan 133 MHz nodig heeft, vooraleer de eerste data wordt aangeboden (dit is een realistische waarde voor DDR-SDRAM geheugen). In totaal zijn dan 9 kloktikken nodig om een M512 RAM-blok te laden. De entropie-encoder kan zoals we gezien hebben de elementen per 2 kloktikken aan 100 MHz verwerken. Het inladen of wegschrijven gebeurt dan nog steeds een factor 2 32/9 (133/100) > 9 sneller dan het verwerken. De busmaster dient ervoor te zorgen dat elk proces op tijd aan bod komt, waarbij de processen die kleinere hoeveelheden data bufferen zoals bijvoorbeeld de lijstenstructuur voorrang krijgen op de processen die grote hoeveelheden data bufferen (zoals het beeldgeheugen). Het inladen van grote hoeveelheden data kan eventueel ook in verschillende fasen gebeuren, waartussen kleine geheugentransfers voor andere processen kunnen worden verzorgd Geheugengebruik We bekijken nu de totale vereisten aan intern geheugen voor de ontwikkelde encoder. De FPGA EP1S25F1020 die hier gebruikt wordt, beschikt zoals in bijlage A is te vinden, over 224 M512 RAM-blokken, 138 M4K RAM-blokken en 2 M-RAM-blokken. We bekijken eerst de geheugenvereisten voor de afzonderlijke blokken. Het quadtree-algoritme De niet-significantielijsten en de verfijningslijsten gebruiken M512 RAM-blokken om de data te bufferen. Voor elk van de drie waveletsubbanden worden vaste buffers voorzien, wat communicatie met het DDR-SDRAM uitspaart. Een andere mogelijkheid zou zijn om geheugen te voorzien voor het kwadrant waarmee gewerkt wordt, en het volgende kwadrant te gaan voorladen. Gezien de geringe geheugenvereisten en de extra complexiteit is echter niet voor deze optie gekozen. Per lijst zijn 2 M512 RAM-blokken nodig: één die wordt verwerkt en een ander die wordt voorgeladen. Voor de niet-significantielijsten wordt, zoals we gezien hebben met 2 lijsten gewerkt. In totaal zijn er dan per kwadrant (2 + 1) 2 M512 RAM-blokken nodig. Voor de drie kwadranten komt dit dan op 18 M512 RAM-blokken. De beeldbuffering werd reeds besproken in 3.3. Door de grotere geheugenvereisten, wordt hier per kwadrant gebufferd. In totaal zijn er dan 2 18 M4K RAM-blokken nodig. In 3.3 is ook te vinden dat de stapel voor elke recursieve oproep 63 bits worden gebruikt. Per opsplitsing worden 4 instanties gecreëerd. Echter de eerste instantie wordt bij diepte-eerst recursie telkens onmiddellijk weer van de stapel gehaald. De maximale vertakkingsdiepte bedraagt 7 niveaus. In totaal kunnen er zich dus 7 3 instanties van 63 bits op de stapel bevinden. We gebruiken hiervoor M512 RAM-blokken die we configureren als 8 64 bits. In totaal zijn er dan 3 M512 RAM-blokken nodig voor de stapel.

69 6.1. HET GEHEEL 58 geheugenblok gebruikt/beschikbaar M-RAM 2/2 M4K RAM 36/138 M512 RAM 28/224 Tabel 6.1: Geheugenvereisten van het quadtree-algoritme De contextgebaseerde modelselectie Voor deze trap zijn zoals besproken de 2 M-RAM-blokken van de FPGA nodig om de benodigde data te kunnen bufferen. De aritmetische encoder De hoeveelheid geheugen per model werd gereduceerd tot 38 bits. Er zijn in totaal 3 26 modellen aanwezig. Een mogelijke configuratie met M512 RAM-blokken is dan als volgt: 6 M512 RAM-blokken worden geconfigureerd als bits. Samen vormen deze reeds 96 mogelijke modellen van 36 bits. Een zevende M512 RAM-blok wordt dan tenslotte ingezet voor de laatste 2 bits in een configuratie. De totale geheugenvereisten zijn weergegeven in tabel Optimalisaties Het eenvoudig aan elkaar koppelen van de drie delen, zal leiden tot een grote vermindering van de totale prestaties. De oorzaak hiervan is te vinden in het onregelmatig verwerkingsritme van de eerste twee trappen. De quadtree-opdeling voert eerst controleberekeningen uit waarbij geen symbolen worden uitgevoerd. Nadien wordt een blokselectiesymbool uitgevoerd naar de contextgebaseerde modelselectie, eventueel gevolgd door een reeks coëfficiënten van een minimum blok. Hierna volgt dan de verwerking van de coëfficiënten uit de verfijningslijst. Wanneer de contextgebaseerde modelselectie een symbool binnenkrijgt, start deze met het doorzoeken van het blok om zo de blokcontext te bepalen. Intussen kunnen geen andere symbolen worden verwerkt, daar enerzijds de symbolen in de correcte volgorde uitgevoerd dienen te worden, en anderzijds de beperkte geheugentoegangen dit niet toelaten. De verwerkingssnelheid van de quadtree-opdeling en de contextgebaseerde modelselectie ligt dus totaal verschillend. Dit zou bij een rechtstreekse koppeling de prestaties met de helft doen dalen. Een oplossing hiervoor is om een wachtrij te plaatsen tussen beide delen. Een ruwe berekening van de omvang van zo n wachtrij leert echter dat dit niet zo praktisch is. Per symbool wordt de significantie, de positie binnen het kwadrant en eventueel het teken uitgevoerd (of een Ref Deltabit bij de verfijningssymbolen). De blokselectie vereist ook nog de grootte van het blok. Voor elk symbool is dan minimum 16 bits nodig, en meestal 17 bits. Tijdens elke eerste opdeling in de boom, wordt een volledig CIF-kwadrant gecontroleerd. Ook de contextgebaseerde modelselectie dient dan een volledig blok af te lopen om de blokcontext te bepalen. Dit gebeurt aan één element per kloktik (meerdere aanvragen per kloktik zijn niet mogelijk door de vereiste configuratie van de M-RAM-blokken). Indien de quadtree-opdeling aan het volle tempo moet kunnen doorwerken, zal deze in het slechtste geval onmiddellijk elementen willen uitvoeren. Dit gebeurt aan 1 symbool per 2 kloktikken. In totaal moeten dan tijdens de controle van de contextgebaseerde modelselectie /2 symbolen worden gebufferd. In de praktijk zal de quadtree opdeling echter ook nog

70 6.2. MOGELIJKE VERBETERINGEN AAN DE CODEC 59 Opcode Operanden Betekenis 000 KwadrantNr - lrows - lcols Aanpassen gebruikte kwadrant en beeldgrenzen 001 X - Y - W - H - Symb Bepalen van een blokcontext 010 X - Y - W - H - doorlopen min-sized blok in significantiepas Symb+T - Symb+T... tot einde gegeven blok 011 X - Y - Symb+T Eén symbool coderen 100 Symb Verfijningspas met Ref Delta waar 101 X - Y - Symb Verfijningspas met Ref Delta niet waar 110 / Einde huidige threshold 111 Functiebit Herstart/Beëindig encodeerproces Tabel 6.2: Voorbeeld mogelijke opcode-structuur controles uitvoeren. Door de optimalisaties zijn die controles gereduceerd met meer dan 75% zoals we gezien hebben. Ruwweg dienen dan een kleine symbolen te worden gebufferd. Aan 16 bits per symbool, is dit enorm geheugenverslindend. De hoeveelheid geheugen kan echter drastisch beperkt worden door een kleine hoeveelheid intelligentie in te bouwen in de wachtrij. We kunnen hiervoor een opcode-operand structuur inbouwen, waarbij we een opcode van bijvoorbeeld 3 bits gebruiken. Door een goed gekozen structuur kan zo het gemiddeld aantal bits per symbool sterk worden beperkt. Bijvoorbeeld bij het selecteren van het contextmodel bij verfijningssymbolen, waarbij de variabele Ref_Delta waar is, zijn geen positiebits nodig (zie 4.3.1). Hoe verder men afdaalt in het beeld, hoe meer verfijningssymbolen er worden gecodeerd waarbij de variabele Ref Delta waar is. Deze bits kunnen dan samen met de opcode in 4 bits worden bijgehouden, wat reeds een grote besparing oplevert aan geheugen. Voor de andere symbolen gelden gelijkaardige overwegingen. Een mogelijke opcode-operand-structuur is weergegeven in tabel 6.2. De complexiteit van het geheel wordt hiermee echter weer een stuk groter. Een andere manier om de beide delen beter te laten samenwerken, is om de controle van de blokcontext te laten gebeuren door de quadtree-opdeling tijdens zijn controlelussen. Dit vergt echter gedeelde geheugenbenaderingen, en extra controles. De contextgebaseerde modelselectie moet dan bovendien worden stilgelegd tijdens deze controles, wat toch de prestaties zal drukken. Een goede oplossing voor dit probleem is dus niet zo eenvoudig. Een ander punt is de connectie tussen de contextgebaseerde modelselectie en de aritmetische encoder. De aritmetische encoder heeft gelukkig een vrij constant verwerkingsritme zoals we hebben gezien. Door de voorgestelde verbeteringen in 5.6 is deze bovendien zonder veel problemen snel genoeg te krijgen t.o.v. de rest van het codeerproces. Het toevoegen van een kleine buffer zal hier reeds voldoende zijn om de prestaties te behouden. 6.2 Mogelijke verbeteringen aan de codec Uit de voorgaande bespreking is gebleken dat een en ander niet eenvoudig kan worden gecombineerd. We bekijken daarom tot slot nog enkele mogelijke aanpassingen aan de codec die voor

71 6.2. MOGELIJKE VERBETERINGEN AAN DE CODEC 60 betere en eenvoudiger haalbare prestaties kunnen zorgen. Een eerste punt is het bepalen van het startdrempelniveau. Dit dient nu steeds te gebeuren tijdens de aanvang van elk resolutieniveau. De benodigde tijd hiervoor is weliswaar klein in vergelijking met het gehele encoderingsproces, maar een efficiëntere methode kan hiervoor worden gebruikt. Gezien de wavelettransformatie de coëfficiënten één voor één berekent, vormt het geen extra kost om meteen ook de maximale waarde van de berekende coëfficiënten bij te houden. Naast de (kleine) snelheidswinst voor de quadtree ( 2%), betekent dit ook het wegvallen van een hoeveelheid hardware-logica, en een vereenvoudigde opzet. We berekenen even de hoeveelheid tijd die de contextgebaseerde modelselectie spendeert aan de bloksymbolen (dit zijn dus de symbolen die door de decoder worden gebruikt om de boom te kunnen reconstrueren). Voor CIF-beelden vinden we in tabel D.1 de volgende gemiddelde waarden: significantie en verfijningssymbolen, tekensymbolen, bloksymbolen en geheugen-aanvragen voor de blokcontext-selectie. In hebben we reeds berekend dat het coderen hiervan kloktikken in beslag neemt. ( ) kloktikken worden hiervoor gebruikt voor de blokselectie, of 43% van de encodeertijd. In verhouding maken de bloksymbolen slechts 7% van de totale hoeveelheid te coderen symbolen uit. Eventueel zou er dus naar een snellere manier kunnen worden gezocht die iets minder efficiënt is. Een mogelijkheid is bijvoorbeeld om het beeld te verdelen in een aantal blokken, en per blok een teller bij te houden die het aantal significante coëfficiënten binnen dit blok bevat. Aan de hand van dit aantal kan dan een model worden geselecteerd. Het aflopen van alle coëfficiënten wordt dan overbodig. Door de blokken niet te klein te kiezen, kan de benodigde hoeveelheid geheugen beperkt blijven. In dit algoritme wordt de boomstructuur in elke laag opnieuw verstuurd. Een verbetering zou erin kunnen bestaan om te vertrekken van de boomstructuur uit de vorige laag, en enkel de nieuwe takken te versturen. Hierdoor zal ook de overhead van 7% sterk kunnen worden verminderd. Vooral tijdens de lagere lagen wordt veel overbodige informatie verstuurd. Anderzijds maakt dit het algoritme weer ingewikkelder. De decoder en de encoder moeten ergens een datastructuur van de boom bijhouden. De encoder dient enkel veranderingen in de boom te versturen, en de decoder moet aan de hand van de binnengekregen bloksymbolen kunnen beslissen naar waar in de boom moet worden uitgeweken, en eventueel zijn takken aanpassen. Toch is dit een zeer zinvolle aanpassing voor het gegeven algoritme. Door de kleinere overhead, wordt het belang van een uitgebreide codering van de bloksymbolen sterk gereduceerd. Hierdoor is het geen probleem om uit te wijken naar een snellere maar minder efficiënte manier om hun contextmodel te bepalen. De hoeveelheid te controleren geheugen voor de blokcontext-selectie zal sowieso sterk verminderen.

72 Hoofdstuk 7 Het eiland-algoritme In dit hoofdstuk wordt een alternatief algoritme voorgesteld voor het quadtree-algoritme. Dit algoritme werd zelf ontworpen, en vormt een uitbreiding op de gegeven opdracht. Er wordt met dit algoritme gepoogd de nadelen van het quadtree-algoritme op te lossen die aan het licht kwamen tijdens het tot stand komen van deze thesis. Hoewel er hierbij verschillende mogelijkheden werden voorgesteld en geïmplementeerd om het quadtree-algoritme tot een goed werkend geheel te brengen, zijn er enkele zaken die eenvoudiger en beter kunnen. Dit vereist een andere aanpak van het probleem in de vorm van een nieuw algoritme. Het uitgangspunt hierbij was een algoritme dat de positieve punten van het quadtree-algoritme blijft behouden, maar komaf maakt met de nadelen. De voornaamste nadelen worden hieronder nog even kort vermeld: Een belangrijk nadeel zit zoals we gezien hebben in de theorie reeds in de werking op zich van de quadtree-opdeling. De voorspelling van de buren wordt uitgelijnd op de grenzen van een minimum blok. Voorspellingen treden dus op in de vorm van volledige blokken, ook al ligt de significante coëfficiënt helemaal in de hoek van zo n blok. In figuur 7.1 is dit geïlustreerd op een afbeelding van Lena waarbij de significantie van de pixels in de bovenste bitlaag wordt beschouwd (zie ook figuur 1.3 op pagina 4). Een volgend nadeel is de overhead aan symbolen bij iedere stap in de vorm van bloksymbolen, waarmee de decoder de boom kan reconstrueren. Deze wordt wel enigzins gereduceerd door de gelimiteerde opdeling, maar blijft niettemin niet verwaarloosbaar. In tabel D.1 vinden we dat bij QCIF gemiddeld op een totaal van te coderen symbolen, er afkomstig zijn van bloksymbolen, wat betekent dat de bloksymbolen toch ongeveer 7,3% (6,8% bij CIF) van de totaliteit uitmaken. De betrekkelijke complexiteit (nood aan een stapel voor de recursieve opdeling) en de vele controleberekeningen zorgen ervoor dat een efficiënte hardware-implementatie niet eenvoudig is. Hoewel in deze thesis door het toepassen van verschillende optimalisaties toch een betrekkelijk goed presterende quadtree-opdeling werd verkregen, zorgt de sterk samenhangende structuur die dit met zich meebrengt ervoor dat de code een moeilijk te begrijpen geheel vormt. 61

73 7.1. DE OPZET 62 Figuur 7.1: Voorspelling van niet-significante pixels in het quadtree-algoritme De slechte afstemming van de contextgebaseerde modelselectie met het quadtree-algoritme, zorgt ervoor dat het ingewikkeld wordt om een goede efficiënte samenwerking te realiseren. In hoofdstuk 6 werden enkele mogelijke oplossingen voorgesteld, maar deze vereisen o.a. weer bijkomende codeer/decodeer logica. Tenslotte zien we dat meer dan een 40% van de tijd van de contextgebaseerde modelselectie wordt gebruikt voor het bepalen van de blokcontext van de quadtree-boom. En dat terwijl deze controles in verhouding slechts 7,3% van de symbolen uitmaken. 7.1 De opzet Net als bij de quadtree gaan we rekening houden met de eigenschap dat significante pixels in (waveletgetransformeerde) beelden zich grotendeels in clusters manifesteren. We trekken deze eigenschap verder door om een algoritme op te zetten dat zich volledig toelegt op het encoderen van deze eilandjes. Hierbij wordt volledig afgestapt van het principe om via een boom de nietsignificante velden te detecteren, en dan de significante en niet-significante velden te verwerken. Er wordt in feite te veel informatie verstuurd, omdat zowel de posities van de niet-significante als van de significante velden worden gecodeerd, terwijl door het uitsluitingsprincipe het voldoende is slechts één van beide te coderen. In dit algoritme gaan we daarentegen enkel nieuwe significante coëfficiënten opsporen. Rond die significante coëfficiënten wordt een eiland gebouwd. De niet-significante coëfficiënten die hierbij worden ontdekt, zijn coëfficiënten die een grote kans hebben om significant te worden tijdens een van de volgende passen. Significante coëfficiënten die dicht genoeg bij elkaar liggen, worden als één eiland beschouwd. De kracht van het algoritme zit in een slimme opzet waardoor de posities van de coëfficiënten binnen de eilanden zonder overhead kunnen worden gecodeerd. In figuur 7.2 wordt hetzelfde beeld van Lena beschouwd als in figuur 7.1, maar nu worden de kanshebbende niet-significante pixels geselecteerd m.b.v. het eiland-algoritme.

74 7.2. WERKING VAN HET ALGORITME 63 Figuur 7.2: Voorspelling van niet-significante pixels in het eiland-algoritme 7.2 Werking van het algoritme Het basisprincipe van de quadtree-trap blijft behouden: het beeld wordt laag per laag geanalyseerd waarbij we op zoek gaan naar significant geworden co fficiënten, die in latere passen worden verfijnd. Het gebruik van drie passen hierbij was een goed idee, en blijft daarom behouden. Deze drie passen zijn de niet-significantiepas, de significantiepas en de verfijningspas. Als geheugenstructuur wordt eveneens gebruik gemaakt van een niet-significantielijst en een verfijningslijst, die efficiënt kunnen worden geïmplementeerd op de manier die in dit afstudeerwerk werd gehanteerd (zie sectie 3.2.1). Daarnaast wordt nu ook een extra map geïntroduceerd: een bitmap van het beeld die bij het begin van het algoritme geïnitialiseerd wordt op 0. Zowel de encoder als de decoder hebben deze map. Gezien het feit dat deze map slechts 1 bit per pixel nodig heeft, kan deze volledig in het intern geheugen van de FPGA worden bijgehouden, wat de aansturing eenvoudig maakt. Gedurende de codering/decodering worden de coëfficiënten die in de niet-significantielijst of in de verfijningslijst worden geplaatst, eveneens op 1 gezet in deze map. We spreken voor de eenvoud verder van pixels i.p.v. coëfficiënten, daar dit intuïtief beter verstaanbaar is Een voorbeeld We leggen het principe van het algoritme uit aan de hand van een voorbeeld. In sectie is een beschrijving in pseudo-code van het algoritme te vinden. In het voorbeeld maken we voor de duidelijkheid gebruik van een beeld van 6 5 pixels. Het algoritme vertrekt vanaf het startdrempel-niveau dat vooraf werd bepaald (dit kan zoals besproken gebeuren tijdens de wavelettransformatie). In figuur 7.3(a) is de uitgangssituatie te zien. De niet-significantielijst en de verfijningslijst zijn leeg, en de bitmap bevat enkel nullen. In het beeld zijn twee pixels significant.

75 7.2. WERKING VAN HET ALGORITME 64 Hoogste bitlaag bitmap lijsten a) NS: leeg VF: leeg b) NS: VF: c) NS: VF: Figuur 7.3: Eerste pas van het eiland-algoritme De significantiepas start nu met het beeld te doorlopen van links naar rechts en van boven naar onder (d.i. scanlijn-volgorde). Wanneer men een significante pixel tegenkomt, worden de positie en het teken van deze pixel naar de entropie-encoder verstuurd, terwijl de pixel lokaal wordt toegevoegd aan de verfijningslijst. Hierna wordt eveneens de significantie van de omliggende pixels meegedeeld aan de decoder, te beginnen met de linkerbovenpixel, en in scanlijnvolgorde doorlopen (BL-B-BR-L-R-OL-O-OR). Tegelijkertijd worden de pixels toegevoegd aan één van de lijsten en wordt de overeenkomstige bit in de bitmap op 1 gezet. De reeds gecontroleerde pixels (3 pixels boven en linkerbuur) dienen hierbij niet opnieuw te worden verstuurd, daar de decoder reeds de significantie van die pixels kent zodat maximaal nog 4 significantiewaarden dienen te worden verstuurd om alle 8 de buren te kennen. De situatie na het coderen van de eerste significante pixel is te zien in figuur 7.3(b). Op deze manier wordt het volledige beeld afgelopen. Het eindresultaat van de eerste pas is te zien in figuur 7.3(c). Volgende pas Een mogelijke uitgangssituatie is weergegeven in figuur 7.4(a). We starten nu met het verwerken van de niet-significantielijst. De significantie van elke pixel in de niet-significantielijst wordt nu verstuurd naar de entropieencoder. Pixel 4 is de eerste pixel die significant is geworden. Identiek hetzelfde principe als

76 7.2. WERKING VAN HET ALGORITME 65 Één na hoogste bitlaag bitmap lijsten a) NS: VF: b) NS: VF: c) NS: VF: Figuur 7.4: Tweede pas van het eiland-algoritme bij de significantiepas wordt nu toegepast. De pixel wordt uit de niet-significantielijst verwijderd en toegevoegd aan de verfijningslijst zoals te zien is in figuur 7.4(b). Tegelijkertijd worden de 8 omliggende buren indien deze dit nog niet waren als significant gemarkeerd, en de benodigde informatie wordt verstuurd naar de entropie-encoder. Hierbij dienen enkel de buren die niet reeds in één van de twee lijsten staan, of die m.a.w. een nul staan hebben in de bitmap effectief te worden verstuurd. In het voorbeeld zijn alle omliggende pixels reeds gemarkeerd, zodat verder niets wordt verstuurd. Hierna vervolgt het algoritme weer met het versturen van bit 0 voor pixel 5. Pixel 9 is weer een significante pixel, waarbij buurpixels 2 en 8 worden toegevoegd aan de niet-significantielijst en verstuurd naar de entropie-encoder (zie figuur 7.5(a)). Dit gaat zo verder tot de volledige nietsignificantielijst werd doorlopen. We komen dan in de situatie van figuur 7.5(b). Nu is het weer de beurt aan de significantiepas om nieuwe significant geworden pixels te detecteren. Hierbij doorlopen we het beeld weer in scanlijnvolgorde, waarbij enkel de pixels gecontroleerd moeten worden die een nul hebben in de bitmap. Pixel 24 is de enige pixel die significant wordt, waarbij de positie van de pixel wordt verstuurd, evenals de significantie van de buren. Weerom dienen wegens de scanlijnvolgorde de 3 bovenburen en de linkerbuur niet te worden beschouwd. Daarnaast zijn ook de buren die reeds een 1 hebben in de bitmap gekend bij de decoder. In ons voorbeeld moet dus enkel nog de significantie van pixel 30 te worden verstuurd.

77 7.2. WERKING VAN HET ALGORITME 66 Één na hoogste bitlaag bitmap lijsten a) NS: VF: b) NS: VF: b) NS: VF: Figuur 7.5: Vervolg tweede pas van het eiland-algoritme Uitvloeiend eiland In het gegeven voorbeeld kwam het nooit voor dat de onderzochte buren van een significant geworden pixel eveneens significant waren. Wanneer dit zich voordoet, dient de significant geworden buur op zich ook weer te worden beschouwd. Dit proces zet zich verder tot wanneer enkel niet significante buren worden gedetecteerd. We krijgen als het ware eilanden in de bitmap die uitvloeien over de significante pixels. Om het uitvloeiingsproces te implementeren roepen we de hulp in van een extra lijst: de hulplijst H, die zowel bij de encoder als de decoder aanwezig is. Elke buur die significant wordt bevonden, wordt enerzijds toegevoegd aan de verfijningslijst en anderzijds aan de hulplijst. Nadat de niet-significantielijst werd verwerkt, of wanneer de significantiepas is afgelopen, wordt de hulplijst verwerkt indien deze niet leeg is. Hierbij kunnen weer nieuwe pixels significant worden bij het beschouwen van de buren van de pixels in deze lijst. Deze worden dan op hun beurt toegevoegd achteraan de hulplijst. Dit proces zet zich voort tot de hulplijst leeg is. Een voorbeeld is te vinden in figuren 7.6 en 7.7. We vertrekken hierbij van de eerste pas uit figuur 7.3. Bij het doorlopen van de niet-significantielijst, komen we aan pixel 9 die significant geworden is. De enige twee onbekende buren hiervan zijn pixel 2 en 8. Pixel 8 is hierbij opnieuw een nieuwe significante pixel, en wordt dus toegevoegd aan de hulplijst en aan de verfijningslijst. Pixel 15 is de volgende significante pixel, doch bezit geen onbekende buren, zodat enkel een significantiebit en een teken wordt geëncodeerd, terwijl de pixel in de verfijningslijst wordt gestopt.

78 7.2. WERKING VAN HET ALGORITME 67 Één na hoogste bitlaag bitmap lijsten a) NS: VF: H: b) NS: VF: H: c) NS: VF: H: 8 Figuur 7.6: Uitvloeien van een eiland Nadat alle pixels uit de niet-significantielijst werden verwerkt, worden pixels 8 en 13 uit de H-lijst beschouwd. Deze bevatten geen nieuwe significante buren, waardoor de significantiepas eindigt. Ten slotte is het de beurt aan de verfijningspas. Deze is volledig analoog aan de verfijningspas uit het quadtree-algoritme (zie hoofdstuk op pagina 11). Opnieuw worden enkel de pixels die reeds significant waren vóór de huidige pas verwerkt. Opmerking Het belang om de niet-significantiepas vóór de significantiepas uit te voeren, zit nu niet zozeer meer in een betere signaalruis-verhouding bij lagere bitrates (deze is minimaal), maar wel in het uitvloeiingsprincipe van eilanden in lagere bitlagen. Wanneer bij een volgend drempelniveau eerst de significantiepas zou worden uitgevoerd, zal deze nieuwe significante pixels die vlak bij een bestaand eiland zijn gelegen, als nieuwe eilanden erkennen. Hierdoor dient opnieuw positie-informatie te worden verstuurd. De niet-significantiepas daarentegen codeert deze pixels als uitbreiding van het huidig eiland, zonder overhead.

79 7.2. WERKING VAN HET ALGORITME 68 Één na hoogste bitlaag bitmap lijsten a) NS: VF: H: 8 13 b) NS: VF: H: 13 c) NS: VF: H: Figuur 7.7: Vervolg uitvloeien van een eiland Pseudo-code van de basisversie van het eiland-algoritme Hieronder geven we de pseudo-code voor de basisversie van de encoder bij gegeven drempelniveau t (threshold). De code voor de decoder is volledig analoog op te stellen. Deze interpreteert de symbolen ontvangen van de encoder, en gebruikt deze om zijn eigen lijsten en bitmap te laten overeen komen met die van de encoder. Op deze manier weet de decoder steeds welke buurpixels de encoder zal versturen. Omdat in tegenstelling met de quadtree in de significantiepas enkel de relevante significantieinformatie wordt verzonden, dient nog een speciaal symbool te worden voorzien om de decoder te vertellen dat de significantiepas is afgelopen. Op die manier weet deze dat het de beurt is aan de volgende pas (de H-pas of de verfijningspas indien H leeg is). Gezien de encoder een adres verwacht, kan hiervoor worden volstaan met een adres buiten het bereik van het beeld te verzenden. Bij CIF zijn de waveletsubbanden maximaal bits, waardoor 15 adresbits nodig zijn om een adres te verzenden (2 14 < ( = 25344) 2 15 ). Wanneer we de meest beduidende adresbits eerst verzenden (Big Endian) volstaat het om 3 enen te verzenden, gezien adres =

80 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME Procedure Eiland-Niet-Significantiepas() Voor elke ns i in de NS-lijst, doorlopen van begin tot einde doe: Voor elke buur ns j, beginnende linksboven, doorlopen in scanlijnvolgorde: indien b j = 0: Indien ns j 2 t, voeg ns j achteraan toe aan de H-lijst en aan de verfijningslijst Anders: voeg ns j toe aan de niet-significantielijst b j = 1 Indien alle pixels doorlopen: Als H niet leeg, doe eerst: Eiland-Hpas() Eiland-Significantiepas() 2. Procedure Eiland-Significantiepas() Voor elke pixel p i in het beeld, doorlopen in scanlijnvolgorde doe: Als p i 2 t en de overeenkomstige bit in de bitmap b i = 0: Verstuur positie van de pixel naar entropie-encoder b i = 1 Voor elke buur p j, beginnende met rechterbuur, doorlopen in scanlijnvolgorde indien b j = 0: Indien p j 2 t, voeg p j deze toe aan de H-lijst en aan de verfijningslijst Anders: voeg p j toe aan de niet-significantielijst b j = 1 Anders: Doe niets Indien alle pixels doorlopen: Verzend terminatiecode (b.v. 111 ) Als H niet leeg, doe eerst: Eiland-Hpas() Eiland-Verfijningspas() 3. Eiland-Hpas() Voor elke h i in H, zolang H niet leeg doe: Voor elke buur h j, beginnende linksboven doorlopen in scanlijnvolgorde: indien b j = 0: Indien h j 2 t, voeg h j achteraan toe aan de H-lijst en aan de verfijningslijst Anders: voeg h j toe aan de niet-significantielijst b j = 1 4. Procedure Eiland-Verfijningspas() Voor elke coëfficiënt v f i die in vroegere codeerpassen in de verfijningslijst werd geschreven doe: Stuur de bit corresponderende met de huidige bitlaag uit v f i naar entropie-encoder 7.3 Vergelijking met het Quadtree-algoritme Zoals uit de pseudocode reeds blijkt, is het algoritme overzichtelijker opgezet dan het quadtreealgoritme. De verschillende procedures vertonen ook onderling enige gelijkenis. Het ontbreken van recursieve aanroepen en uitgebreide controlestructuren zorgen er verder voor dat het algoritme zonder veel problemen in hardware kan worden geïmplementeerd. Door het scanlijnprincipe wordt het geheugen bovendien veel gestroomlijnder aangesproken.

81 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME Figuur 7.8: Slechts denkbare scenario voor het basis-eiland-algoritme Codeer-efficiëntie In het quadtree-algoritme zit men met een symbool-overhead van in totaal 7% voor het opbouwen van de boom in significantiepas. Dit opbouwen dient voor elk drempelniveau opnieuw te gebeuren. Hoewel de quadtree hiërarchisch te werk gaat bij het bepalen van de positie van de significante minimum blokken, kan men ook intuïtief inzien dat voor het bepalen van een minimum blok een grote overhead aan bloksymbolen wordt geïntroduceerd: in totaal dient er in het hoogste resolutieniveau voor CIF 7 keer te worden opgedeeld om een minimum blok te bereiken ( , 88 72, 44 36, 22 18, 11 9, 5 4, 2 2) waarbij per tak telkens 4 symbolen moeten worden gecodeerd. In het eiland-algoritme wordt de enige overhead veroorzaakt bij het ontstaan van een nieuw eiland. Telkens een nieuw eiland wordt ontdekt wordt de positie van het eiland geëncodeerd. Bij CIF bedraagt die overhead zoals gezien 15 bits per nieuw eiland. Verder dient er op het einde van elke significantiepas een eindsymbool te worden verstuurd, waarvoor een 3-bit code voldoende is. Een nieuw eiland ontstaat slechts wanneer pixels die niet aansluiten bij andere pixelgroepen significant worden, en dus een eiland op zich gaan vormen. Door het clusteringsprincipe echter, is dit vrij beperkt. Het slechts denkbare geval is het geval waarbij totaal geen clustering optreedt, en waar dus een strikte orde is, zoals in figuur 7.8 is te zien. Hierbij zal elke groep van 4 pixels een nieuw eiland gaan vormen, waardoor de overhead sterk oploopt. Door gebruik te maken van enkele optimalisaties van het algoritme zoals besproken in volgende paragraaf, kan echter ook deze situatie efficiënt worden gecodeerd. In een gemiddeld CIF-beeld mogen we verwachten dat het aantal nieuwe eilandjes die worden gevormd met dit basisalgoritme zelden meer dan een paar honderd zullen bedragen. De totale overhead die hiermee wordt geïntroduceerd bedraagt dan ongeveer = bits. In vergelijking met de overhead aan bloksymbolen voor een CIF-frame is dit slechts een peulenschil: in tabel D.1 op pagina 91 vinden we dat de overhead door de quadtree-boom ongeveer bits bedraagt. Naast het feit dat de significante symbolen efficiënter worden gecodeerd, is de voorspelling natuurlijk ook beter. Bij het QT-L-algoritme dat hier wordt gebruikt, wordt voorspeld in eenheden van rechthoekige minimale blokken, terwijl bij het eiland-algoritme effectief eilanden worden gevormd rond de pixels. Bovendien kunnen aan deze eilanden elke gewenste vorm worden meegegeven, zoals straks aan bod komt. Een ander belangrijk punt op vlak van efficiëntie is de samenwerking met de entropie-encoder. Zoals gezien in het vorig hoofdstuk, is de quadtree-opdeling slecht afgestemd op de contextgeba-

82 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME 71 seerde modelselectie. De contextgebaseerde modelselectie besteedt bovendien 43% van zijn tijd in het coderen van de bloksymbolen, terwijl deze slechts ongeveer 7% van de totale hoeveelheid symbolen uitmaken. Door het wegvallen van deze bloksymbolen, komt ook de gehele blokselectie te vervallen. Gezien het zeer kleine aandeel van de positiebits ten opzichte van het totale aantal te coderen bits (3.000 bits op een totaal van meer dan bits of minder dan 0,4%) en het feit dat de positie van nieuwe eilanden statistisch moeilijk te voorspellen valt, heeft het geen zin hier een uitgebreide modellenstructuur voor op te stellen. Hier winnen we dus al een factor 1,7 (100/(100-43)%) aan snelheid. Zoals we in het hoofdstuk over de contextgebaseerde modelselectie hebben besproken, is er een alternatieve manier om de modellen op te slaan, die veel minder geheugen gebruikt. De reden dat deze manier niet werd gebruikt, was het grote verlies aan snelheid die dit zou veroorzaken in de blokselectie, doordat per element binnen het blok meerdere kloktikken zouden nodig zijn om de gewenste data binnen te halen, wat de blokselectie op zich al te traag zou maken ten opzichte van de quadtree. Door het wegvallen van de blokselectie staat ons echter niets in de weg om de alternatieve manier te gebruiken. Door de grote regelmatigheid in verwerking in de verschillende passen van het eiland-algoritme, en de eveneens regelmatige verwerking van de symbolen in de contextgebaseerde modelselectie door het wegvallen van de blokselectie vervalt het probleem van de grote wachtrijen. Een kleine wachtrij kan nu eventueel nog worden ingelast voor een optimale verwerking, doch dit zal geen grote problemen stellen Geheugenvereisten De eiland-encoder We bekijken eerst de te verwachten geheugenvereisten van de eiland-encoder. De NS- en RF-lijsten blijven behouden. We hebben in dit afstudeerwerk een efficiënte methode ontwikkeld om de lijsten bij te houden in het DDR-geheugen, terwijl ze toch snel toegankelijk blijven. Hiervoor werden 18 M512 RAM-blokken gebruikt. Nu dienen we echter wel een extra bitmap bij te houden per wavelet-subband. Het eenvoudigste is de drie bitmappen continue in het geheugen te houden. Per subband hebben we 6 M4K RAM-blokken nodig (zie vorig hoofdstuk), waardoor we dus nog eens 18 M4K RAM-blokken gebruiken. De laaggebaseerde beeldbuffering dient nu enkel nog het teken van elk pixel en de significantie in het huidig drempelniveau (of de bitwaarde voor de verfijningspas) ter beschikking te stellen. Hier winnen we dus een bitmap per bitlaag door het ontbreken van de significantie in het vorig drempelniveau. We passen voor de rest dezelfde oplossing toe zoals deze die voor de quadtree-opdeling werd ontwikkeld: terwijl gecodeerd wordt met de ene geheugengroep, wordt de andere voorgeladen vanuit het DDR-SDRAM. We gebruiken nu dus nog 2 (2 6)=24 M4K RAM-blokken. Het geheugengebruik voor de stapel komt te vervallen. In de plaats komt er nu een H-lijst. Deze zal bij normale werking niet zeer groot worden. Met behulp van enkele M512 blokken

83 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME 72 geheugenblok gebruikt/beschikbaar M-RAM 0/2 M4K RAM 78/138 M512 RAM 25/224 Tabel 7.1: Geheugenvereisten van het eiland-algoritme kan er verder net als bij de lijsten voor gezorgd worden dat wanneer een blok vol is, naar het ander wordt overgeschakeld terwijl het eerste naar het DDR-SDRAM wordt weggeschreven. In het totaal brengt dit ons dus op 42 M4K RAM-blokken en 20 M512 RAM-blokken voor het eiland-algoritme, wat in de lijn ligt van de quadtree-encoder. De contextgebaseerde modelselectie In de contextgebaseerde modelselectie schakelen we nu echter over naar de alternatieve manier die werd beschreven in (pagina 36). Hierdoor daalt het geheugengebruik voor deze trap drastisch. Het gebruik van de 2 grote M-RAM-blokken komt nu te vervallen. In hoofdstuk 4 werd voorgesteld om 3 bits per pixel bij te houden: de huidige significantietoestand, het teken, en een extra bit die de verfijningscontextselectie een factor 3 versnelt. Door een goed opgezette modelselectie en door het wegvallen van de blokselectie, is de codering snel genoeg, waardoor deze extra bit niet nodig is. Het verlies aan snelheid wordt grotendeels gecompenseerd doordat bij het coderen van een significante pixel, de 8 omliggende buren niet hoeven te worden bijgewerkt. De modelselectie zal in ieder geval anders zijn, door het wegvallen van de 9 modellen voor de blokcontext-selectie. Omdat de positie van nieuwe eilanden relatief willekeurig is, zal er op de positiebits praktisch geen compressie kunnen worden bereikt. Deze kunnen daarom rechtstreeks naar de uitvoerstroom worden geschreven. Voor de modelselectie staan verscheidene manieren open, doch een studie hiervan valt buiten het bestek van dit afstudeerwerk. In totaal gebruikt de contextgebaseerde modelselectie dan dus 2 bits per pixel. We opteren hier opnieuw voor de eenvoudigste implementatie waarbij de 3 subbandmodellen in het intern geheugen worden gehouden, waardoor ook weer minder communicatie met het DDR-SDRAM geheugen nodig is. Per bitlaag en per subband zijn nu opnieuw 6 M4K blokken nodig bij CIFbeelden. We komen dan tot een totaal van 2 3 6=36 M4K RAM-blokken. Het geheel Het geheugenverbruik van de aritmetische encoder is gering ten opzichte van de rest. Bij de quadtree-opdeling hadden we 3 26 modellen nodig van elk 38 bits. Door het wegvallen van 9 bits per model, houden we nog 51 modellen van 38 bits over. Door hiervoor enkel M512 RAMblokken te gebruiken, kunnen we deze configureren als 64 9 bits, zodat we om aan databreedte van 38 te geraken, we 5 van deze blokken parallel gebruiken. De totale geheugenvereisten zijn weergegeven in tabel 7.1. In vergelijking met het quadtree-algoritme is het eiland-algoritme door het ontbreken van de M-RAM-blokken een stuk geheugenefficiënter. Een ander gevolg is dat er minder communicatie

84 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME 73 start bezig Eiland algoritme - niet-significantiepas -significantiepas - verfijningspas Statistische Model selectie Aritmetische encoder Symbolen aannemen Beeld module - startdrempel - laaginformatie -voorladen Lijsten -NS-lijsten - VF-lijsten -H-lijst -voorladen Deler Intern geheugen Uitvoer buffer Lagen Buffer Lijsten buffer 2 bitmappen 3x17 modellen DDR geheugen Gecodeerde uitvoer Beeldframe Lijsten Figuur 7.9: Totaal schema van de eiland-encoder met het DDR-SDRAM nodig is, zodat de encoder eveneens beter geschikt is om samen met de wavelettransformatie en de bewegingsschatting op dezelfde FPGA te worden geïmplementeerd. Een algemeen blokschema van de encoder is geschetst in figuur Snelheid Een laatste aspect dat we bekijken is de snelheid van het eiland-algoritme in vergelijking met de quadtree-opdeling. Bij de quadtree-opdeling werd de meeste tijd verbruikt in de significantiepas. Hierbij diende in een eerste lus te worden bepaald of een deelboom al dan niet significant was in de huidige of vorige laag. Door een efficiënte implementatie werd het aantal keren dat dezelfde geheugenplaats gecheckt werd reeds drastisch beperkt (> 75%) door rekening te houden met informatie van de ouderknoop. Niettegenstaande wordt in de meeste gevallen eenzelfde geheugenplaats nog steeds meerdere malen gecontroleerd. Een blok dat reeds in vorige lagen significant werd, wordt toch nog tot op volledige diepte opgedeeld, waarbij elke geheugenplaats in dit blok bij een boomdiepte van 7, 3 keer wordt gecheckt op significantie in de vorige of in de huidige bitlaag. De andere blokken worden efficiënter gecodeerd, doch hoe dieper men afdaalt in het drempelniveau, hoe meer blokken reeds significant zijn geworden. In de significantiepas van het eiland-algoritme daarentegen, wordt de bitmap éénmalig overlo-

85 7.3. VERGELIJKING MET HET QUADTREE-ALGORITME 74 pen. Bij het detecteren van nieuwe eilanden wordt dan wel extra tijd gebruikt doordat de buren op significantie moeten gecontroleerd worden, die op hun beurt weer nieuwe significante buren kunnen hebben, enz. Deze extra tijd wordt echter in de quadtree ook gespendeerd bij het vinden van nieuwe significante minimale blokken, waarbij alle coëfficiënten worden afgelopen en gecodeerd. Tevens gebeurt het creëren van nieuwe eilanden gezien over alle passen relatief weinig. En éénmaal de meeste pixels significant zijn geworden, houden we enkel nog de kost van het overlopen van het beeld over, waarbij per kloktik een nieuw element kan worden gecheckt. We kunnen hier net als bij de contextgebaseerde modelselectie het geheugen interleaved gaan behandelen, daar de bitmap en beeldsignificanties worden bijgehouden in telkens 6 M4K RAM-blokken. Hierdoor kan het aflopen theoretisch zelfs met 6 pixels tegelijk gebeuren, per kloktik! Het eiland-algoritme komt er dus in de significantiepas een heel stuk sneller uit. Zoals al eerder opgemerkt, werd de contextgebaseerde modelselectie ook een factor 1,7 sneller door het wegvallen van de blokcontext. Doordat we overstappen op de geheugenefficiëntere manier verliezen we een deel van die versnelling, die anderzijds gecompenseerd wordt door het wegvallen van de extra geheugentoegangen die nodig waren om de 8 buren bij te werken van een significant geworden pixel. Een ruwe berekening voor een gemiddeld CIF-frame leert ons dat (tabel D.1 op pagina 91) de originele methode ongeveer = kloktikken zal in beslag nemen, t.o.v = kloktikken vroeger (= factor 1,7). Bij de alternatieve methode onderstellen we door het interleaved geheugen maximum 4 kloktikken per te coderen symbool zullen nodig hebben. We krijgen dan een tijdsduur van ( ) 4 = kloktikken. Dit is nog steeds een versnelling van ongeveer 1,5. Dit komt tevens overeen met een framerate voor CIF van 36 frames per seconde bij een klok van 100 MHz. Tenslotte is er nog de aritmetische encoder die in de huidige vorm sowieso reeds te traag is. We hebben echter in 5.6 op pagina 53 enkele mogelijkheden aangereikt om deze nog een stuk sneller te krijgen. Eventueel kan nog uitgeweken worden naar een ander type aritmetische encoder Samenvattende vergelijking De verwachting voor dit nieuwe algoritme is dat het CIF-beelden zonder noemenswaardige problemen in ware tijd zal kunnen coderen en decoderen. Het decoderen zal hierbij sneller kunnen gebeuren dan het encoderen, omdat bij het decoderen de bitmap niet in scanlijn-volgorde afgezocht dient te worden. Enkel de encoder voert deze controle uit om nieuwe significante velden te ontdekken. De decoder leest eenvoudig de positie van de pixels in die de encoder verstuurt. De geheugenvereisten worden voor het totale algoritme een stuk kleiner in vergelijking met het quadtree-algoritme, doordat de contextgebaseerde modelselectie nu met een veel efficiënter geheugenmodel kan werken. Tenslotte is het te verwachten dat de verliesloze compressie meer dan 5% zal verbeteren in vergelijking met het quadtree-algoritme door de kleinere overhead. Ook de verliesgevende compressie zal beter zijn op alle compressieniveaus, mede doordat de kanshebbende coëfficiënten beter worden geselecteerd.

86 7.4. VERDERE MOGELIJKHEDEN EN OPTIMALISATIES 75 a) b) c) Figuur 7.10: Enkele nuttige eilandvormen bij het coderen van waveletbeelden 7.4 Verdere mogelijkheden en optimalisaties Het eenvoudige basisschema van het eiland-algoritme dat hier werd geschetst, biedt nog veel ruimte voor variaties en optimalisaties waardoor de efficiëntie verder kan worden opgedreven. Lijsten Een mogelijke overweging is om de niet-significantielijsten en de verfijningslijst te vervangen door twee bitmappen. Dit betekent een vereenvoudiging op gebied van implementatie daar de bitmappen rechtstreeks in het intern geheugen worden bijgehouden, waarbij de voortdurende communicatie met het DDR-SDRAM wegvalt. Ook de logica nodig voor het bijhouden van een oude én een nieuwe niet-significantielijst wordt hierbij overbodig. Het verwerken van de lijsten houdt nu het in scanlijn-volgorde aflopen van de bitmappen in. De codeersnelheid zal hierdoor lager komen te liggen, doordat alle elementen gecontroleerd worden. Anderzijds wordt dit deels gerecupereerd doordat tot 6 elementen gelijktijdig kunnen worden gecontroleerd. De bitmap die in de basisversie werd gebruikt kan vervallen, daar de informatie uit deze bitmap eenvoudig kan worden afgeleid uit de twee nieuwe bitmappen door een of -functie uit te voeren op beide bitmappen. Globaal is er dus geheugen voor één extra bitmap vereist (per kwadrant), wat neerkomt op 18 extra M4K RAM-blokken. Anderzijds vervallen de 18 M512 RAM-blokken die gebruikt werden als buffer voor het DDR-SDRAM. Eilandvorm Een nadeel van het huidig basisalgoritme is dat de eilanden worden gecreërd door enkel te kijken naar de aangrenzende buren, waardoor men in bepaalde gevallen in problemen kan komen zoals werd geschetst. Het algoritme laat echter probleemloos toe om verder te kijken dan enkel de aangrenzende buren bij het creëren van een nieuw eiland. Men kan dus verschillende eilandstypes en/of groottes gaan specifiëren. Dit is vooral zeer nuttig in combinatie met de waveletgetransformeerde beelden. Afhankelijk van de subband waarin men zich bevindt, kunnen andere soorten eilanden worden gebruikt, die statistisch dichter aanleunen bij de eigenschappen van het beeld. Voor de horizontale subband kan bijvoorbeeld een eiland worden gebruikt zoals in figuur 7.10(a) wordt getoond, voor de andere twee subbanden resp. 7.10(b) en 7.10(c).

87 7.4. VERDERE MOGELIJKHEDEN EN OPTIMALISATIES 76 Positie: 15+1 bits Positie: 6+1 bits Figuur 7.11: Voorbeeld gebruik van relatieve coördinaten t.o.v. een bestaand eiland Eilandgrootte De eilandgrootte kan ook dynamisch worden bepaald. Afhankelijk van de gemiddelde waarde van de omliggende pixels kan dan worden gekozen voor een groot of een klein basis-eiland. Wanneer de gemiddelde waarde groot is, is de kans groter dat er, iets verder in de omgeving, nog pixels liggen die significant zijn. Deze worden dan door een groot basiseiland bij hetzelfde eiland gecodeerd, wat de overhead om een nieuw eiland te creëren uitspaart. Ook voor beelden met een grote resolutie kan gekozen worden voor grotere eilanden, zodat het aantal gecreërde eilanden binnen de perken kan worden gehouden. Enig experimenteren zal hierbij meer duidelijkheid kunnen scheppen. Eilandclusters Bij het bekijken van waveletgetransformeerde beelden, valt het op dat er veel kleine eilandjes ontstaan, die zich clusteren in gebieden. Deze eilandgroepen kunnen enerzijds samengevoegd worden door het basiseiland voldoende groot te kiezen, maar anderzijds is dit niet zo interessant, omdat het basiseiland te groot zou moeten worden, waardoor de efficiëntie van de voorspelling verminderd. Het is daarom beter om een soort hiërarchie in te bouwen. Wanneer het eiland beneden een bepaalde grootte is, wordt in een klein gebied rond dit eiland opnieuw in scanlijnvolgorde gezocht naar nieuwe eilandjes. Deze worden dan gecodeerd met relatieve coördinaten. Wanneer we bijvoorbeeld een zoekvenster van pixels instellen, kunnen de posities van de eilanden hierbinnen met 8 bits worden gecodeerd. Een extra bit laat de decoder weten of het gaat om een relatief of een absoluut adres. Omdat de hogerliggende pixels reeds vroeger werden gecontroleerd, dient de verticale component enkel naar onder te worden gericht, terwijl de horizontale component zowel links als rechts van de huidige pixel kan liggen. Een voorbeeld is te zien in figuur 7.11 waarbij voor de duidelijkheid een zoekvenster van 8 8 pixels wordt gebruikt. Door een goede opzet, kan deze uitbreiding zonder merkbare extra complexiteit worden geïmplementeerd. Bij het ontdekken van een eiland, wordt hierbij na de gebruikelijke codering eerst het kleinere gebied in scanlijnvolgorde afgezocht i.p.v. verder te gaan met het scannen van de volledige bitmap.

88 Hoofdstuk 8 Besluit In deze thesis werd de entropie-encodering uit een bestaande waveletgebaseerde video-encoder naar een hardware-implementeerbare vorm omgewerkt. De bedoeling hiervan was een snelle verwerkingssnelheid van beelden te bereiken, die in software niet kunnen worden gerealiseerd. De hardware die hiervoor werd gebruikt, bestaat uit een Stratix-FPGA van Altera, aangevuld met o.a. 256 MiB DDR-SDRAM. De entropie-encoder bestaat uit drie grote delen: een quadtree-opdeling, een contextgebaseerde modelselectie en een aritmetische encoder. De voornaamste opstakels bij het uitwerken van de encoder naar een efficiënte implementatie, werden gevormd door de sterke sequentiële werking van de gebruikte algoritmes (typisch voor compressie-algoritmes), de grote geheugenvereisten en de moeilijke samenwerking tussen de delen. De quadtree-opdeling vormt de hoofdmodule van deze encoder. De originele code vereiste een grote hoeveelheid snel geheugen. Optimalisaties situeerden zich voornamelijk rond het wegwerken van deze geheugenvereisten en het optimaliseren van de berekeningen. Op die manier werd een snelheid van 99 QCIF-beelden per seconde gehaald, en 24 CIF-beelden per seconde. In vergelijking met hetzelfde algoritme in software, uitgevoerd op een PentiumIV 2,4 GHz, betekent dit een versnelling met een factor 9. De contextgebaseerde modelselectie vormt een tussenliggende trap tussen de quadtree-opdeling en de aritmetische encoder. Deze trap neemt veruit de grootste hap van het geheugen voor zijn rekening. De interne structuur werd aangepast zodat deze efficiënter communiceert met het geheugen, en de verwerkingssnelheid van de quadtree-opdeling kan volgen. De opzet van het algoritme kan echter nog sterk worden verbeterd, en vereist een aanpassing van zowel de encoder als de decoder. Enkele mogelijkheden werden aangereikt in deze scriptie. De aritmetische encoder tenslotte verzorgt de eigenlijke compressie van de symbolen. Door de vele berekeningen die per symbool moeten worden uitgevoerd, vormt deze de traagste trap van de encoder. De code werd omgevormd naar een complexe pijplijn, om toch zo hoog mogelijke prestaties te behalen. Verdere mogelijkheden worden besproken om de berekeningen te versnellen, zonder dat dit een grote invloed op de prestaties zal hebben. De drie trappen verschillen sterk wat betreft hun verwerkingsritme. Een goede koppeling tussen de trappen is daardoor niet eenvoudig. Verschillende mogelijkheden worden in deze scriptie 77

89 HOOFDSTUK 8. BESLUIT 78 voorgesteld, doch een goede oplossing die het globale prestatieverlies minimaliseert, terwijl de extra benodigde logica en geheugen klein blijft, lijkt moeilijk te verwezenlijken. Algemeen beschouwd zijn er dus een aantal punten waarin dit algoritme tekort schiet. Vandaar dat als afsluiting van deze thesis een alternatief algoritme werd uitgedacht: het eiland-algoritme. Deze behoudt of versterkt de positieve punten van het originele algoritme, terwijl de negatieve punten die de prestaties beperken worden verbeterd. De verbetering situeert zich hierbij zowel op vlak van compressie, als op vlak van een snellere en eenvoudige hardware-implementatie.

90 Bijlage A Het PCI Altera Stratix bord In deze bijlage geven we kort een beschrijving van het gebruikte FPGA-bord met de voor deze thesis relevante gegevens en de belangrijkste informatie over de synthese software, en het standaard referentiedesign. A.1 Het bord Het PCI ontwikkelingsbord voor de Stratix-FPGA gebruikt in deze thesis voorziet in een compleet hardware platform dat ontwikkelaars kunnen gebruiken om snel hardware te kunnen testen en te verifiëren. Het is speciaal bedoeld voor prototyping, wat te zien is in de zeer universele opzet. Het bord kan zowel met de PCI-bus als autonoom worden ingezet. Hierbij voorziet men in oplossingen voor PCI en voor DDR-SDRAM ontwerpen. Het bord kan zowel overweg met 3.3-V als met 5.0-V PCI bussen, en ondersteunt 32- en 64-bit PCI slots. Daarnaast kan het zowel werken op 33- en 66-MHz PCI bussen, alsook op een 133-MHz PCI-X bus. In figuur A.1 is de opbouw van het bord te zien. We vermelden hier enkel de belangrijkste karakteristieken. De FPGA die op dit bord wordt gebruikt is de EP1S25F1020, en behoort tot het type EP1S25 [3]. Deze FPGA heeft logische elementen (LE) aan boord, en beschikt daarnaast over 3 types RAM-blokken voor efficiënte toepassingen ondersteuning. De kleinste RAM-blokken zijn de zogenaamde M512 RAM-blokken. Daarvan zijn er 224 aanwezig. Ze beschikken elk over 576 bits geheugen (of 512 bits + pariteitbits) die in een aantal vaste databreedtes kunnen worden geconfigureerd, te beginnen bij een 1 bits databus. Ze kunnen daarnaast zowel als enkelpoorts RAM, eenvoudig tweepoorts RAM, FIFO, ROM en als schuifregister worden ingezet. De M4K RAM-blokken zijn de tweede soort RAM aanwezig op de FPGA. Hiervan zijn er 138 aanwezig, en deze beschikken over RAM bits. Ze kunnen naast de eigenschappen van de M512 RAM-blokken ook als echt tweepoortsgeheugen worden ingezet, waarbij onafhankelijke klokken kunnen worden gebruikt voor de twee poorten. Van deze eigenschap kan handig worden gebruik gemaakt wanneer de RAM-blokken worden ingezet als CACHE-geheugen tussen het DDR-SDRAM en de interne hardware van de applicatie. 79

91 A.2. DE QUARTUS II ONTWIKKELINGSSOFTWARE 80 De grootste RAM-blokken aanwezig zijn de M-RAM-blokken. Hiervan zijn er slechts 2 aanwezig, doch deze beschikken evenwel over bits geheugen. Ze kunnen ook in enkele vaste databreedtes worden ingezet, te beginnen bij een 9 bits brede databus. Ze zijn ideaal om grotere hoeveelheden data te bufferen, en kunnen hierbij als eenvoudig en echt tweepoorts geheugen, enkelpoorts geheugen en als FIFO worden ingezet. Meer gedetailleerde informatie is te vinden in [4]. Het achtervoegsel F1020 duidt op de snelheidsklasse en het behuizingstype. Het hier gebruikte type is de tragere soort binnen zijn klasse. Hierbij kan rekening worden gehouden tijdens het ontwikkelen van de hardware. Wanneer van het prototypingbord wordt overgestapt naar een meer specifiek ontwikkeld bord, kan gekozen worden voor een snellere soort, waardoor de kloksnelheid verhoogd kan worden. Op het bord is verder flash geheugen aanwezig waarin het programma van de FPGA niet vluchtig kan worden opgeslagen. Er is voldoende plaats aanwezig om 4 configuraties in te laden. De kaart beschikt naast de PCI-interface nog over tal van andere communicatie mogelijkheden waaronder 10/100 Ethernet, RS-232 en JTAG. Via deze JTAG interface kan de FPGA ook geprogrammeerd worden, de manier ook die voor dit afstudeerwerk werd gebruikt. Daarnaast kan de FPGA ook worden geprogrammeerd via de PCI-bus. Om het debuggen te vereenvoudigen zijn op het bord nog enkele invoer- en uitvoerkanalen aanwezig in de vorm van 8 programmeerbare LED s en 4 programmeerbare schakelaars. A.2 De Quartus II ontwikkelingssoftware Bij het bord wordt tevens een synthesetool geleverd in de vorm van QuartusII. Deze integreert nog enkele andere handige functies binnen hetzelfde programma. Het programma werkt met AHDL-, VHDL-, of Verilog-bestanden als hardware beschrijvingstaal. De SystemC-code die voor deze thesis werd geschreven, dient daarom eerst extern naar VHDL te worden vertaald. In SystemC werd gebruik gemaakt van simulatieblokken voor het geheugen. In QuartusII daarentegen wordt code gecreerd via de MegaPlugIn-Wizard om de geheugenblokken die op de FPGA aanwezig zijn te configureren. Via deze tool kunnen ramblokken eenvoudig op maat worden geprogrammeerd. Deze wizard herbergt ook nog tal van andere blokken, gaande van standaardblokken zoals delers en multiplexers tot volledige processoren die op de FPGA kunnen worden gesynthetiseerd. Tijdens het synthetiseren bepaalt het programma de hoeveelheid ruimte die de hardwarebeschrijving effectief op de gespecificeerde FPGA inneemt. Daarnaast wordt de haalbare kloksnelheid berekend op basis van het langste pad dat binnen een klokcyclus kan optreden. Hierdoor wordt het mogelijk de code verder te optimaliseren naar snelheid door de aangegeven kritische paden verder te optimaliseren. In de laatste fase wordt de gesynthetiseerde code via de JTAG-interface op het bord geplaatst waarna het programma automatisch wordt gestart.

92 A.3. HET STRATIX MODULAIR TOP DESIGN 81 A.3 Het Stratix modulair top design Voor dit bord werd door Altera een referentie-ontwerp gemaakt waarmee reeds een eenvoudige communicatie tussen het DDR-SDRAM en de PCI bus kan worden uitgevoerd. Het ontwerp is echter gesloten opgezet, waardoor het erg moeilijk is om naast de rechtstreekse communicatie tussen het DDR-SDRAM en de PCI-bus data tussen het DDR-SDRAM en de processen op de FPGA uit te wisselen. Vandaar dat in de onderzoeksgroep gedurende dit jaar een modulair ontwerp werd ontwikkeld waarmee op een eenvoudiger wijze extra componenten aan de DDR-SDRAM interface kunnen worden toegevoegd. Hierbij dient echter de nodige zorg te worden besteed aan de verschillende klokfrequenties tussen de modules. Het rechtstreeks bufferen van signalen via een enkele flipflop, die geklokt wordt via de inlezende module, leverde problemen omtrent metastabiliteit op. Een in praktijk uitstekend werkende remedie hiervoor was het gebruik van een extra tussentijds register zodat signalen doorgeschoven worden via een 2-niveaus schuifregister. Data kan eenvoudig via tweepoortsgeheugen worden uitgewisseld tussen de twee modules. Om controle van het programma vanuit de PC mogelijk te maken wordt gebruik gemaakt van enkele statusregisters die op vaste adresbanken op de kaart worden opgeslagen. Vanuit de PC wordt naar deze registers geschreven en gelezen via de PCI-interface. De FPGA dient deze registers te controleren bij het wachten op een opdracht. Op deze manier worden ook de resultaten vanuit de FPGA terug naar de PC geschreven. Voor verdere details verwijzen we rechtstreeks naar de VHDL-code van het modulair referentie ontwerp. Deze werd geïncludeerd op de CD-ROM die achteraan dit boek werd geïncludeerd.

93 A.3. HET STRATIX MODULAIR TOP DESIGN 82 Figuur A.1: Het Altera Stratix PCI bord, gebruikt in dit afstudeerwerk