jpegdecinternal.c 154 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339
  1. /*------------------------------------------------------------------------------
  2. -- --
  3. -- This software is confidential and proprietary and may be used --
  4. -- only as expressly authorized by a licensing agreement from --
  5. -- --
  6. -- Hantro Products Oy. --
  7. -- --
  8. -- (C) COPYRIGHT 2006 HANTRO PRODUCTS OY --
  9. -- ALL RIGHTS RESERVED --
  10. -- --
  11. -- The entire notice above must be reproduced --
  12. -- on all copies and should not be removed. --
  13. -- --
  14. --------------------------------------------------------------------------------
  15. --
  16. -- Description : SW Jpeg Decoder
  17. --
  18. ------------------------------------------------------------------------------
  19. --
  20. -- Version control information, please leave untouched.
  21. --
  22. -- $RCSfile: jpegdecinternal.c,v $
  23. -- $Revision: 1.47 $
  24. -- $Date: 2010/12/02 10:53:50 $
  25. --
  26. ------------------------------------------------------------------------------*/
  27. /*------------------------------------------------------------------------------
  28. Table of contents
  29. 1. Include headers
  30. 2. External compiler flags
  31. 3. Module defines
  32. 4. Local function prototypes
  33. 5. Functions
  34. - JpegDecClearStructs
  35. - JpegDecInitHW
  36. - JpegDecAllocateResidual
  37. - JpegDecWriteTables
  38. - JpegRefreshRegs
  39. - JpegFlushRegs
  40. ------------------------------------------------------------------------------*/
  41. /*------------------------------------------------------------------------------
  42. 1. Include headers
  43. ------------------------------------------------------------------------------*/
  44. #include "basetype.h"
  45. #include "jpegdeccontainer.h"
  46. #include "jpegdecapi.h"
  47. #include "jpegdecmarkers.h"
  48. #include "jpegdecutils.h"
  49. #include "jpegdechdrs.h"
  50. #include "jpegdecscan.h"
  51. #include "jpegregdrv.h"
  52. #include "jpegdecinternal.h"
  53. #include "dwl.h"
  54. #include "deccfg.h"
  55. #ifdef JPEGDEC_ASIC_TRACE
  56. #include "jpegasicdbgtrace.h"
  57. #endif /* #ifdef JPEGDEC_TRACE */
  58. #ifdef JPEGDEC_PP_TRACE
  59. #include "ppinternal.h"
  60. #endif /* #ifdef JPEGDEC_PP_TRACE */
  61. /*------------------------------------------------------------------------------
  62. 2. External compiler flags
  63. --------------------------------------------------------------------------------
  64. --------------------------------------------------------------------------------
  65. 3. Module defines
  66. ------------------------------------------------------------------------------*/
  67. static const u8 zzOrder[64] = {
  68. 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
  69. 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
  70. 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  71. 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  72. };
  73. #define JPEGDEC_SLICE_START_VALUE 0
  74. #define JPEGDEC_VLC_LEN_START_REG 16
  75. #define JPEGDEC_VLC_LEN_END_REG 29
  76. #ifdef PJPEG_COMPONENT_TRACE
  77. extern u32 pjpegComponentId;
  78. extern u32 *pjpegCoeffBase;
  79. extern u32 pjpegCoeffSize;
  80. #define TRACE_COMPONENT_ID(id) pjpegComponentId = id
  81. #else
  82. #define TRACE_COMPONENT_ID(id)
  83. #endif
  84. /*------------------------------------------------------------------------------
  85. 4. Local function prototypes
  86. ------------------------------------------------------------------------------*/
  87. static void JpegDecWriteTables(JpegDecContainer * pJpegDecCont);
  88. static void JpegDecWriteTablesNonInterleaved(JpegDecContainer * pJpegDecCont);
  89. static void JpegDecWriteTablesProgressive(JpegDecContainer * pJpegDecCont);
  90. static void JpegDecChromaTableSelectors(JpegDecContainer * pJpegDecCont);
  91. static void JpegDecSetHwStrmParams(JpegDecContainer * pJpegDecCont);
  92. static void JpegDecWriteLenBits(JpegDecContainer * pJpegDecCont);
  93. static void JpegDecWriteLenBitsNonInterleaved(JpegDecContainer * pJpegDecCont);
  94. static void JpegDecWriteLenBitsProgressive(JpegDecContainer * pJpegDecCont);
  95. /*------------------------------------------------------------------------------
  96. 5. Functions
  97. ------------------------------------------------------------------------------*/
  98. /*------------------------------------------------------------------------------
  99. Function name: JpegDecClearStructs
  100. Functional description:
  101. handles the initialisation of jpeg decoder data structure
  102. Inputs:
  103. Outputs:
  104. Returns OK when successful, NOK in case unknown message type is
  105. asked
  106. ------------------------------------------------------------------------------*/
  107. void JpegDecClearStructs(JpegDecContainer * pJpegDecCont)
  108. {
  109. u32 i;
  110. ASSERT(pJpegDecCont);
  111. /* stream pointers */
  112. pJpegDecCont->stream.thumbnail = 0;
  113. pJpegDecCont->stream.streamBus = 0;
  114. pJpegDecCont->stream.pStartOfStream = NULL;
  115. pJpegDecCont->stream.pCurrPos = NULL;
  116. pJpegDecCont->stream.bitPosInByte = 0;
  117. pJpegDecCont->stream.streamLength = 0;
  118. pJpegDecCont->stream.readBits = 0;
  119. pJpegDecCont->stream.appnFlag = 0;
  120. pJpegDecCont->stream.returnSosMarker = 0;
  121. /* output image pointers and variables */
  122. pJpegDecCont->image.pStartOfImage = NULL;
  123. pJpegDecCont->image.pLum = NULL;
  124. pJpegDecCont->image.pCr = NULL;
  125. pJpegDecCont->image.pCb = NULL;
  126. pJpegDecCont->image.headerReady = 0;
  127. pJpegDecCont->image.imageReady = 0;
  128. pJpegDecCont->image.ready = 0;
  129. pJpegDecCont->image.size = 0;
  130. pJpegDecCont->image.sizeLuma = 0;
  131. pJpegDecCont->image.sizeChroma = 0;
  132. for(i = 0; i < MAX_NUMBER_OF_COMPONENTS; i++)
  133. {
  134. pJpegDecCont->image.columns[i] = 0;
  135. pJpegDecCont->image.pixelsPerRow[i] = 0;
  136. }
  137. /* frame info */
  138. pJpegDecCont->frame.Lf = 0;
  139. pJpegDecCont->frame.P = 0;
  140. pJpegDecCont->frame.Y = 0;
  141. pJpegDecCont->frame.X = 0;
  142. pJpegDecCont->frame.hwY = 0;
  143. pJpegDecCont->frame.hwX = 0;
  144. pJpegDecCont->frame.Nf = 0; /* Number of components in frame */
  145. pJpegDecCont->frame.codingType = 0;
  146. pJpegDecCont->frame.numMcuInFrame = 0;
  147. pJpegDecCont->frame.numMcuInRow = 0;
  148. pJpegDecCont->frame.mcuNumber = 0;
  149. pJpegDecCont->frame.Ri = 0;
  150. pJpegDecCont->frame.row = 0;
  151. pJpegDecCont->frame.col = 0;
  152. pJpegDecCont->frame.driPeriod = 0;
  153. pJpegDecCont->frame.block = 0;
  154. pJpegDecCont->frame.cIndex = 0;
  155. pJpegDecCont->frame.bufferBus = 0;
  156. pJpegDecCont->frame.pBuffer = NULL;
  157. pJpegDecCont->frame.pBufferCb = NULL;
  158. pJpegDecCont->frame.pBufferCr = NULL;
  159. pJpegDecCont->frame.pTableBase.virtualAddress = NULL;
  160. pJpegDecCont->frame.pTableBase.busAddress = 0;
  161. /* asic buffer */
  162. pJpegDecCont->asicBuff.outLumaBuffer.virtualAddress = NULL;
  163. pJpegDecCont->asicBuff.outChromaBuffer.virtualAddress = NULL;
  164. pJpegDecCont->asicBuff.outChromaBuffer2.virtualAddress = NULL;
  165. pJpegDecCont->asicBuff.outLumaBuffer.busAddress = 0;
  166. pJpegDecCont->asicBuff.outChromaBuffer.busAddress = 0;
  167. pJpegDecCont->asicBuff.outChromaBuffer2.busAddress = 0;
  168. pJpegDecCont->asicBuff.outLumaBuffer.size = 0;
  169. pJpegDecCont->asicBuff.outChromaBuffer.size = 0;
  170. pJpegDecCont->asicBuff.outChromaBuffer2.size = 0;
  171. /* pp instance */
  172. pJpegDecCont->ppStatus = 0;
  173. pJpegDecCont->ppInstance = NULL;
  174. pJpegDecCont->PPRun = NULL;
  175. pJpegDecCont->PPEndCallback = NULL;
  176. pJpegDecCont->ppControl.usePipeline = 0;
  177. /* asic running flag */
  178. pJpegDecCont->asicRunning = 0;
  179. /* resolution */
  180. pJpegDecCont->minSupportedWidth = 0;
  181. pJpegDecCont->minSupportedHeight = 0;
  182. pJpegDecCont->maxSupportedWidth = 0;
  183. pJpegDecCont->maxSupportedHeight = 0;
  184. pJpegDecCont->maxSupportedPixelAmount = 0;
  185. pJpegDecCont->maxSupportedSliceSize = 0;
  186. /* out bus tmp */
  187. pJpegDecCont->info.outLuma.virtualAddress = NULL;
  188. pJpegDecCont->info.outChroma.virtualAddress = NULL;
  189. pJpegDecCont->info.outChroma2.virtualAddress = NULL;
  190. /* user allocated addresses */
  191. pJpegDecCont->info.givenOutLuma.virtualAddress = NULL;
  192. pJpegDecCont->info.givenOutChroma.virtualAddress = NULL;
  193. pJpegDecCont->info.givenOutChroma2.virtualAddress = NULL;
  194. /* image handling info */
  195. pJpegDecCont->info.sliceHeight = 0;
  196. pJpegDecCont->info.amountOfQTables = 0;
  197. pJpegDecCont->info.yCbCrMode = 0;
  198. pJpegDecCont->info.yCbCr422 = 0;
  199. pJpegDecCont->info.column = 0;
  200. pJpegDecCont->info.X = 0;
  201. pJpegDecCont->info.Y = 0;
  202. pJpegDecCont->info.memSize = 0;
  203. pJpegDecCont->info.SliceCount = 0;
  204. pJpegDecCont->info.SliceMBCutValue = 0;
  205. pJpegDecCont->info.pipeline = 0;
  206. pJpegDecCont->info.userAllocMem = 0;
  207. pJpegDecCont->info.sliceStartCount = 0;
  208. pJpegDecCont->info.amountOfSlices = 0;
  209. pJpegDecCont->info.noSliceIrqForUser = 0;
  210. pJpegDecCont->info.SliceReadyForPause = 0;
  211. pJpegDecCont->info.sliceLimitReached = 0;
  212. pJpegDecCont->info.sliceMbSetValue = 0;
  213. pJpegDecCont->info.timeout = (u32) DEC_X170_TIMEOUT_LENGTH;
  214. pJpegDecCont->info.rlcMode = 0; /* JPEG always in VLC mode == 0 */
  215. pJpegDecCont->info.lumaPos = 0;
  216. pJpegDecCont->info.chromaPos = 0;
  217. pJpegDecCont->info.fillRight = 0;
  218. pJpegDecCont->info.fillBottom = 0;
  219. pJpegDecCont->info.streamEnd = 0;
  220. pJpegDecCont->info.streamEndFlag = 0;
  221. pJpegDecCont->info.inputBufferEmpty = 0;
  222. pJpegDecCont->info.inputStreaming = 0;
  223. pJpegDecCont->info.inputBufferLen = 0;
  224. pJpegDecCont->info.decodedStreamLen = 0;
  225. pJpegDecCont->info.init = 0;
  226. pJpegDecCont->info.initThumb = 0;
  227. pJpegDecCont->info.initBufferSize = 0;
  228. /* progressive */
  229. pJpegDecCont->info.nonInterleaved = 0;
  230. pJpegDecCont->info.componentId = 0;
  231. pJpegDecCont->info.operationType = 0;
  232. pJpegDecCont->info.operationTypeThumb = 0;
  233. pJpegDecCont->info.progressiveScanReady = 0;
  234. pJpegDecCont->info.nonInterleavedScanReady = 0;
  235. pJpegDecCont->info.pCoeffBase.virtualAddress = NULL;
  236. pJpegDecCont->info.pCoeffBase.busAddress = 0;
  237. pJpegDecCont->info.allocated = 0;
  238. pJpegDecCont->info.yCbCrModeOrig = 0;
  239. pJpegDecCont->info.getInfoYCbCrMode = 0;
  240. pJpegDecCont->info.progressiveFinish = 0;
  241. pJpegDecCont->info.pfCompId = 0;
  242. for(i = 0; i < MAX_NUMBER_OF_COMPONENTS; i++)
  243. pJpegDecCont->info.pfNeeded[i] = 0;
  244. pJpegDecCont->info.tmpStrm.virtualAddress = NULL;
  245. for(i = 0; i < MAX_NUMBER_OF_COMPONENTS; i++)
  246. {
  247. pJpegDecCont->info.components[i] = 0;
  248. pJpegDecCont->info.pred[i] = 0;
  249. pJpegDecCont->info.dcRes[i] = 0;
  250. pJpegDecCont->frame.numBlocks[i] = 0;
  251. pJpegDecCont->frame.blocksPerRow[i] = 0;
  252. pJpegDecCont->frame.useAcOffset[i] = 0;
  253. pJpegDecCont->frame.component[i].C = 0;
  254. pJpegDecCont->frame.component[i].H = 0;
  255. pJpegDecCont->frame.component[i].V = 0;
  256. pJpegDecCont->frame.component[i].Tq = 0;
  257. }
  258. /* scan info */
  259. pJpegDecCont->scan.Ls = 0;
  260. pJpegDecCont->scan.Ns = 0;
  261. pJpegDecCont->scan.Ss = 0;
  262. pJpegDecCont->scan.Se = 0;
  263. pJpegDecCont->scan.Ah = 0;
  264. pJpegDecCont->scan.Al = 0;
  265. pJpegDecCont->scan.index = 0;
  266. pJpegDecCont->scan.numIdctRows = 0;
  267. for(i = 0; i < MAX_NUMBER_OF_COMPONENTS; i++)
  268. {
  269. pJpegDecCont->scan.Cs[i] = 0;
  270. pJpegDecCont->scan.Td[i] = 0;
  271. pJpegDecCont->scan.Ta[i] = 0;
  272. pJpegDecCont->scan.pred[i] = 0;
  273. }
  274. /* huffman table lengths */
  275. pJpegDecCont->vlc.acTable0.tableLength = 0;
  276. pJpegDecCont->vlc.acTable1.tableLength = 0;
  277. pJpegDecCont->vlc.acTable2.tableLength = 0;
  278. pJpegDecCont->vlc.acTable3.tableLength = 0;
  279. pJpegDecCont->vlc.dcTable0.tableLength = 0;
  280. pJpegDecCont->vlc.dcTable1.tableLength = 0;
  281. pJpegDecCont->vlc.dcTable2.tableLength = 0;
  282. pJpegDecCont->vlc.dcTable3.tableLength = 0;
  283. /* Restart interval */
  284. pJpegDecCont->frame.Ri = 0;
  285. /* pointer initialisation */
  286. pJpegDecCont->vlc.acTable0.vals = NULL;
  287. pJpegDecCont->vlc.acTable1.vals = NULL;
  288. pJpegDecCont->vlc.acTable2.vals = NULL;
  289. pJpegDecCont->vlc.acTable3.vals = NULL;
  290. pJpegDecCont->vlc.dcTable0.vals = NULL;
  291. pJpegDecCont->vlc.dcTable1.vals = NULL;
  292. pJpegDecCont->vlc.dcTable2.vals = NULL;
  293. pJpegDecCont->vlc.dcTable3.vals = NULL;
  294. pJpegDecCont->frame.pBuffer = NULL;
  295. return;
  296. }
  297. /*------------------------------------------------------------------------------
  298. Function name: JpegDecInitHW
  299. Functional description:
  300. Set up HW regs for decode
  301. Inputs:
  302. JpegDecContainer *pJpegDecCont
  303. Outputs:
  304. Returns OK when successful, NOK in case unknown message type is
  305. asked
  306. ------------------------------------------------------------------------------*/
  307. JpegDecRet JpegDecInitHW(JpegDecContainer * pJpegDecCont)
  308. {
  309. u32 i;
  310. u32 coeffBuffer = 0;
  311. #define PTR_JPGC pJpegDecCont
  312. ASSERT(pJpegDecCont);
  313. TRACE_COMPONENT_ID(PTR_JPGC->info.componentId);
  314. /* Check if first InitHw call */
  315. if(PTR_JPGC->info.sliceStartCount == 0)
  316. {
  317. /* Check if HW resource is available */
  318. if(DWLReserveHw(pJpegDecCont->dwl) == DWL_ERROR)
  319. {
  320. JPEGDEC_TRACE_INTERNAL(("JpegDecInitHW: ERROR hw resource unavailable"));
  321. return JPEGDEC_HW_RESERVED;
  322. }
  323. }
  324. /*************** Set swreg4 data ************/
  325. /* frame size, round up the number of mbs */
  326. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width extension\n"));
  327. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_W_EXT,
  328. ((((PTR_JPGC->info.X) >> (4)) & 0xE00) >> 9));
  329. /* frame size, round up the number of mbs */
  330. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width\n"));
  331. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_WIDTH,
  332. ((PTR_JPGC->info.X) >> (4)) & 0x1FF);
  333. /* frame size, round up the number of mbs */
  334. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height extension\n"));
  335. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_H_EXT,
  336. ((((PTR_JPGC->info.Y) >> (4)) & 0x700) >> 8));
  337. /* frame size, round up the number of mbs */
  338. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height\n"));
  339. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_HEIGHT_P,
  340. ((PTR_JPGC->info.Y) >> (4)) & 0x0FF);
  341. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set decoding mode: JPEG\n"));
  342. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_MODE, JPEG_X170_MODE_JPEG);
  343. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set output write enabled\n"));
  344. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 0);
  345. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set filtering disabled\n"));
  346. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_FILTERING_DIS, 1);
  347. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set amount of QP Table\n"));
  348. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_QTABLES,
  349. PTR_JPGC->info.amountOfQTables);
  350. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set input format\n"));
  351. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_MODE,
  352. PTR_JPGC->info.yCbCrMode);
  353. JPEGDEC_TRACE_INTERNAL(("INTERNAL: RLC mode enable, JPEG == disable\n"));
  354. /* In case of JPEG: Always VLC mode used (0) */
  355. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_RLC_MODE_E, PTR_JPGC->info.rlcMode);
  356. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Width is not multiple of 16\n"));
  357. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_FILRIGHT_E,
  358. PTR_JPGC->info.fillRight);
  359. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_FILDOWN_E,
  360. PTR_JPGC->info.fillBottom);
  361. /*************** Set swreg15 data ************/
  362. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set slice/full mode: 0 full; other = slice\n"));
  363. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_SLICE_H,
  364. PTR_JPGC->info.sliceHeight);
  365. /*************** Set swreg52 data ************/
  366. if(PTR_JPGC->info.operationType != JPEGDEC_PROGRESSIVE)
  367. {
  368. /* Set JPEG operation mode */
  369. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  370. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_E, 0);
  371. }
  372. else
  373. {
  374. /* Set JPEG operation mode */
  375. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  376. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_E, 1);
  377. }
  378. /* Set spectral selection start coefficient */
  379. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  380. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_SS, PTR_JPGC->scan.Ss);
  381. /* Set spectral selection end coefficient */
  382. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  383. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_SE, PTR_JPGC->scan.Se);
  384. /* Set the point transform used in the preceding scan */
  385. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  386. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_AH, PTR_JPGC->scan.Ah);
  387. /* Set the point transform value */
  388. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  389. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_AL, PTR_JPGC->scan.Al);
  390. /* Set needed progressive parameters */
  391. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE)
  392. {
  393. /* write coeff table base */
  394. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set coefficient buffer base address\n"));
  395. coeffBuffer = PTR_JPGC->info.pCoeffBase.busAddress;
  396. /* non-interleaved */
  397. if(PTR_JPGC->info.nonInterleaved)
  398. {
  399. for(i = 0; i < PTR_JPGC->info.componentId; i++)
  400. {
  401. coeffBuffer += (JPEGDEC_COEFF_SIZE *
  402. PTR_JPGC->frame.numBlocks[i]);
  403. }
  404. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_COEFF_BUF,
  405. coeffBuffer);
  406. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 0);
  407. }
  408. /* interleaved components */
  409. else
  410. {
  411. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_COEFF_BUF,
  412. coeffBuffer);
  413. coeffBuffer += (JPEGDEC_COEFF_SIZE) * PTR_JPGC->frame.numBlocks[0];
  414. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_DCCB_BASE,
  415. coeffBuffer);
  416. coeffBuffer += (JPEGDEC_COEFF_SIZE) * PTR_JPGC->frame.numBlocks[1];
  417. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_DCCR_BASE,
  418. coeffBuffer);
  419. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 1);
  420. }
  421. }
  422. /*************** Set swreg5/swreg6/swreg12/swreg16-swreg27 data ************/
  423. if(PTR_JPGC->info.operationType == JPEGDEC_BASELINE)
  424. {
  425. /* write "length amounts" */
  426. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write VLC length amounts to register\n"));
  427. JpegDecWriteLenBits(PTR_JPGC);
  428. /* Create AC/DC/QP tables for HW */
  429. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write AC,DC,QP tables to base\n"));
  430. JpegDecWriteTables(PTR_JPGC);
  431. }
  432. else if(PTR_JPGC->info.operationType == JPEGDEC_NONINTERLEAVED)
  433. {
  434. /* write "length amounts" */
  435. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write VLC length amounts to register\n"));
  436. JpegDecWriteLenBitsNonInterleaved(PTR_JPGC);
  437. /* Create AC/DC/QP tables for HW */
  438. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write AC,DC,QP tables to base\n"));
  439. JpegDecWriteTablesNonInterleaved(PTR_JPGC);
  440. }
  441. else
  442. {
  443. /* write "length amounts" */
  444. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write VLC length amounts to register\n"));
  445. JpegDecWriteLenBitsProgressive(PTR_JPGC);
  446. /* Create AC/DC/QP tables for HW */
  447. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write AC,DC,QP tables to base\n"));
  448. JpegDecWriteTablesProgressive(PTR_JPGC);
  449. }
  450. /* Select which tables the chromas use */
  451. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Select chroma AC,DC tables\n"));
  452. JpegDecChromaTableSelectors(PTR_JPGC);
  453. /* write table base */
  454. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set AC,DC,QP table base address\n"));
  455. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_QTABLE_BASE,
  456. PTR_JPGC->frame.pTableBase.busAddress);
  457. /* set up stream position for HW decode */
  458. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set stream position for HW\n"));
  459. JpegDecSetHwStrmParams(PTR_JPGC);
  460. /* set restart interval */
  461. if(PTR_JPGC->frame.Ri)
  462. {
  463. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_SYNC_MARKER_E, 1);
  464. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_REST_FREQ,
  465. PTR_JPGC->frame.Ri);
  466. }
  467. else
  468. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_SYNC_MARKER_E, 0);
  469. /* Handle PP and output base addresses */
  470. /* PP depending register writes */
  471. if(PTR_JPGC->ppInstance != NULL && PTR_JPGC->ppControl.usePipeline)
  472. {
  473. /*************** Set swreg4 data ************/
  474. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set output write disabled\n"));
  475. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 1);
  476. /* set output to zero, because of pp */
  477. /*************** Set swreg13 data ************/
  478. /* Luminance output */
  479. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set LUMA OUTPUT data base address\n"));
  480. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE, 0);
  481. /*************** Set swreg14 data ************/
  482. /* Chrominance output */
  483. if(PTR_JPGC->image.sizeChroma)
  484. {
  485. /* write output base */
  486. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set CHROMA OUTPUT data base address\n"));
  487. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPG_CH_OUT_BASE, 0);
  488. }
  489. if(PTR_JPGC->info.sliceStartCount == JPEGDEC_SLICE_START_VALUE)
  490. {
  491. /* Enable pp */
  492. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Enable pp\n"));
  493. PTR_JPGC->PPRun(PTR_JPGC->ppInstance, &PTR_JPGC->ppControl);
  494. PTR_JPGC->ppControl.ppStatus = DECPP_RUNNING;
  495. }
  496. PTR_JPGC->info.pipeline = 1;
  497. }
  498. else
  499. {
  500. /*************** Set swreg13 data ************/
  501. /* Luminance output */
  502. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set LUMA OUTPUT data base address\n"));
  503. if(PTR_JPGC->info.operationType == JPEGDEC_BASELINE)
  504. {
  505. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  506. PTR_JPGC->asicBuff.outLumaBuffer.busAddress);
  507. /*************** Set swreg14 data ************/
  508. /* Chrominance output */
  509. if(PTR_JPGC->image.sizeChroma)
  510. {
  511. /* write output base */
  512. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set CHROMA OUTPUT data base address\n"));
  513. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPG_CH_OUT_BASE,
  514. PTR_JPGC->asicBuff.outChromaBuffer.busAddress);
  515. }
  516. }
  517. else
  518. {
  519. if(PTR_JPGC->info.componentId == 0)
  520. {
  521. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  522. PTR_JPGC->asicBuff.outLumaBuffer.busAddress);
  523. }
  524. else if(PTR_JPGC->info.componentId == 1)
  525. {
  526. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  527. PTR_JPGC->asicBuff.outChromaBuffer.busAddress);
  528. }
  529. else
  530. {
  531. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  532. (PTR_JPGC->asicBuff.outChromaBuffer2.
  533. busAddress));
  534. }
  535. }
  536. PTR_JPGC->info.pipeline = 0;
  537. }
  538. PTR_JPGC->info.sliceStartCount = 1;
  539. #ifdef JPEGDEC_ASIC_TRACE
  540. {
  541. FILE *fd;
  542. fd = fopen("picture_ctrl_dec.trc", "at");
  543. DumpJPEGCtrlReg(pJpegDecCont->jpegRegs, fd);
  544. fclose(fd);
  545. fd = fopen("picture_ctrl_dec.hex", "at");
  546. HexDumpJPEGCtrlReg(pJpegDecCont->jpegRegs, fd);
  547. fclose(fd);
  548. fd = fopen("jpeg_tables.hex", "at");
  549. HexDumpJPEGTables(pJpegDecCont->jpegRegs, pJpegDecCont, fd);
  550. fclose(fd);
  551. fd = fopen("registers.hex", "at");
  552. HexDumpRegs(pJpegDecCont->jpegRegs, fd);
  553. fclose(fd);
  554. }
  555. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  556. #ifdef JPEGDEC_PP_TRACE
  557. ppRegDump(((PPContainer_t *) PTR_JPGC->ppInstance)->ppRegs);
  558. #endif /* #ifdef JPEGDEC_PP_TRACE */
  559. PTR_JPGC->asicRunning = 1;
  560. /* Flush regs to hw register */
  561. JpegFlushRegs(PTR_JPGC);
  562. /* Enable jpeg mode and set slice mode */
  563. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Enable jpeg\n"));
  564. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_E, 1);
  565. DWLEnableHW(PTR_JPGC->dwl, 4 * 1, PTR_JPGC->jpegRegs[1]);
  566. #undef PTR_JPGC
  567. return JPEGDEC_OK;
  568. }
  569. /*------------------------------------------------------------------------------
  570. Function name: JpegDecInitHWContinue
  571. Functional description:
  572. Set up HW regs for decode
  573. Inputs:
  574. JpegDecContainer *pJpegDecCont
  575. Outputs:
  576. Returns OK when successful, NOK in case unknown message type is
  577. asked
  578. ------------------------------------------------------------------------------*/
  579. void JpegDecInitHWContinue(JpegDecContainer * pJpegDecCont)
  580. {
  581. #define PTR_JPGC pJpegDecCont
  582. ASSERT(pJpegDecCont);
  583. /* update slice counter */
  584. PTR_JPGC->info.amountOfSlices++;
  585. if(PTR_JPGC->ppInstance == NULL &&
  586. PTR_JPGC->info.userAllocMem == 1 && PTR_JPGC->info.sliceStartCount > 0)
  587. {
  588. /* if user allocated memory ==> new addresses */
  589. PTR_JPGC->asicBuff.outLumaBuffer.virtualAddress =
  590. PTR_JPGC->info.givenOutLuma.virtualAddress;
  591. PTR_JPGC->asicBuff.outLumaBuffer.busAddress =
  592. PTR_JPGC->info.givenOutLuma.busAddress;
  593. PTR_JPGC->asicBuff.outChromaBuffer.virtualAddress =
  594. PTR_JPGC->info.givenOutChroma.virtualAddress;
  595. PTR_JPGC->asicBuff.outChromaBuffer.busAddress =
  596. PTR_JPGC->info.givenOutChroma.busAddress;
  597. }
  598. /* Update only register/values that might have been changed */
  599. /*************** Set swreg1 data ************/
  600. /* clear status bit */
  601. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_SLICE_INT, 0);
  602. /*************** Set swreg5 data ************/
  603. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set stream last buffer bit\n"));
  604. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_STREAM_ALL,
  605. PTR_JPGC->info.streamEnd);
  606. /*************** Set swreg13 data ************/
  607. /* PP depending register writes */
  608. if(PTR_JPGC->ppInstance == NULL)
  609. {
  610. /* Luminance output */
  611. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set LUMA OUTPUT data base address\n"));
  612. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  613. PTR_JPGC->asicBuff.outLumaBuffer.busAddress);
  614. /*************** Set swreg14 data ************/
  615. /* Chrominance output */
  616. if(PTR_JPGC->image.sizeChroma)
  617. {
  618. /* write output base */
  619. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set CHROMA OUTPUT data base address\n"));
  620. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPG_CH_OUT_BASE,
  621. PTR_JPGC->asicBuff.outChromaBuffer.busAddress);
  622. }
  623. PTR_JPGC->info.pipeline = 0;
  624. }
  625. /*************** Set swreg13 data ************/
  626. /* PP depending register writes */
  627. if(PTR_JPGC->ppInstance != NULL && PTR_JPGC->ppControl.usePipeline == 0)
  628. {
  629. if(PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV420)
  630. {
  631. PTR_JPGC->info.lumaPos = (PTR_JPGC->info.X *
  632. (PTR_JPGC->info.sliceMbSetValue * 16));
  633. PTR_JPGC->info.chromaPos = ((PTR_JPGC->info.X) *
  634. (PTR_JPGC->info.sliceMbSetValue * 8));
  635. }
  636. else if(PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV422)
  637. {
  638. PTR_JPGC->info.lumaPos = (PTR_JPGC->info.X *
  639. (PTR_JPGC->info.sliceMbSetValue * 16));
  640. PTR_JPGC->info.chromaPos = ((PTR_JPGC->info.X) *
  641. (PTR_JPGC->info.sliceMbSetValue * 16));
  642. }
  643. else if(PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV440)
  644. {
  645. PTR_JPGC->info.lumaPos = (PTR_JPGC->info.X *
  646. (PTR_JPGC->info.sliceMbSetValue * 16));
  647. PTR_JPGC->info.chromaPos = ((PTR_JPGC->info.X) *
  648. (PTR_JPGC->info.sliceMbSetValue * 16));
  649. }
  650. else
  651. {
  652. PTR_JPGC->info.lumaPos = (PTR_JPGC->info.X *
  653. (PTR_JPGC->info.sliceMbSetValue * 16));
  654. PTR_JPGC->info.chromaPos = 0;
  655. }
  656. /* update luma/chroma position */
  657. PTR_JPGC->info.lumaPos = (PTR_JPGC->info.lumaPos *
  658. PTR_JPGC->info.amountOfSlices);
  659. if(PTR_JPGC->info.chromaPos)
  660. {
  661. PTR_JPGC->info.chromaPos = (PTR_JPGC->info.chromaPos *
  662. PTR_JPGC->info.amountOfSlices);
  663. }
  664. /* Luminance output */
  665. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set LUMA OUTPUT data base address\n"));
  666. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE,
  667. PTR_JPGC->asicBuff.outLumaBuffer.busAddress +
  668. PTR_JPGC->info.lumaPos);
  669. /*************** Set swreg14 data ************/
  670. /* Chrominance output */
  671. if(PTR_JPGC->image.sizeChroma)
  672. {
  673. /* write output base */
  674. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set CHROMA OUTPUT data base address\n"));
  675. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPG_CH_OUT_BASE,
  676. PTR_JPGC->asicBuff.outChromaBuffer.busAddress +
  677. PTR_JPGC->info.chromaPos);
  678. }
  679. PTR_JPGC->info.pipeline = 0;
  680. }
  681. /*************** Set swreg15 data ************/
  682. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set slice/full mode: 0 full; other = slice\n"));
  683. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_SLICE_H,
  684. PTR_JPGC->info.sliceHeight);
  685. /* Flush regs to hw register */
  686. DWLWriteReg(pJpegDecCont->dwl, 0x34, PTR_JPGC->jpegRegs[13]);
  687. DWLWriteReg(pJpegDecCont->dwl, 0x38, PTR_JPGC->jpegRegs[14]);
  688. DWLWriteReg(pJpegDecCont->dwl, 0x3C, PTR_JPGC->jpegRegs[15]);
  689. DWLWriteReg(pJpegDecCont->dwl, 0x14, PTR_JPGC->jpegRegs[5]);
  690. DWLWriteReg(pJpegDecCont->dwl, 0x4, PTR_JPGC->jpegRegs[1]);
  691. #ifdef JPEGDEC_ASIC_TRACE
  692. {
  693. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: REGS BEFORE IRQ CLEAN\n"));
  694. PrintJPEGReg(pJpegDecCont->jpegRegs);
  695. }
  696. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  697. }
  698. /*------------------------------------------------------------------------------
  699. Function name: JpegDecInitHWInputBuffLoad
  700. Functional description:
  701. Set up HW regs for decode after input buffer load
  702. Inputs:
  703. JpegDecContainer *pJpegDecCont
  704. Outputs:
  705. Returns OK when successful, NOK in case unknown message type is
  706. asked
  707. ------------------------------------------------------------------------------*/
  708. void JpegDecInitHWInputBuffLoad(JpegDecContainer * pJpegDecCont)
  709. {
  710. #define PTR_JPGC pJpegDecCont
  711. ASSERT(pJpegDecCont);
  712. /* Update only register/values that might have been changed */
  713. /*************** Set swreg4 data ************/
  714. /* frame size, round up the number of mbs */
  715. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width extension\n"));
  716. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_W_EXT,
  717. ((((PTR_JPGC->info.X) >> (4)) & 0xE00) >> 9));
  718. /* frame size, round up the number of mbs */
  719. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width\n"));
  720. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_WIDTH,
  721. ((PTR_JPGC->info.X) >> (4)) & 0x1FF);
  722. /* frame size, round up the number of mbs */
  723. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height extension\n"));
  724. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_H_EXT,
  725. ((((PTR_JPGC->info.Y) >> (4)) & 0x700) >> 8));
  726. /* frame size, round up the number of mbs */
  727. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height\n"));
  728. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_HEIGHT_P,
  729. ((PTR_JPGC->info.Y) >> (4)) & 0x0FF);
  730. /*************** Set swreg5 data ************/
  731. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Set stream start bit\n"));
  732. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_STRM_START_BIT,
  733. PTR_JPGC->stream.bitPosInByte);
  734. /*************** Set swreg6 data ************/
  735. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Set stream length\n"));
  736. /* check if all stream will processed in this buffer */
  737. if((PTR_JPGC->info.decodedStreamLen) >= PTR_JPGC->stream.streamLength)
  738. {
  739. PTR_JPGC->info.streamEnd = 1;
  740. }
  741. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_STREAM_LEN,
  742. PTR_JPGC->info.inputBufferLen);
  743. /*************** Set swreg4 data ************/
  744. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Set stream last buffer bit\n"));
  745. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_STREAM_ALL,
  746. PTR_JPGC->info.streamEnd);
  747. /*************** Set swreg12 data ************/
  748. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Set stream start address\n"));
  749. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_RLC_VLC_BASE,
  750. PTR_JPGC->stream.streamBus);
  751. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Stream bus start 0x%08x\n",
  752. PTR_JPGC->stream.streamBus));
  753. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Bit position 0x%08x\n",
  754. PTR_JPGC->stream.bitPosInByte));
  755. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: Stream length 0x%08x\n",
  756. PTR_JPGC->stream.streamLength));
  757. /* Flush regs to hw register */
  758. DWLWriteReg(pJpegDecCont->dwl, 0x30, PTR_JPGC->jpegRegs[12]);
  759. DWLWriteReg(pJpegDecCont->dwl, 0x10, PTR_JPGC->jpegRegs[4]);
  760. DWLWriteReg(pJpegDecCont->dwl, 0x14, PTR_JPGC->jpegRegs[5]);
  761. DWLWriteReg(pJpegDecCont->dwl, 0x18, PTR_JPGC->jpegRegs[6]);
  762. DWLWriteReg(pJpegDecCont->dwl, 0x04, PTR_JPGC->jpegRegs[1]);
  763. #ifdef JPEGDEC_ASIC_TRACE
  764. {
  765. JPEGDEC_TRACE_INTERNAL(("INTERNAL BUFFER LOAD: REGS BEFORE IRQ CLEAN\n"));
  766. PrintJPEGReg(pJpegDecCont->jpegRegs);
  767. }
  768. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  769. }
  770. /*------------------------------------------------------------------------------
  771. Function name: JpegDecInitHWProgressiveContinue
  772. Functional description:
  773. Set up HW regs for decode after progressive scan decoded
  774. Inputs:
  775. JpegDecContainer *pJpegDecCont
  776. Outputs:
  777. Returns OK when successful, NOK in case unknown message type is
  778. asked
  779. ------------------------------------------------------------------------------*/
  780. void JpegDecInitHWProgressiveContinue(JpegDecContainer * pJpegDecCont)
  781. {
  782. #define PTR_JPGC pJpegDecCont
  783. u32 i;
  784. u32 coeffBuffer = 0;
  785. u32 outputBuffer = 0;
  786. ASSERT(pJpegDecCont);
  787. if(PTR_JPGC->ppInstance == NULL && PTR_JPGC->info.userAllocMem == 1)
  788. {
  789. /* if user allocated memory ==> new addresses */
  790. PTR_JPGC->asicBuff.outLumaBuffer.virtualAddress =
  791. PTR_JPGC->info.givenOutLuma.virtualAddress;
  792. PTR_JPGC->asicBuff.outLumaBuffer.busAddress =
  793. PTR_JPGC->info.givenOutLuma.busAddress;
  794. PTR_JPGC->asicBuff.outChromaBuffer.virtualAddress =
  795. PTR_JPGC->info.givenOutChroma.virtualAddress;
  796. PTR_JPGC->asicBuff.outChromaBuffer.busAddress =
  797. PTR_JPGC->info.givenOutChroma.busAddress;
  798. PTR_JPGC->asicBuff.outChromaBuffer2.virtualAddress =
  799. PTR_JPGC->info.givenOutChroma2.virtualAddress;
  800. PTR_JPGC->asicBuff.outChromaBuffer2.busAddress =
  801. PTR_JPGC->info.givenOutChroma2.busAddress;
  802. }
  803. TRACE_COMPONENT_ID(PTR_JPGC->info.componentId);
  804. /* Update only register/values that might have been changed */
  805. /*************** Set swreg13 data ************/
  806. /* Luminance output */
  807. if(PTR_JPGC->info.componentId == 0)
  808. outputBuffer = PTR_JPGC->asicBuff.outLumaBuffer.busAddress;
  809. else if(PTR_JPGC->info.componentId == 1)
  810. outputBuffer = (PTR_JPGC->asicBuff.outChromaBuffer.busAddress);
  811. else
  812. outputBuffer = (PTR_JPGC->asicBuff.outChromaBuffer2.busAddress);
  813. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set LUMA OUTPUT data base address\n"));
  814. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_BASE, outputBuffer);
  815. PTR_JPGC->info.pipeline = 0;
  816. /* set up stream position for HW decode */
  817. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set stream position for HW\n"));
  818. JpegDecSetHwStrmParams(PTR_JPGC);
  819. /*************** Set swreg5 data ************/
  820. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set input format\n"));
  821. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_MODE,
  822. PTR_JPGC->info.yCbCrMode);
  823. /* frame size, round up the number of mbs */
  824. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width extension\n"));
  825. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_W_EXT,
  826. ((((PTR_JPGC->info.X) >> (4)) & 0xE00) >> 9));
  827. /* frame size, round up the number of mbs */
  828. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width\n"));
  829. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_WIDTH,
  830. ((PTR_JPGC->info.X) >> (4)) & 0x1FF);
  831. /* frame size, round up the number of mbs */
  832. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height extension\n"));
  833. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_H_EXT,
  834. ((((PTR_JPGC->info.Y) >> (4)) & 0x700) >> 8));
  835. /* frame size, round up the number of mbs */
  836. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height\n"));
  837. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PIC_MB_HEIGHT_P,
  838. ((PTR_JPGC->info.Y) >> (4)) & 0x0FF);
  839. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_WDIV8, PTR_JPGC->info.fillX);
  840. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_FILRIGHT_E,
  841. PTR_JPGC->info.fillX || PTR_JPGC->info.fillRight);
  842. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_HDIV8, PTR_JPGC->info.fillY);
  843. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_FILDOWN_E,
  844. PTR_JPGC->info.fillY || PTR_JPGC->info.fillBottom);
  845. /*************** Set swreg52 data ************/
  846. /* Set JPEG operation mode */
  847. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  848. if(PTR_JPGC->info.operationType != JPEGDEC_PROGRESSIVE)
  849. {
  850. /* Set JPEG operation mode */
  851. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  852. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_E, 0);
  853. }
  854. else
  855. {
  856. /* Set JPEG operation mode */
  857. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  858. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_E, 1);
  859. }
  860. /* Set spectral selection start coefficient */
  861. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  862. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_SS, PTR_JPGC->scan.Ss);
  863. /* Set spectral selection end coefficient */
  864. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  865. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_SE, PTR_JPGC->scan.Se);
  866. /* Set the point transform used in the preceding scan */
  867. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  868. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_AH, PTR_JPGC->scan.Ah);
  869. /* Set the point transform value */
  870. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  871. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_AL, PTR_JPGC->scan.Al);
  872. /* Set needed progressive parameters */
  873. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE)
  874. {
  875. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set coefficient buffer base address\n"));
  876. coeffBuffer = PTR_JPGC->info.pCoeffBase.busAddress;
  877. /* non-interleaved */
  878. if(PTR_JPGC->info.nonInterleaved)
  879. {
  880. for(i = 0; i < PTR_JPGC->info.componentId; i++)
  881. {
  882. coeffBuffer += (JPEGDEC_COEFF_SIZE *
  883. PTR_JPGC->frame.numBlocks[i]);
  884. }
  885. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_COEFF_BUF,
  886. coeffBuffer);
  887. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 0);
  888. }
  889. /* interleaved components */
  890. else
  891. {
  892. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_COEFF_BUF,
  893. coeffBuffer);
  894. coeffBuffer += (JPEGDEC_COEFF_SIZE) * PTR_JPGC->frame.numBlocks[0];
  895. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_DCCB_BASE,
  896. coeffBuffer);
  897. coeffBuffer += (JPEGDEC_COEFF_SIZE) * PTR_JPGC->frame.numBlocks[1];
  898. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_PJPEG_DCCR_BASE,
  899. coeffBuffer);
  900. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_OUT_DIS, 1);
  901. }
  902. }
  903. /* write "length amounts" */
  904. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write VLC length amounts to register\n"));
  905. JpegDecWriteLenBitsProgressive(PTR_JPGC);
  906. /* Create AC/DC/QP tables for HW */
  907. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write AC,DC,QP tables to base\n"));
  908. JpegDecWriteTablesProgressive(PTR_JPGC);
  909. /* Select which tables the chromas use */
  910. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Select chroma AC,DC tables\n"));
  911. JpegDecChromaTableSelectors(PTR_JPGC);
  912. /* write table base */
  913. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set AC,DC,QP table base address\n"));
  914. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_QTABLE_BASE,
  915. PTR_JPGC->frame.pTableBase.busAddress);
  916. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_QTABLES,
  917. PTR_JPGC->info.amountOfQTables);
  918. if(PTR_JPGC->info.sliceMbSetValue)
  919. {
  920. /*************** Set swreg15 data ************/
  921. JPEGDEC_TRACE_INTERNAL(("INTERNAL CONTINUE: Set slice/full mode: 0 full; other = slice\n"));
  922. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_SLICE_H,
  923. PTR_JPGC->info.sliceHeight);
  924. }
  925. /* set restart interval */
  926. if(PTR_JPGC->frame.Ri)
  927. {
  928. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_SYNC_MARKER_E, 1);
  929. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_REFER13_BASE,
  930. PTR_JPGC->frame.Ri);
  931. }
  932. else
  933. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_SYNC_MARKER_E, 0);
  934. PTR_JPGC->asicRunning = 1;
  935. /* Flush regs to hw register */
  936. JpegFlushRegs(PTR_JPGC);
  937. /* Enable jpeg mode and set slice mode */
  938. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Enable jpeg\n"));
  939. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DEC_E, 1);
  940. DWLEnableHW(PTR_JPGC->dwl, 4 * 1, PTR_JPGC->jpegRegs[1]);
  941. #ifdef JPEGDEC_ASIC_TRACE
  942. {
  943. JPEGDEC_TRACE_INTERNAL(("PROGRESSIVE CONTINUE: REGS BEFORE IRQ CLEAN\n"));
  944. PrintJPEGReg(pJpegDecCont->jpegRegs);
  945. }
  946. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  947. }
  948. /*------------------------------------------------------------------------------
  949. Function name: JpegDecSetHwStrmParams
  950. Functional description:
  951. set up hw stream start position
  952. Inputs:
  953. JpegDecContainer *pJpegDecCont
  954. Outputs:
  955. void
  956. ------------------------------------------------------------------------------*/
  957. static void JpegDecSetHwStrmParams(JpegDecContainer * pJpegDecCont)
  958. {
  959. #define PTR_JPGC pJpegDecCont
  960. #define JPG_STR pJpegDecCont->stream
  961. u32 addrTmp = 0;
  962. u32 amountOfStream = 0;
  963. /* calculate and set stream start address to hw */
  964. JPEGDEC_TRACE_INTERNAL(("INTERNAL: read bits %d\n", JPG_STR.readBits));
  965. JPEGDEC_TRACE_INTERNAL(("INTERNAL: read bytes %d\n", JPG_STR.readBits / 8));
  966. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Stream bus start 0x%08x\n",
  967. JPG_STR.streamBus));
  968. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Stream virtual start 0x%08x\n",
  969. JPG_STR.pStartOfStream));
  970. /* calculate and set stream start address to hw */
  971. addrTmp = ((u32) JPG_STR.streamBus + ((u32) JPG_STR.pStartOfStream & 0x3) +
  972. (u32) (JPG_STR.pCurrPos - JPG_STR.pStartOfStream)) & (~7);
  973. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_RLC_VLC_BASE, addrTmp);
  974. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Stream bus start 0x%08x\n",
  975. JPG_STR.streamBus));
  976. // JPEGDEC_TRACE_INTERNAL(("INTERNAL: Start Addr 0x%08x\n",
  977. // GetJpegDecStreamStartAddress(PTR_JPGC->jpegRegs)));
  978. /* calculate and set stream start bit to hw */
  979. /* change current pos to bus address style */
  980. /* remove three lowest bits and add the difference to bitPosInWord */
  981. /* used as bit pos in word not as bit pos in byte actually... */
  982. switch ((u32) JPG_STR.pCurrPos & (7))
  983. {
  984. case 0:
  985. break;
  986. case 1:
  987. JPG_STR.bitPosInByte += 8;
  988. break;
  989. case 2:
  990. JPG_STR.bitPosInByte += 16;
  991. break;
  992. case 3:
  993. JPG_STR.bitPosInByte += 24;
  994. break;
  995. case 4:
  996. JPG_STR.bitPosInByte += 32;
  997. break;
  998. case 5:
  999. JPG_STR.bitPosInByte += 40;
  1000. break;
  1001. case 6:
  1002. JPG_STR.bitPosInByte += 48;
  1003. break;
  1004. case 7:
  1005. JPG_STR.bitPosInByte += 56;
  1006. break;
  1007. default:
  1008. ASSERT(0);
  1009. break;
  1010. }
  1011. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_STRM_START_BIT,
  1012. JPG_STR.bitPosInByte);
  1013. /* set up stream length for HW.
  1014. * length = size of original buffer - stream we already decoded in SW */
  1015. JPG_STR.pCurrPos = (u8 *) ((u32) JPG_STR.pCurrPos & (~7));
  1016. if(PTR_JPGC->info.inputStreaming)
  1017. {
  1018. amountOfStream = (PTR_JPGC->info.inputBufferLen -
  1019. (u32) (JPG_STR.pCurrPos - JPG_STR.pStartOfStream));
  1020. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_STREAM_LEN, amountOfStream);
  1021. }
  1022. else
  1023. {
  1024. amountOfStream = (JPG_STR.streamLength -
  1025. (u32) (JPG_STR.pCurrPos - JPG_STR.pStartOfStream));
  1026. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_STREAM_LEN, amountOfStream);
  1027. /* because no input streaming, frame should be ready during decoding this buffer */
  1028. PTR_JPGC->info.streamEnd = 1;
  1029. }
  1030. /*************** Set swreg4 data ************/
  1031. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set stream last buffer bit\n"));
  1032. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_JPEG_STREAM_ALL,
  1033. PTR_JPGC->info.streamEnd);
  1034. JPEGDEC_TRACE_INTERNAL(("INTERNAL: JPG_STR.streamLength %d\n",
  1035. JPG_STR.streamLength));
  1036. JPEGDEC_TRACE_INTERNAL(("INTERNAL: JPG_STR.pCurrPos 0x%08x\n",
  1037. (u32) JPG_STR.pCurrPos));
  1038. JPEGDEC_TRACE_INTERNAL(("INTERNAL: JPG_STR.pStartOfStream 0x%08x\n",
  1039. (u32) JPG_STR.pStartOfStream));
  1040. JPEGDEC_TRACE_INTERNAL(("INTERNAL: JPG_STR.bitPosInByte 0x%08x\n",
  1041. JPG_STR.bitPosInByte));
  1042. return;
  1043. #undef JPG_STR
  1044. #undef PTR_JPGC
  1045. }
  1046. /*------------------------------------------------------------------------------
  1047. Function name: JpegDecAllocateResidual
  1048. Functional description:
  1049. Allocates residual buffer
  1050. Inputs:
  1051. JpegDecContainer *pJpegDecCont Pointer to DecData structure
  1052. Outputs:
  1053. OK
  1054. JPEGDEC_MEMFAIL
  1055. ------------------------------------------------------------------------------*/
  1056. JpegDecRet JpegDecAllocateResidual(JpegDecContainer * pJpegDecCont)
  1057. {
  1058. #define PTR_JPGC pJpegDecCont
  1059. i32 tmp = JPEGDEC_ERROR;
  1060. u32 numBlocks = 0;
  1061. u32 i;
  1062. u32 tableSize = 0;
  1063. ASSERT(PTR_JPGC);
  1064. JPEGDEC_TRACE_INTERNAL(("++++++++++++ALLOCATE: PTR_JPGC->info.operationType %x ++++++\n",PTR_JPGC->info.operationType));
  1065. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE)
  1066. {
  1067. for(i = 0; i < PTR_JPGC->frame.Nf; i++)
  1068. {
  1069. numBlocks += PTR_JPGC->frame.numBlocks[i];
  1070. }
  1071. /* allocate coefficient buffer */
  1072. tmp = DWLMallocLinear(PTR_JPGC->dwl, (sizeof(u8) * (JPEGDEC_COEFF_SIZE *
  1073. numBlocks)),
  1074. &(PTR_JPGC->info.pCoeffBase));
  1075. JPEGDEC_TRACE_INTERNAL(("++++++++++++DWLMallocLinear ++++++\n"));
  1076. if(tmp == -1)
  1077. {
  1078. return (JPEGDEC_MEMFAIL);
  1079. }
  1080. #ifdef PJPEG_COMPONENT_TRACE
  1081. pjpegCoeffBase = PTR_JPGC->info.pCoeffBase.virtualAddress;
  1082. pjpegCoeffSize = numBlocks * JPEGDEC_COEFF_SIZE;
  1083. #endif
  1084. JPEGDEC_TRACE_INTERNAL(("ALLOCATE: COEFF virtual %x bus %x\n",
  1085. (u32) PTR_JPGC->info.pCoeffBase.virtualAddress,
  1086. PTR_JPGC->info.pCoeffBase.busAddress));
  1087. if(PTR_JPGC->frame.Nf > 1)
  1088. {
  1089. tmp = DWLMallocLinear(PTR_JPGC->dwl, sizeof(u8) * 100,
  1090. &PTR_JPGC->info.tmpStrm);
  1091. if(tmp == -1)
  1092. {
  1093. return (JPEGDEC_MEMFAIL);
  1094. }
  1095. }
  1096. }
  1097. /* QP/VLC memory size */
  1098. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE)
  1099. tableSize = JPEGDEC_PROGRESSIVE_TABLE_SIZE;
  1100. else
  1101. tableSize = JPEGDEC_BASELINE_TABLE_SIZE;
  1102. /* allocate VLC/QP table */
  1103. tmp =
  1104. DWLMallocLinear(PTR_JPGC->dwl, (sizeof(u8) * tableSize),
  1105. &(PTR_JPGC->frame.pTableBase));
  1106. if(tmp == -1)
  1107. {
  1108. return (JPEGDEC_MEMFAIL);
  1109. }
  1110. JPEGDEC_TRACE_INTERNAL(("ALLOCATE: VLC/QP virtual %x bus %x\n",
  1111. (u32) PTR_JPGC->frame.pTableBase.virtualAddress,
  1112. PTR_JPGC->frame.pTableBase.busAddress));
  1113. if(PTR_JPGC->ppInstance != NULL)
  1114. {
  1115. PTR_JPGC->ppConfigQuery.tiledMode = 0;
  1116. PTR_JPGC->PPConfigQuery(PTR_JPGC->ppInstance, &PTR_JPGC->ppConfigQuery);
  1117. PTR_JPGC->ppControl.usePipeline =
  1118. PTR_JPGC->ppConfigQuery.pipelineAccepted;
  1119. if(!PTR_JPGC->ppControl.usePipeline)
  1120. {
  1121. PTR_JPGC->image.sizeLuma = (PTR_JPGC->info.X * PTR_JPGC->info.Y);
  1122. if(PTR_JPGC->image.sizeChroma)
  1123. {
  1124. if(PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV420)
  1125. PTR_JPGC->image.sizeChroma = (PTR_JPGC->image.sizeLuma / 2);
  1126. else if(PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV422 ||
  1127. PTR_JPGC->info.yCbCrMode == JPEGDEC_YUV440)
  1128. PTR_JPGC->image.sizeChroma = PTR_JPGC->image.sizeLuma;
  1129. }
  1130. }
  1131. }
  1132. /* if pipelined PP -> decoder's output is not written external memory */
  1133. if(PTR_JPGC->ppInstance == NULL ||
  1134. (PTR_JPGC->ppInstance != NULL && !PTR_JPGC->ppControl.usePipeline))
  1135. {
  1136. if(PTR_JPGC->info.givenOutLuma.virtualAddress == NULL)
  1137. {
  1138. /* allocate luminance output */
  1139. tmp =
  1140. DWLMallocRefFrm(PTR_JPGC->dwl, (PTR_JPGC->image.sizeLuma),
  1141. &(PTR_JPGC->asicBuff.outLumaBuffer));
  1142. if(tmp == -1)
  1143. {
  1144. return (JPEGDEC_MEMFAIL);
  1145. }
  1146. /* luma bus address to output */
  1147. PTR_JPGC->info.outLuma = PTR_JPGC->asicBuff.outLumaBuffer;
  1148. }
  1149. else
  1150. {
  1151. PTR_JPGC->asicBuff.outLumaBuffer.virtualAddress =
  1152. PTR_JPGC->info.givenOutLuma.virtualAddress;
  1153. PTR_JPGC->asicBuff.outLumaBuffer.busAddress =
  1154. PTR_JPGC->info.givenOutLuma.busAddress;
  1155. /* luma bus address to output */
  1156. PTR_JPGC->info.outLuma = PTR_JPGC->asicBuff.outLumaBuffer;
  1157. /* flag to release */
  1158. PTR_JPGC->info.userAllocMem = 1;
  1159. }
  1160. JPEGDEC_TRACE_INTERNAL(("ALLOCATE: Luma virtual %x bus %x\n",
  1161. (u32) PTR_JPGC->asicBuff.outLumaBuffer.
  1162. virtualAddress,
  1163. PTR_JPGC->asicBuff.outLumaBuffer.busAddress));
  1164. /* allocate chrominance output */
  1165. if(PTR_JPGC->image.sizeChroma)
  1166. {
  1167. if(PTR_JPGC->info.givenOutChroma.virtualAddress == NULL)
  1168. {
  1169. if(PTR_JPGC->info.operationType != JPEGDEC_BASELINE)
  1170. {
  1171. tmp =
  1172. DWLMallocRefFrm(PTR_JPGC->dwl,
  1173. (PTR_JPGC->image.sizeChroma / 2),
  1174. &(PTR_JPGC->asicBuff.outChromaBuffer));
  1175. if(tmp == -1)
  1176. return (JPEGDEC_MEMFAIL);
  1177. tmp =
  1178. DWLMallocRefFrm(PTR_JPGC->dwl,
  1179. (PTR_JPGC->image.sizeChroma / 2),
  1180. &(PTR_JPGC->asicBuff.outChromaBuffer2));
  1181. if(tmp == -1)
  1182. return (JPEGDEC_MEMFAIL);
  1183. }
  1184. else
  1185. {
  1186. tmp =
  1187. DWLMallocRefFrm(PTR_JPGC->dwl,
  1188. (PTR_JPGC->image.sizeChroma),
  1189. &(PTR_JPGC->asicBuff.outChromaBuffer));
  1190. if(tmp == -1)
  1191. return (JPEGDEC_MEMFAIL);
  1192. PTR_JPGC->asicBuff.outChromaBuffer2.virtualAddress = NULL;
  1193. PTR_JPGC->asicBuff.outChromaBuffer2.busAddress = 0;
  1194. }
  1195. }
  1196. else
  1197. {
  1198. PTR_JPGC->asicBuff.outChromaBuffer.virtualAddress =
  1199. PTR_JPGC->info.givenOutChroma.virtualAddress;
  1200. PTR_JPGC->asicBuff.outChromaBuffer.busAddress =
  1201. PTR_JPGC->info.givenOutChroma.busAddress;
  1202. PTR_JPGC->asicBuff.outChromaBuffer2.virtualAddress =
  1203. PTR_JPGC->info.givenOutChroma2.virtualAddress;
  1204. PTR_JPGC->asicBuff.outChromaBuffer2.busAddress =
  1205. PTR_JPGC->info.givenOutChroma2.busAddress;
  1206. }
  1207. /* chroma bus address to output */
  1208. PTR_JPGC->info.outChroma = PTR_JPGC->asicBuff.outChromaBuffer;
  1209. PTR_JPGC->info.outChroma2 = PTR_JPGC->asicBuff.outChromaBuffer2;
  1210. JPEGDEC_TRACE_INTERNAL(("ALLOCATE: Chroma virtual %x bus %x\n",
  1211. (u32) PTR_JPGC->asicBuff.outChromaBuffer.
  1212. virtualAddress,
  1213. PTR_JPGC->asicBuff.outChromaBuffer.
  1214. busAddress));
  1215. }
  1216. }
  1217. #ifdef JPEGDEC_RESET_OUTPUT
  1218. {
  1219. (void) DWLmemset(PTR_JPGC->asicBuff.outLumaBuffer.virtualAddress,
  1220. 128, PTR_JPGC->image.sizeLuma);
  1221. if(PTR_JPGC->image.sizeChroma)
  1222. {
  1223. if(PTR_JPGC->info.operationType != JPEGDEC_BASELINE)
  1224. {
  1225. (void) DWLmemset(PTR_JPGC->asicBuff.outChromaBuffer.
  1226. virtualAddress, 128,
  1227. PTR_JPGC->image.sizeChroma / 2);
  1228. (void) DWLmemset(PTR_JPGC->asicBuff.outChromaBuffer2.
  1229. virtualAddress, 128,
  1230. PTR_JPGC->image.sizeChroma / 2);
  1231. }
  1232. else
  1233. (void) DWLmemset(PTR_JPGC->asicBuff.outChromaBuffer.
  1234. virtualAddress, 128,
  1235. PTR_JPGC->image.sizeChroma);
  1236. }
  1237. (void) DWLmemset(PTR_JPGC->frame.pTableBase.virtualAddress, 0,
  1238. (sizeof(u8) * tableSize));
  1239. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE)
  1240. {
  1241. (void) DWLmemset(PTR_JPGC->info.pCoeffBase.virtualAddress, 0,
  1242. (sizeof(u8) * JPEGDEC_COEFF_SIZE * numBlocks));
  1243. }
  1244. }
  1245. #endif /* #ifdef JPEGDEC_RESET_OUTPUT */
  1246. return JPEGDEC_OK;
  1247. #undef PTR_JPGC
  1248. }
  1249. /*------------------------------------------------------------------------------
  1250. Function name: JpegDecSliceSizeCalculation
  1251. Functional description:
  1252. Calculates slice size
  1253. Inputs:
  1254. JpegDecContainer *pJpegDecCont
  1255. Outputs:
  1256. void
  1257. ------------------------------------------------------------------------------*/
  1258. void JpegDecSliceSizeCalculation(JpegDecContainer * pJpegDecCont)
  1259. {
  1260. #define PTR_JPGC pJpegDecCont
  1261. if(((PTR_JPGC->info.SliceCount +
  1262. 1) * (PTR_JPGC->info.sliceMbSetValue * 16)) > PTR_JPGC->info.Y)
  1263. {
  1264. PTR_JPGC->info.sliceHeight = ((PTR_JPGC->info.Y / 16) -
  1265. (PTR_JPGC->info.SliceCount *
  1266. PTR_JPGC->info.sliceHeight));
  1267. }
  1268. else
  1269. {
  1270. /* TODO! other sampling formats also than YUV420 */
  1271. if(PTR_JPGC->info.operationType == JPEGDEC_PROGRESSIVE &&
  1272. PTR_JPGC->info.componentId != 0)
  1273. PTR_JPGC->info.sliceHeight = PTR_JPGC->info.sliceMbSetValue / 2;
  1274. else
  1275. PTR_JPGC->info.sliceHeight = PTR_JPGC->info.sliceMbSetValue;
  1276. }
  1277. }
  1278. /*------------------------------------------------------------------------------
  1279. Function name: JpegDecWriteTables
  1280. Functional description:
  1281. Writes q/ac/dc tables to the HW format as specified in HW regs
  1282. Inputs:
  1283. JpegDecContainer *pJpegDecCont
  1284. Outputs:
  1285. void
  1286. ------------------------------------------------------------------------------*/
  1287. static void JpegDecWriteTables(JpegDecContainer * pJpegDecCont)
  1288. {
  1289. #define PTR_JPGC pJpegDecCont
  1290. #define JPG_SCN pJpegDecCont->scan
  1291. #define JPG_VLC pJpegDecCont->vlc
  1292. #define JPG_QTB pJpegDecCont->quant
  1293. #define JPG_FRM pJpegDecCont->frame
  1294. u32 i, j = 0;
  1295. u32 shifter = 32;
  1296. u32 tableWord = 0;
  1297. u32 tableValue = 0;
  1298. u8 tableTmp[64] = { 0 };
  1299. u32 *pTableBase = NULL;
  1300. ASSERT(PTR_JPGC);
  1301. ASSERT(PTR_JPGC->frame.pTableBase.virtualAddress);
  1302. ASSERT(PTR_JPGC->frame.pTableBase.busAddress);
  1303. ASSERT(PTR_JPGC->frame.pTableBase.size);
  1304. pTableBase = PTR_JPGC->frame.pTableBase.virtualAddress;
  1305. /* QP tables for all components */
  1306. for(j = 0; j < PTR_JPGC->info.amountOfQTables; j++)
  1307. {
  1308. if((JPG_FRM.component[j].Tq) == 0)
  1309. {
  1310. for(i = 0; i < 64; i++)
  1311. {
  1312. tableTmp[zzOrder[i]] = (u8) JPG_QTB.table0[i];
  1313. }
  1314. /* update shifter */
  1315. shifter = 32;
  1316. for(i = 0; i < 64; i++)
  1317. {
  1318. shifter -= 8;
  1319. if(shifter == 24)
  1320. tableWord = (tableTmp[i] << shifter);
  1321. else
  1322. tableWord |= (tableTmp[i] << shifter);
  1323. if(shifter == 0)
  1324. {
  1325. *(pTableBase) = tableWord;
  1326. pTableBase++;
  1327. shifter = 32;
  1328. }
  1329. }
  1330. }
  1331. else
  1332. {
  1333. for(i = 0; i < 64; i++)
  1334. {
  1335. tableTmp[zzOrder[i]] = (u8) JPG_QTB.table1[i];
  1336. }
  1337. /* update shifter */
  1338. shifter = 32;
  1339. for(i = 0; i < 64; i++)
  1340. {
  1341. shifter -= 8;
  1342. if(shifter == 24)
  1343. tableWord = (tableTmp[i] << shifter);
  1344. else
  1345. tableWord |= (tableTmp[i] << shifter);
  1346. if(shifter == 0)
  1347. {
  1348. *(pTableBase) = tableWord;
  1349. pTableBase++;
  1350. shifter = 32;
  1351. }
  1352. }
  1353. }
  1354. }
  1355. /* update shifter */
  1356. shifter = 32;
  1357. if(PTR_JPGC->info.yCbCrMode != JPEGDEC_YUV400)
  1358. {
  1359. /* this trick is done because hw always wants luma table as ac hw table 1 */
  1360. if(JPG_SCN.Ta[0] == 0)
  1361. {
  1362. /* Write AC Table 1 (as specified in HW regs)
  1363. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  1364. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  1365. if(JPG_VLC.acTable0.vals)
  1366. {
  1367. for(i = 0; i < 162; i++)
  1368. {
  1369. if(i < JPG_VLC.acTable0.tableLength)
  1370. {
  1371. tableValue = (u8) JPG_VLC.acTable0.vals[i];
  1372. }
  1373. else
  1374. {
  1375. tableValue = 0;
  1376. }
  1377. if(shifter == 32)
  1378. tableWord = (tableValue << (shifter - 8));
  1379. else
  1380. tableWord |= (tableValue << (shifter - 8));
  1381. shifter -= 8;
  1382. if(shifter == 0)
  1383. {
  1384. *(pTableBase) = tableWord;
  1385. pTableBase++;
  1386. shifter = 32;
  1387. }
  1388. }
  1389. }
  1390. else
  1391. {
  1392. for(i = 0; i < 162; i++)
  1393. {
  1394. tableWord = 0;
  1395. shifter -= 8;
  1396. if(shifter == 0)
  1397. {
  1398. *(pTableBase) = tableWord;
  1399. pTableBase++;
  1400. shifter = 32;
  1401. }
  1402. }
  1403. }
  1404. /* Write AC Table 2 */
  1405. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC2 (not-luma)\n"));
  1406. if(JPG_VLC.acTable1.vals)
  1407. {
  1408. for(i = 0; i < 162; i++)
  1409. {
  1410. if(i < JPG_VLC.acTable1.tableLength)
  1411. {
  1412. tableValue = (u8) JPG_VLC.acTable1.vals[i];
  1413. }
  1414. else
  1415. {
  1416. tableValue = 0;
  1417. }
  1418. if(shifter == 32)
  1419. tableWord = (tableValue << (shifter - 8));
  1420. else
  1421. tableWord |= (tableValue << (shifter - 8));
  1422. shifter -= 8;
  1423. if(shifter == 0)
  1424. {
  1425. *(pTableBase) = tableWord;
  1426. pTableBase++;
  1427. shifter = 32;
  1428. }
  1429. }
  1430. }
  1431. else
  1432. {
  1433. for(i = 0; i < 162; i++)
  1434. {
  1435. tableWord = 0;
  1436. shifter -= 8;
  1437. if(shifter == 0)
  1438. {
  1439. *(pTableBase) = tableWord;
  1440. pTableBase++;
  1441. shifter = 32;
  1442. }
  1443. }
  1444. }
  1445. }
  1446. else
  1447. {
  1448. /* Write AC Table 1 (as specified in HW regs)
  1449. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  1450. if(JPG_VLC.acTable1.vals)
  1451. {
  1452. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  1453. for(i = 0; i < 162; i++)
  1454. {
  1455. if(i < JPG_VLC.acTable1.tableLength)
  1456. {
  1457. tableValue = (u8) JPG_VLC.acTable1.vals[i];
  1458. }
  1459. else
  1460. {
  1461. tableValue = 0;
  1462. }
  1463. if(shifter == 32)
  1464. tableWord = (tableValue << (shifter - 8));
  1465. else
  1466. tableWord |= (tableValue << (shifter - 8));
  1467. shifter -= 8;
  1468. if(shifter == 0)
  1469. {
  1470. *(pTableBase) = tableWord;
  1471. pTableBase++;
  1472. shifter = 32;
  1473. }
  1474. }
  1475. }
  1476. else
  1477. {
  1478. for(i = 0; i < 162; i++)
  1479. {
  1480. tableWord = 0;
  1481. shifter -= 8;
  1482. if(shifter == 0)
  1483. {
  1484. *(pTableBase) = tableWord;
  1485. pTableBase++;
  1486. shifter = 32;
  1487. }
  1488. }
  1489. }
  1490. /* Write AC Table 2 */
  1491. if(JPG_VLC.acTable0.vals)
  1492. {
  1493. JPEGDEC_TRACE_INTERNAL(("INTERNAL: writeTables: AC2 (not-luma)\n"));
  1494. for(i = 0; i < 162; i++)
  1495. {
  1496. if(i < JPG_VLC.acTable0.tableLength)
  1497. {
  1498. tableValue = (u8) JPG_VLC.acTable0.vals[i];
  1499. }
  1500. else
  1501. {
  1502. tableValue = 0;
  1503. }
  1504. if(shifter == 32)
  1505. tableWord = (tableValue << (shifter - 8));
  1506. else
  1507. tableWord |= (tableValue << (shifter - 8));
  1508. shifter -= 8;
  1509. if(shifter == 0)
  1510. {
  1511. *(pTableBase) = tableWord;
  1512. pTableBase++;
  1513. shifter = 32;
  1514. }
  1515. }
  1516. }
  1517. else
  1518. {
  1519. for(i = 0; i < 162; i++)
  1520. {
  1521. tableWord = 0;
  1522. shifter -= 8;
  1523. if(shifter == 0)
  1524. {
  1525. *(pTableBase) = tableWord;
  1526. pTableBase++;
  1527. shifter = 32;
  1528. }
  1529. }
  1530. }
  1531. }
  1532. /* this trick is done because hw always wants luma table as dc hw table 1 */
  1533. if(JPG_SCN.Td[0] == 0)
  1534. {
  1535. if(JPG_VLC.dcTable0.vals)
  1536. {
  1537. for(i = 0; i < 12; i++)
  1538. {
  1539. if(i < JPG_VLC.dcTable0.tableLength)
  1540. {
  1541. tableValue = (u8) JPG_VLC.dcTable0.vals[i];
  1542. }
  1543. else
  1544. {
  1545. tableValue = 0;
  1546. }
  1547. if(shifter == 32)
  1548. tableWord = (tableValue << (shifter - 8));
  1549. else
  1550. tableWord |= (tableValue << (shifter - 8));
  1551. shifter -= 8;
  1552. if(shifter == 0)
  1553. {
  1554. *(pTableBase) = tableWord;
  1555. pTableBase++;
  1556. shifter = 32;
  1557. }
  1558. }
  1559. }
  1560. else
  1561. {
  1562. for(i = 0; i < 12; i++)
  1563. {
  1564. tableWord = 0;
  1565. shifter -= 8;
  1566. if(shifter == 0)
  1567. {
  1568. *(pTableBase) = tableWord;
  1569. pTableBase++;
  1570. shifter = 32;
  1571. }
  1572. }
  1573. }
  1574. if(JPG_VLC.dcTable1.vals)
  1575. {
  1576. for(i = 0; i < 12; i++)
  1577. {
  1578. if(i < JPG_VLC.dcTable1.tableLength)
  1579. {
  1580. tableValue = (u8) JPG_VLC.dcTable1.vals[i];
  1581. }
  1582. else
  1583. {
  1584. tableValue = 0;
  1585. }
  1586. if(shifter == 32)
  1587. tableWord = (tableValue << (shifter - 8));
  1588. else
  1589. tableWord |= (tableValue << (shifter - 8));
  1590. shifter -= 8;
  1591. if(shifter == 0)
  1592. {
  1593. *(pTableBase) = tableWord;
  1594. pTableBase++;
  1595. shifter = 32;
  1596. }
  1597. }
  1598. }
  1599. else
  1600. {
  1601. for(i = 0; i < 12; i++)
  1602. {
  1603. tableWord = 0;
  1604. shifter -= 8;
  1605. if(shifter == 0)
  1606. {
  1607. *(pTableBase) = tableWord;
  1608. pTableBase++;
  1609. shifter = 32;
  1610. }
  1611. }
  1612. }
  1613. }
  1614. else
  1615. {
  1616. if(JPG_VLC.dcTable1.vals)
  1617. {
  1618. for(i = 0; i < 12; i++)
  1619. {
  1620. if(i < JPG_VLC.dcTable1.tableLength)
  1621. {
  1622. tableValue = (u8) JPG_VLC.dcTable1.vals[i];
  1623. }
  1624. else
  1625. {
  1626. tableValue = 0;
  1627. }
  1628. if(shifter == 32)
  1629. tableWord = (tableValue << (shifter - 8));
  1630. else
  1631. tableWord |= (tableValue << (shifter - 8));
  1632. shifter -= 8;
  1633. if(shifter == 0)
  1634. {
  1635. *(pTableBase) = tableWord;
  1636. pTableBase++;
  1637. shifter = 32;
  1638. }
  1639. }
  1640. }
  1641. else
  1642. {
  1643. for(i = 0; i < 12; i++)
  1644. {
  1645. tableWord = 0;
  1646. shifter -= 8;
  1647. if(shifter == 0)
  1648. {
  1649. *(pTableBase) = tableWord;
  1650. pTableBase++;
  1651. shifter = 32;
  1652. }
  1653. }
  1654. }
  1655. if(JPG_VLC.dcTable0.vals)
  1656. {
  1657. for(i = 0; i < 12; i++)
  1658. {
  1659. if(i < JPG_VLC.dcTable0.tableLength)
  1660. {
  1661. tableValue = (u8) JPG_VLC.dcTable0.vals[i];
  1662. }
  1663. else
  1664. {
  1665. tableValue = 0;
  1666. }
  1667. if(shifter == 32)
  1668. tableWord = (tableValue << (shifter - 8));
  1669. else
  1670. tableWord |= (tableValue << (shifter - 8));
  1671. shifter -= 8;
  1672. if(shifter == 0)
  1673. {
  1674. *(pTableBase) = tableWord;
  1675. pTableBase++;
  1676. shifter = 32;
  1677. }
  1678. }
  1679. }
  1680. else
  1681. {
  1682. for(i = 0; i < 12; i++)
  1683. {
  1684. tableWord = 0;
  1685. shifter -= 8;
  1686. if(shifter == 0)
  1687. {
  1688. *(pTableBase) = tableWord;
  1689. pTableBase++;
  1690. shifter = 32;
  1691. }
  1692. }
  1693. }
  1694. }
  1695. }
  1696. else /* YUV400 */
  1697. {
  1698. if(!PTR_JPGC->info.nonInterleavedScanReady)
  1699. {
  1700. /* this trick is done because hw always wants luma table as ac hw table 1 */
  1701. if(JPG_SCN.Ta[0] == 0)
  1702. {
  1703. /* Write AC Table 1 (as specified in HW regs)
  1704. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  1705. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  1706. if(JPG_VLC.acTable0.vals)
  1707. {
  1708. for(i = 0; i < 162; i++)
  1709. {
  1710. if(i < JPG_VLC.acTable0.tableLength)
  1711. {
  1712. tableValue = (u8) JPG_VLC.acTable0.vals[i];
  1713. }
  1714. else
  1715. {
  1716. tableValue = 0;
  1717. }
  1718. if(shifter == 32)
  1719. tableWord = (tableValue << (shifter - 8));
  1720. else
  1721. tableWord |= (tableValue << (shifter - 8));
  1722. shifter -= 8;
  1723. if(shifter == 0)
  1724. {
  1725. *(pTableBase) = tableWord;
  1726. pTableBase++;
  1727. shifter = 32;
  1728. }
  1729. }
  1730. }
  1731. else
  1732. {
  1733. for(i = 0; i < 162; i++)
  1734. {
  1735. tableWord = 0;
  1736. shifter -= 8;
  1737. if(shifter == 0)
  1738. {
  1739. *(pTableBase) = tableWord;
  1740. pTableBase++;
  1741. shifter = 32;
  1742. }
  1743. }
  1744. }
  1745. /* Write AC Table 2 */
  1746. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write zero table (YUV400): \n"));
  1747. for(i = 0; i < 162; i++)
  1748. {
  1749. tableValue = 0;
  1750. if(shifter == 32)
  1751. tableWord = (tableValue << (shifter - 8));
  1752. else
  1753. tableWord |= (tableValue << (shifter - 8));
  1754. shifter -= 8;
  1755. if(shifter == 0)
  1756. {
  1757. *(pTableBase) = tableWord;
  1758. pTableBase++;
  1759. shifter = 32;
  1760. }
  1761. }
  1762. }
  1763. else
  1764. {
  1765. /* Write AC Table 1 (as specified in HW regs)
  1766. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  1767. if(JPG_VLC.acTable1.vals)
  1768. {
  1769. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  1770. for(i = 0; i < 162; i++)
  1771. {
  1772. if(i < JPG_VLC.acTable1.tableLength)
  1773. {
  1774. tableValue = (u8) JPG_VLC.acTable1.vals[i];
  1775. }
  1776. else
  1777. {
  1778. tableValue = 0;
  1779. }
  1780. if(shifter == 32)
  1781. tableWord = (tableValue << (shifter - 8));
  1782. else
  1783. tableWord |= (tableValue << (shifter - 8));
  1784. shifter -= 8;
  1785. if(shifter == 0)
  1786. {
  1787. *(pTableBase) = tableWord;
  1788. pTableBase++;
  1789. shifter = 32;
  1790. }
  1791. }
  1792. }
  1793. else
  1794. {
  1795. for(i = 0; i < 162; i++)
  1796. {
  1797. tableWord = 0;
  1798. shifter -= 8;
  1799. if(shifter == 0)
  1800. {
  1801. *(pTableBase) = tableWord;
  1802. pTableBase++;
  1803. shifter = 32;
  1804. }
  1805. }
  1806. }
  1807. /* Write AC Table 2 */
  1808. JPEGDEC_TRACE_INTERNAL(("INTERNAL: writeTables: padding zero (YUV400)\n"));
  1809. for(i = 0; i < 162; i++)
  1810. {
  1811. tableValue = 0;
  1812. if(shifter == 32)
  1813. tableWord = (tableValue << (shifter - 8));
  1814. else
  1815. tableWord |= (tableValue << (shifter - 8));
  1816. shifter -= 8;
  1817. if(shifter == 0)
  1818. {
  1819. *(pTableBase) = tableWord;
  1820. pTableBase++;
  1821. shifter = 32;
  1822. }
  1823. }
  1824. }
  1825. /* this trick is done because hw always wants luma table as dc hw table 1 */
  1826. if(JPG_SCN.Td[0] == 0)
  1827. {
  1828. if(JPG_VLC.dcTable0.vals)
  1829. {
  1830. for(i = 0; i < 12; i++)
  1831. {
  1832. if(i < JPG_VLC.dcTable0.tableLength)
  1833. {
  1834. tableValue = (u8) JPG_VLC.dcTable0.vals[i];
  1835. }
  1836. else
  1837. {
  1838. tableValue = 0;
  1839. }
  1840. if(shifter == 32)
  1841. tableWord = (tableValue << (shifter - 8));
  1842. else
  1843. tableWord |= (tableValue << (shifter - 8));
  1844. shifter -= 8;
  1845. if(shifter == 0)
  1846. {
  1847. *(pTableBase) = tableWord;
  1848. pTableBase++;
  1849. shifter = 32;
  1850. }
  1851. }
  1852. }
  1853. else
  1854. {
  1855. for(i = 0; i < 12; i++)
  1856. {
  1857. tableWord = 0;
  1858. shifter -= 8;
  1859. if(shifter == 0)
  1860. {
  1861. *(pTableBase) = tableWord;
  1862. pTableBase++;
  1863. shifter = 32;
  1864. }
  1865. }
  1866. }
  1867. for(i = 0; i < 12; i++)
  1868. {
  1869. tableValue = 0;
  1870. if(shifter == 32)
  1871. tableWord = (tableValue << (shifter - 8));
  1872. else
  1873. tableWord |= (tableValue << (shifter - 8));
  1874. shifter -= 8;
  1875. if(shifter == 0)
  1876. {
  1877. *(pTableBase) = tableWord;
  1878. pTableBase++;
  1879. shifter = 32;
  1880. }
  1881. }
  1882. }
  1883. else
  1884. {
  1885. if(JPG_VLC.dcTable1.vals)
  1886. {
  1887. for(i = 0; i < 12; i++)
  1888. {
  1889. if(i < JPG_VLC.dcTable1.tableLength)
  1890. {
  1891. tableValue = (u8) JPG_VLC.dcTable1.vals[i];
  1892. }
  1893. else
  1894. {
  1895. tableValue = 0;
  1896. }
  1897. if(shifter == 32)
  1898. tableWord = (tableValue << (shifter - 8));
  1899. else
  1900. tableWord |= (tableValue << (shifter - 8));
  1901. shifter -= 8;
  1902. if(shifter == 0)
  1903. {
  1904. *(pTableBase) = tableWord;
  1905. pTableBase++;
  1906. shifter = 32;
  1907. }
  1908. }
  1909. }
  1910. else
  1911. {
  1912. for(i = 0; i < 12; i++)
  1913. {
  1914. tableWord = 0;
  1915. shifter -= 8;
  1916. if(shifter == 0)
  1917. {
  1918. *(pTableBase) = tableWord;
  1919. pTableBase++;
  1920. shifter = 32;
  1921. }
  1922. }
  1923. }
  1924. for(i = 0; i < 12; i++)
  1925. {
  1926. tableValue = 0;
  1927. if(shifter == 32)
  1928. tableWord = (tableValue << (shifter - 8));
  1929. else
  1930. tableWord |= (tableValue << (shifter - 8));
  1931. shifter -= 8;
  1932. if(shifter == 0)
  1933. {
  1934. *(pTableBase) = tableWord;
  1935. pTableBase++;
  1936. shifter = 32;
  1937. }
  1938. }
  1939. }
  1940. }
  1941. else
  1942. {
  1943. /* this trick is done because hw always wants luma table as ac hw table 1 */
  1944. if(JPG_SCN.Ta[PTR_JPGC->info.componentId] == 0)
  1945. {
  1946. /* Write AC Table 1 (as specified in HW regs)
  1947. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  1948. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  1949. if(JPG_VLC.acTable0.vals)
  1950. {
  1951. for(i = 0; i < 162; i++)
  1952. {
  1953. if(i < JPG_VLC.acTable0.tableLength)
  1954. {
  1955. tableValue = (u8) JPG_VLC.acTable0.vals[i];
  1956. }
  1957. else
  1958. {
  1959. tableValue = 0;
  1960. }
  1961. if(shifter == 32)
  1962. tableWord = (tableValue << (shifter - 8));
  1963. else
  1964. tableWord |= (tableValue << (shifter - 8));
  1965. shifter -= 8;
  1966. if(shifter == 0)
  1967. {
  1968. *(pTableBase) = tableWord;
  1969. pTableBase++;
  1970. shifter = 32;
  1971. }
  1972. }
  1973. }
  1974. else
  1975. {
  1976. for(i = 0; i < 162; i++)
  1977. {
  1978. tableWord = 0;
  1979. shifter -= 8;
  1980. if(shifter == 0)
  1981. {
  1982. *(pTableBase) = tableWord;
  1983. pTableBase++;
  1984. shifter = 32;
  1985. }
  1986. }
  1987. }
  1988. /* Write AC Table 2 */
  1989. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write zero table (YUV400): \n"));
  1990. for(i = 0; i < 162; i++)
  1991. {
  1992. tableValue = 0;
  1993. if(shifter == 32)
  1994. tableWord = (tableValue << (shifter - 8));
  1995. else
  1996. tableWord |= (tableValue << (shifter - 8));
  1997. shifter -= 8;
  1998. if(shifter == 0)
  1999. {
  2000. *(pTableBase) = tableWord;
  2001. pTableBase++;
  2002. shifter = 32;
  2003. }
  2004. }
  2005. }
  2006. else
  2007. {
  2008. /* Write AC Table 1 (as specified in HW regs)
  2009. * NOTE: Not the same as actable[1] (as specified in JPEG Spec) */
  2010. if(JPG_VLC.acTable1.vals)
  2011. {
  2012. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write tables: AC1 (luma)\n"));
  2013. for(i = 0; i < 162; i++)
  2014. {
  2015. if(i < JPG_VLC.acTable1.tableLength)
  2016. {
  2017. tableValue = (u8) JPG_VLC.acTable1.vals[i];
  2018. }
  2019. else
  2020. {
  2021. tableValue = 0;
  2022. }
  2023. if(shifter == 32)
  2024. tableWord = (tableValue << (shifter - 8));
  2025. else
  2026. tableWord |= (tableValue << (shifter - 8));
  2027. shifter -= 8;
  2028. if(shifter == 0)
  2029. {
  2030. *(pTableBase) = tableWord;
  2031. pTableBase++;
  2032. shifter = 32;
  2033. }
  2034. }
  2035. }
  2036. else
  2037. {
  2038. for(i = 0; i < 162; i++)
  2039. {
  2040. tableWord = 0;
  2041. shifter -= 8;
  2042. if(shifter == 0)
  2043. {
  2044. *(pTableBase) = tableWord;
  2045. pTableBase++;
  2046. shifter = 32;
  2047. }
  2048. }
  2049. }
  2050. /* Write AC Table 2 */
  2051. JPEGDEC_TRACE_INTERNAL(("INTERNAL: writeTables: padding zero (YUV400)\n"));
  2052. for(i = 0; i < 162; i++)
  2053. {
  2054. tableValue = 0;
  2055. if(shifter == 32)
  2056. tableWord = (tableValue << (shifter - 8));
  2057. else
  2058. tableWord |= (tableValue << (shifter - 8));
  2059. shifter -= 8;
  2060. if(shifter == 0)
  2061. {
  2062. *(pTableBase) = tableWord;
  2063. pTableBase++;
  2064. shifter = 32;
  2065. }
  2066. }
  2067. }
  2068. /* this trick is done because hw always wants luma table as dc hw table 1 */
  2069. if(JPG_SCN.Td[PTR_JPGC->info.componentId] == 0)
  2070. {
  2071. if(JPG_VLC.dcTable0.vals)
  2072. {
  2073. for(i = 0; i < 12; i++)
  2074. {
  2075. if(i < JPG_VLC.dcTable0.tableLength)
  2076. {
  2077. tableValue = (u8) JPG_VLC.dcTable0.vals[i];
  2078. }
  2079. else
  2080. {
  2081. tableValue = 0;
  2082. }
  2083. if(shifter == 32)
  2084. tableWord = (tableValue << (shifter - 8));
  2085. else
  2086. tableWord |= (tableValue << (shifter - 8));
  2087. shifter -= 8;
  2088. if(shifter == 0)
  2089. {
  2090. *(pTableBase) = tableWord;
  2091. pTableBase++;
  2092. shifter = 32;
  2093. }
  2094. }
  2095. }
  2096. else
  2097. {
  2098. for(i = 0; i < 12; i++)
  2099. {
  2100. tableWord = 0;
  2101. shifter -= 8;
  2102. if(shifter == 0)
  2103. {
  2104. *(pTableBase) = tableWord;
  2105. pTableBase++;
  2106. shifter = 32;
  2107. }
  2108. }
  2109. }
  2110. for(i = 0; i < 12; i++)
  2111. {
  2112. tableValue = 0;
  2113. if(shifter == 32)
  2114. tableWord = (tableValue << (shifter - 8));
  2115. else
  2116. tableWord |= (tableValue << (shifter - 8));
  2117. shifter -= 8;
  2118. if(shifter == 0)
  2119. {
  2120. *(pTableBase) = tableWord;
  2121. pTableBase++;
  2122. shifter = 32;
  2123. }
  2124. }
  2125. }
  2126. else
  2127. {
  2128. if(JPG_VLC.dcTable1.vals)
  2129. {
  2130. for(i = 0; i < 12; i++)
  2131. {
  2132. if(i < JPG_VLC.dcTable1.tableLength)
  2133. {
  2134. tableValue = (u8) JPG_VLC.dcTable1.vals[i];
  2135. }
  2136. else
  2137. {
  2138. tableValue = 0;
  2139. }
  2140. if(shifter == 32)
  2141. tableWord = (tableValue << (shifter - 8));
  2142. else
  2143. tableWord |= (tableValue << (shifter - 8));
  2144. shifter -= 8;
  2145. if(shifter == 0)
  2146. {
  2147. *(pTableBase) = tableWord;
  2148. pTableBase++;
  2149. shifter = 32;
  2150. }
  2151. }
  2152. }
  2153. else
  2154. {
  2155. for(i = 0; i < 12; i++)
  2156. {
  2157. tableWord = 0;
  2158. shifter -= 8;
  2159. if(shifter == 0)
  2160. {
  2161. *(pTableBase) = tableWord;
  2162. pTableBase++;
  2163. shifter = 32;
  2164. }
  2165. }
  2166. }
  2167. for(i = 0; i < 12; i++)
  2168. {
  2169. tableValue = 0;
  2170. if(shifter == 32)
  2171. tableWord = (tableValue << (shifter - 8));
  2172. else
  2173. tableWord |= (tableValue << (shifter - 8));
  2174. shifter -= 8;
  2175. if(shifter == 0)
  2176. {
  2177. *(pTableBase) = tableWord;
  2178. pTableBase++;
  2179. shifter = 32;
  2180. }
  2181. }
  2182. }
  2183. }
  2184. }
  2185. for(i = 0; i < 4; i++)
  2186. {
  2187. tableValue = 0;
  2188. if(shifter == 32)
  2189. tableWord = (tableValue << (shifter - 8));
  2190. else
  2191. tableWord |= (tableValue << (shifter - 8));
  2192. shifter -= 8;
  2193. if(shifter == 0)
  2194. {
  2195. *(pTableBase) = tableWord;
  2196. pTableBase++;
  2197. shifter = 32;
  2198. }
  2199. }
  2200. #undef JPG_SCN
  2201. #undef JPG_VLC
  2202. #undef JPG_QTB
  2203. #undef JPG_FRM
  2204. #undef PTR_JPGC
  2205. }
  2206. /*------------------------------------------------------------------------------
  2207. Function name: JpegDecWriteTablesNonInterleaved
  2208. Functional description:
  2209. Writes q/ac/dc tables to the HW format as specified in HW regs
  2210. Inputs:
  2211. JpegDecContainer *pJpegDecCont
  2212. Outputs:
  2213. void
  2214. ------------------------------------------------------------------------------*/
  2215. static void JpegDecWriteTablesNonInterleaved(JpegDecContainer * pJpegDecCont)
  2216. {
  2217. #define PTR_JPGC pJpegDecCont
  2218. #define JPG_SCN pJpegDecCont->scan
  2219. #define JPG_VLC pJpegDecCont->vlc
  2220. #define JPG_QTB pJpegDecCont->quant
  2221. #define JPG_FRM pJpegDecCont->frame
  2222. u32 i, j = 0;
  2223. u32 tableWord = 0;
  2224. u8 tableTmp[64] = { 0 };
  2225. u8 *pTmp;
  2226. u32 *pTableBase = NULL;
  2227. u32 first, count;
  2228. u32 len, numWords;
  2229. u32 *vals;
  2230. u32 *pTable;
  2231. //u32 dcTable = 0;
  2232. u32 qpTableBase = 0;
  2233. ASSERT(PTR_JPGC);
  2234. ASSERT(PTR_JPGC->frame.pTableBase.virtualAddress);
  2235. ASSERT(PTR_JPGC->frame.pTableBase.busAddress);
  2236. ASSERT(PTR_JPGC->frame.pTableBase.size);
  2237. ASSERT(PTR_JPGC->info.nonInterleaved);
  2238. /* Reset the table memory */
  2239. (void) DWLmemset(PTR_JPGC->frame.pTableBase.virtualAddress, 0,
  2240. (sizeof(u8) * JPEGDEC_BASELINE_TABLE_SIZE));
  2241. pTableBase = PTR_JPGC->frame.pTableBase.virtualAddress;
  2242. first = PTR_JPGC->info.componentId;
  2243. count = 1;
  2244. /* QP tables for all components */
  2245. for(j = first; j < first + count; j++)
  2246. {
  2247. if((JPG_FRM.component[j].Tq) == 0)
  2248. pTable = JPG_QTB.table0;
  2249. else
  2250. pTable = JPG_QTB.table1;
  2251. for(i = 0; i < 64; i++)
  2252. {
  2253. tableTmp[zzOrder[i]] = (u8) pTable[i];
  2254. }
  2255. pTmp = tableTmp;
  2256. for(i = 0; i < 16; i++)
  2257. {
  2258. tableWord = (pTmp[0] << 24) | (pTmp[1] << 16) |
  2259. (pTmp[2] << 8) | (pTmp[3] << 0);;
  2260. *pTableBase++ = tableWord;
  2261. pTmp += 4;
  2262. }
  2263. }
  2264. /* AC table */
  2265. for(i = first; i < first + count; i++)
  2266. {
  2267. numWords = 162;
  2268. switch (JPG_SCN.Ta[i])
  2269. {
  2270. case 0:
  2271. vals = JPG_VLC.acTable0.vals;
  2272. len = JPG_VLC.acTable0.tableLength;
  2273. break;
  2274. case 1:
  2275. vals = JPG_VLC.acTable1.vals;
  2276. len = JPG_VLC.acTable1.tableLength;
  2277. break;
  2278. case 2:
  2279. vals = JPG_VLC.acTable2.vals;
  2280. len = JPG_VLC.acTable2.tableLength;
  2281. break;
  2282. default:
  2283. vals = JPG_VLC.acTable3.vals;
  2284. len = JPG_VLC.acTable3.tableLength;
  2285. break;
  2286. }
  2287. /* set pointer */
  2288. if(count == 3)
  2289. qpTableBase = 0;
  2290. else
  2291. qpTableBase = JPEGDEC_QP_BASE;
  2292. pTableBase =
  2293. &PTR_JPGC->frame.pTableBase.virtualAddress[JPEGDEC_AC1_BASE -
  2294. qpTableBase];
  2295. for(j = 0; j < numWords; j++)
  2296. {
  2297. tableWord <<= 8;
  2298. if(j < len)
  2299. tableWord |= vals[j];
  2300. if((j & 0x3) == 0x3)
  2301. *pTableBase++ = tableWord;
  2302. }
  2303. /* fill to border */
  2304. numWords = 164;
  2305. len = 164;
  2306. for(j = 162; j < numWords; j++)
  2307. {
  2308. tableWord <<= 8;
  2309. if(j < len)
  2310. tableWord |= 0;
  2311. if((j & 0x3) == 0x3)
  2312. *pTableBase++ = tableWord;
  2313. }
  2314. }
  2315. /* DC table */
  2316. for(i = first; i < first + count; i++)
  2317. {
  2318. numWords = 12;
  2319. switch (JPG_SCN.Td[i])
  2320. {
  2321. case 0:
  2322. vals = JPG_VLC.dcTable0.vals;
  2323. len = JPG_VLC.dcTable0.tableLength;
  2324. break;
  2325. case 1:
  2326. vals = JPG_VLC.dcTable1.vals;
  2327. len = JPG_VLC.dcTable1.tableLength;
  2328. break;
  2329. case 2:
  2330. vals = JPG_VLC.dcTable2.vals;
  2331. len = JPG_VLC.dcTable2.tableLength;
  2332. break;
  2333. default:
  2334. vals = JPG_VLC.dcTable3.vals;
  2335. len = JPG_VLC.dcTable3.tableLength;
  2336. break;
  2337. }
  2338. /* set pointer */
  2339. if(count == 3)
  2340. qpTableBase = 0;
  2341. else
  2342. qpTableBase = JPEGDEC_QP_BASE;
  2343. pTableBase =
  2344. &PTR_JPGC->frame.pTableBase.virtualAddress[JPEGDEC_DC1_BASE -
  2345. qpTableBase];
  2346. for(j = 0; j < numWords; j++)
  2347. {
  2348. tableWord <<= 8;
  2349. if(j < len)
  2350. tableWord |= vals[j];
  2351. if((j & 0x3) == 0x3)
  2352. *pTableBase++ = tableWord;
  2353. }
  2354. }
  2355. *pTableBase = 0;
  2356. #undef JPG_SCN
  2357. #undef JPG_VLC
  2358. #undef JPG_QTB
  2359. #undef JPG_FRM
  2360. #undef PTR_JPGC
  2361. }
  2362. /*------------------------------------------------------------------------------
  2363. Function name: JpegDecWriteTablesProgressive
  2364. Functional description:
  2365. Writes q/ac/dc tables to the HW format as specified in HW regs
  2366. Inputs:
  2367. JpegDecContainer *pJpegDecCont
  2368. Outputs:
  2369. void
  2370. ------------------------------------------------------------------------------*/
  2371. static void JpegDecWriteTablesProgressive(JpegDecContainer * pJpegDecCont)
  2372. {
  2373. #define PTR_JPGC pJpegDecCont
  2374. #define JPG_SCN pJpegDecCont->scan
  2375. #define JPG_VLC pJpegDecCont->vlc
  2376. #define JPG_QTB pJpegDecCont->quant
  2377. #define JPG_FRM pJpegDecCont->frame
  2378. u32 i, j = 0;
  2379. u32 tableWord = 0;
  2380. u8 tableTmp[64] = { 0 };
  2381. u8 *pTmp;
  2382. u32 *pTableBase = NULL;
  2383. u32 first, count;
  2384. u32 len, numWords;
  2385. u32 *vals;
  2386. u32 *pTable;
  2387. u32 dcTable = 0;
  2388. u32 qpTableBase = 0;
  2389. ASSERT(PTR_JPGC);
  2390. ASSERT(PTR_JPGC->frame.pTableBase.virtualAddress);
  2391. ASSERT(PTR_JPGC->frame.pTableBase.busAddress);
  2392. ASSERT(PTR_JPGC->frame.pTableBase.size);
  2393. /* Reset the table memory */
  2394. (void) DWLmemset(PTR_JPGC->frame.pTableBase.virtualAddress, 0,
  2395. (sizeof(u8) * JPEGDEC_PROGRESSIVE_TABLE_SIZE));
  2396. pTableBase = PTR_JPGC->frame.pTableBase.virtualAddress;
  2397. if(PTR_JPGC->info.nonInterleaved)
  2398. {
  2399. first = PTR_JPGC->info.componentId;
  2400. count = 1;
  2401. }
  2402. else
  2403. {
  2404. first = 0;
  2405. count = 3;
  2406. }
  2407. /* QP tables for all components */
  2408. for(j = first; j < first + count; j++)
  2409. {
  2410. if((JPG_FRM.component[j].Tq) == 0)
  2411. pTable = JPG_QTB.table0;
  2412. else
  2413. pTable = JPG_QTB.table1;
  2414. for(i = 0; i < 64; i++)
  2415. {
  2416. tableTmp[zzOrder[i]] = (u8) pTable[i];
  2417. }
  2418. pTmp = tableTmp;
  2419. for(i = 0; i < 16; i++)
  2420. {
  2421. tableWord = (pTmp[0] << 24) | (pTmp[1] << 16) |
  2422. (pTmp[2] << 8) | (pTmp[3] << 0);;
  2423. *pTableBase++ = tableWord;
  2424. pTmp += 4;
  2425. }
  2426. }
  2427. /* if later stage DC ==> no need for table */
  2428. if(PTR_JPGC->scan.Ah != 0 && PTR_JPGC->scan.Ss == 0)
  2429. return;
  2430. for(i = first; i < first + count; i++)
  2431. {
  2432. if(PTR_JPGC->scan.Ss == 0) /* DC */
  2433. {
  2434. dcTable = 1;
  2435. numWords = 12;
  2436. switch (JPG_SCN.Td[i])
  2437. {
  2438. case 0:
  2439. vals = JPG_VLC.dcTable0.vals;
  2440. len = JPG_VLC.dcTable0.tableLength;
  2441. break;
  2442. case 1:
  2443. vals = JPG_VLC.dcTable1.vals;
  2444. len = JPG_VLC.dcTable1.tableLength;
  2445. break;
  2446. case 2:
  2447. vals = JPG_VLC.dcTable2.vals;
  2448. len = JPG_VLC.dcTable2.tableLength;
  2449. break;
  2450. default:
  2451. vals = JPG_VLC.dcTable3.vals;
  2452. len = JPG_VLC.dcTable3.tableLength;
  2453. break;
  2454. }
  2455. }
  2456. else
  2457. {
  2458. numWords = 162;
  2459. switch (JPG_SCN.Ta[i])
  2460. {
  2461. case 0:
  2462. vals = JPG_VLC.acTable0.vals;
  2463. len = JPG_VLC.acTable0.tableLength;
  2464. break;
  2465. case 1:
  2466. vals = JPG_VLC.acTable1.vals;
  2467. len = JPG_VLC.acTable1.tableLength;
  2468. break;
  2469. case 2:
  2470. vals = JPG_VLC.acTable2.vals;
  2471. len = JPG_VLC.acTable2.tableLength;
  2472. break;
  2473. default:
  2474. vals = JPG_VLC.acTable3.vals;
  2475. len = JPG_VLC.acTable3.tableLength;
  2476. break;
  2477. }
  2478. }
  2479. /* set pointer */
  2480. if(count == 3)
  2481. qpTableBase = 0;
  2482. else
  2483. qpTableBase = JPEGDEC_QP_BASE;
  2484. if(dcTable)
  2485. {
  2486. /* interleaved || non-interleaved */
  2487. if(count == 3)
  2488. {
  2489. if(i == 0)
  2490. pTableBase =
  2491. &PTR_JPGC->frame.pTableBase.
  2492. virtualAddress[JPEGDEC_DC1_BASE - qpTableBase];
  2493. else if(i == 1)
  2494. pTableBase =
  2495. &PTR_JPGC->frame.pTableBase.
  2496. virtualAddress[JPEGDEC_DC2_BASE - qpTableBase];
  2497. else
  2498. pTableBase =
  2499. &PTR_JPGC->frame.pTableBase.
  2500. virtualAddress[JPEGDEC_DC3_BASE - qpTableBase];
  2501. }
  2502. else
  2503. {
  2504. pTableBase =
  2505. &PTR_JPGC->frame.pTableBase.
  2506. virtualAddress[JPEGDEC_DC1_BASE - qpTableBase];
  2507. }
  2508. }
  2509. else
  2510. {
  2511. pTableBase =
  2512. &PTR_JPGC->frame.pTableBase.virtualAddress[JPEGDEC_AC1_BASE -
  2513. qpTableBase];
  2514. }
  2515. for(j = 0; j < numWords; j++)
  2516. {
  2517. tableWord <<= 8;
  2518. if(j < len)
  2519. tableWord |= vals[j];
  2520. if((j & 0x3) == 0x3)
  2521. *pTableBase++ = tableWord;
  2522. }
  2523. /* fill to border */
  2524. if(i == 0 && dcTable == 0)
  2525. {
  2526. numWords = 164;
  2527. len = 164;
  2528. for(j = 162; j < numWords; j++)
  2529. {
  2530. tableWord <<= 8;
  2531. if(j < len)
  2532. tableWord |= 0;
  2533. if((j & 0x3) == 0x3)
  2534. *pTableBase++ = tableWord;
  2535. }
  2536. }
  2537. /* reset */
  2538. dcTable = 0;
  2539. }
  2540. *pTableBase = 0;
  2541. #undef JPG_SCN
  2542. #undef JPG_VLC
  2543. #undef JPG_QTB
  2544. #undef JPG_FRM
  2545. #undef PTR_JPGC
  2546. }
  2547. /*------------------------------------------------------------------------------
  2548. Function name: JpegDecChromaTableSelectors
  2549. Functional description:
  2550. select what tables chromas use
  2551. Inputs:
  2552. JpegDecContainer *pJpegDecCont
  2553. Outputs:
  2554. void
  2555. ------------------------------------------------------------------------------*/
  2556. static void JpegDecChromaTableSelectors(JpegDecContainer * pJpegDecCont)
  2557. {
  2558. #define PTR_JPGC pJpegDecCont
  2559. #define JPG_SCN pJpegDecCont->scan
  2560. #define JPG_FRM pJpegDecCont->frame
  2561. /* this trick is done because hw always wants luma table as ac hw table 1 */
  2562. if(JPG_SCN.Ta[0] == 0)
  2563. {
  2564. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_AC_VLCTABLE, JPG_SCN.Ta[2]);
  2565. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_AC_VLCTABLE, JPG_SCN.Ta[1]);
  2566. }
  2567. else
  2568. {
  2569. if(JPG_SCN.Ta[0] == JPG_SCN.Ta[1])
  2570. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_AC_VLCTABLE, 0);
  2571. else
  2572. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_AC_VLCTABLE, 1);
  2573. if(JPG_SCN.Ta[0] == JPG_SCN.Ta[2])
  2574. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_AC_VLCTABLE, 0);
  2575. else
  2576. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_AC_VLCTABLE, 1);
  2577. }
  2578. /* Third DC table selectors */
  2579. if(PTR_JPGC->info.operationType != JPEGDEC_PROGRESSIVE)
  2580. {
  2581. if(JPG_SCN.Td[0] == 0)
  2582. {
  2583. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE,
  2584. JPG_SCN.Td[2]);
  2585. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE,
  2586. JPG_SCN.Td[1]);
  2587. }
  2588. else
  2589. {
  2590. if(JPG_SCN.Td[0] == JPG_SCN.Td[1])
  2591. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE, 0);
  2592. else
  2593. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE, 1);
  2594. if(JPG_SCN.Td[0] == JPG_SCN.Td[2])
  2595. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE, 0);
  2596. else
  2597. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE, 1);
  2598. }
  2599. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE3, 0);
  2600. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE3, 0);
  2601. }
  2602. else
  2603. {
  2604. /* if non-interleaved ==> decoding mode YUV400, uses table zero (0) */
  2605. if(PTR_JPGC->info.nonInterleaved)
  2606. {
  2607. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE, 0);
  2608. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE, 0);
  2609. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE3, 0);
  2610. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE3, 0);
  2611. }
  2612. else
  2613. {
  2614. /* if later stage DC ==> no need for table */
  2615. if(PTR_JPGC->scan.Ah != 0 && PTR_JPGC->scan.Ss == 0)
  2616. {
  2617. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE, 0);
  2618. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE3, 0);
  2619. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE, 0);
  2620. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE3, 0);
  2621. }
  2622. else
  2623. {
  2624. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE, 0);
  2625. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CR_DC_VLCTABLE3, 1);
  2626. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE, 1);
  2627. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_CB_DC_VLCTABLE3, 0);
  2628. }
  2629. }
  2630. }
  2631. return;
  2632. #undef JPG_SCN
  2633. #undef JPG_FRM
  2634. #undef PTR_JPGC
  2635. }
  2636. /*------------------------------------------------------------------------------
  2637. Function name: JpegDecWriteLenBits
  2638. Functional description:
  2639. tell hw how many vlc words of different lengths we have
  2640. Inputs:
  2641. JpegDecContainer *pJpegDecCont
  2642. Outputs:
  2643. void
  2644. ------------------------------------------------------------------------------*/
  2645. static void JpegDecWriteLenBits(JpegDecContainer * pJpegDecCont)
  2646. {
  2647. #define PTR_JPGC pJpegDecCont
  2648. #define JPG_SCN pJpegDecCont->scan
  2649. #define JPG_VLC pJpegDecCont->vlc
  2650. #define JPG_QTB pJpegDecCont->quant
  2651. #define JPG_FRM pJpegDecCont->frame
  2652. VlcTable *pTable1 = NULL;
  2653. VlcTable *pTable2 = NULL;
  2654. /* first select the table we'll use */
  2655. /* this trick is done because hw always wants luma table as ac hw table 1 */
  2656. if(JPG_SCN.Ta[0] == 0)
  2657. {
  2658. pTable1 = &(JPG_VLC.acTable0);
  2659. pTable2 = &(JPG_VLC.acTable1);
  2660. }
  2661. else
  2662. {
  2663. pTable1 = &(JPG_VLC.acTable1);
  2664. pTable2 = &(JPG_VLC.acTable0);
  2665. }
  2666. ASSERT(pTable1);
  2667. ASSERT(pTable2);
  2668. /* write AC table 1 (luma) */
  2669. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE1_CNT, pTable1->bits[0]);
  2670. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE2_CNT, pTable1->bits[1]);
  2671. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE3_CNT, pTable1->bits[2]);
  2672. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE4_CNT, pTable1->bits[3]);
  2673. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE5_CNT, pTable1->bits[4]);
  2674. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE6_CNT, pTable1->bits[5]);
  2675. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE7_CNT, pTable1->bits[6]);
  2676. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE8_CNT, pTable1->bits[7]);
  2677. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE9_CNT, pTable1->bits[8]);
  2678. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE10_CNT, pTable1->bits[9]);
  2679. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE11_CNT, pTable1->bits[10]);
  2680. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE12_CNT, pTable1->bits[11]);
  2681. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE13_CNT, pTable1->bits[12]);
  2682. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE14_CNT, pTable1->bits[13]);
  2683. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE15_CNT, pTable1->bits[14]);
  2684. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE16_CNT, pTable1->bits[15]);
  2685. /* table AC2 (the not-luma table) */
  2686. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE1_CNT, pTable2->bits[0]);
  2687. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE2_CNT, pTable2->bits[1]);
  2688. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE3_CNT, pTable2->bits[2]);
  2689. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE4_CNT, pTable2->bits[3]);
  2690. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE5_CNT, pTable2->bits[4]);
  2691. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE6_CNT, pTable2->bits[5]);
  2692. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE7_CNT, pTable2->bits[6]);
  2693. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE8_CNT, pTable2->bits[7]);
  2694. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE9_CNT, pTable2->bits[8]);
  2695. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE10_CNT, pTable2->bits[9]);
  2696. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE11_CNT, pTable2->bits[10]);
  2697. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE12_CNT, pTable2->bits[11]);
  2698. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE13_CNT, pTable2->bits[12]);
  2699. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE14_CNT, pTable2->bits[13]);
  2700. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE15_CNT, pTable2->bits[14]);
  2701. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC2_CODE16_CNT, pTable2->bits[15]);
  2702. if(JPG_SCN.Td[0] == 0)
  2703. {
  2704. pTable1 = &(JPG_VLC.dcTable0);
  2705. pTable2 = &(JPG_VLC.dcTable1);
  2706. }
  2707. else
  2708. {
  2709. pTable1 = &(JPG_VLC.dcTable1);
  2710. pTable2 = &(JPG_VLC.dcTable0);
  2711. }
  2712. ASSERT(pTable1);
  2713. ASSERT(pTable2);
  2714. /* write DC table 1 (luma) */
  2715. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT, pTable1->bits[0]);
  2716. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT, pTable1->bits[1]);
  2717. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT, pTable1->bits[2]);
  2718. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT, pTable1->bits[3]);
  2719. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT, pTable1->bits[4]);
  2720. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT, pTable1->bits[5]);
  2721. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT, pTable1->bits[6]);
  2722. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT, pTable1->bits[7]);
  2723. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT, pTable1->bits[8]);
  2724. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT, pTable1->bits[9]);
  2725. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT, pTable1->bits[10]);
  2726. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT, pTable1->bits[11]);
  2727. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT, pTable1->bits[12]);
  2728. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT, pTable1->bits[13]);
  2729. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT, pTable1->bits[14]);
  2730. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT, pTable1->bits[15]);
  2731. /* table DC2 (the not-luma table) */
  2732. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE1_CNT, pTable2->bits[0]);
  2733. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE2_CNT, pTable2->bits[1]);
  2734. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE3_CNT, pTable2->bits[2]);
  2735. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE4_CNT, pTable2->bits[3]);
  2736. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE5_CNT, pTable2->bits[4]);
  2737. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE6_CNT, pTable2->bits[5]);
  2738. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE7_CNT, pTable2->bits[6]);
  2739. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE8_CNT, pTable2->bits[7]);
  2740. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE9_CNT, pTable2->bits[8]);
  2741. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE10_CNT, pTable2->bits[9]);
  2742. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE11_CNT, pTable2->bits[10]);
  2743. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE12_CNT, pTable2->bits[11]);
  2744. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE13_CNT, pTable2->bits[12]);
  2745. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE14_CNT, pTable2->bits[13]);
  2746. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE15_CNT, pTable2->bits[14]);
  2747. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE16_CNT, pTable2->bits[15]);
  2748. return;
  2749. #undef JPG_SCN
  2750. #undef JPG_VLC
  2751. #undef JPG_QTB
  2752. #undef JPG_FRM
  2753. #undef PTR_JPGC
  2754. }
  2755. /*------------------------------------------------------------------------------
  2756. Function name: JpegDecWriteLenBitsNonInterleaved
  2757. Functional description:
  2758. tell hw how many vlc words of different lengths we have
  2759. Inputs:
  2760. JpegDecContainer *pJpegDecCont
  2761. Outputs:
  2762. void
  2763. ------------------------------------------------------------------------------*/
  2764. static void JpegDecWriteLenBitsNonInterleaved(JpegDecContainer * pJpegDecCont)
  2765. {
  2766. #define PTR_JPGC pJpegDecCont
  2767. #define JPG_SCN pJpegDecCont->scan
  2768. #define JPG_VLC pJpegDecCont->vlc
  2769. #define JPG_QTB pJpegDecCont->quant
  2770. #define JPG_FRM pJpegDecCont->frame
  2771. VlcTable *pTable1 = NULL;
  2772. VlcTable *pTable2 = NULL;
  2773. /* first select the table we'll use */
  2774. /* this trick is done because hw always wants luma table as ac hw table 1 */
  2775. if(JPG_SCN.Ta[PTR_JPGC->info.componentId] == 0)
  2776. {
  2777. pTable1 = &(JPG_VLC.acTable0);
  2778. pTable2 = &(JPG_VLC.acTable1);
  2779. }
  2780. else
  2781. {
  2782. pTable1 = &(JPG_VLC.acTable1);
  2783. pTable2 = &(JPG_VLC.acTable0);
  2784. }
  2785. ASSERT(pTable1);
  2786. ASSERT(pTable2);
  2787. /* write AC table 1 (luma) */
  2788. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE1_CNT, pTable1->bits[0]);
  2789. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE2_CNT, pTable1->bits[1]);
  2790. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE3_CNT, pTable1->bits[2]);
  2791. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE4_CNT, pTable1->bits[3]);
  2792. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE5_CNT, pTable1->bits[4]);
  2793. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE6_CNT, pTable1->bits[5]);
  2794. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE7_CNT, pTable1->bits[6]);
  2795. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE8_CNT, pTable1->bits[7]);
  2796. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE9_CNT, pTable1->bits[8]);
  2797. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE10_CNT, pTable1->bits[9]);
  2798. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE11_CNT, pTable1->bits[10]);
  2799. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE12_CNT, pTable1->bits[11]);
  2800. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE13_CNT, pTable1->bits[12]);
  2801. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE14_CNT, pTable1->bits[13]);
  2802. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE15_CNT, pTable1->bits[14]);
  2803. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE16_CNT, pTable1->bits[15]);
  2804. if(JPG_SCN.Td[PTR_JPGC->info.componentId] == 0)
  2805. {
  2806. pTable1 = &(JPG_VLC.dcTable0);
  2807. pTable2 = &(JPG_VLC.dcTable1);
  2808. }
  2809. else
  2810. {
  2811. pTable1 = &(JPG_VLC.dcTable1);
  2812. pTable2 = &(JPG_VLC.dcTable0);
  2813. }
  2814. ASSERT(pTable1);
  2815. ASSERT(pTable2);
  2816. /* write DC table 1 (luma) */
  2817. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT, pTable1->bits[0]);
  2818. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT, pTable1->bits[1]);
  2819. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT, pTable1->bits[2]);
  2820. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT, pTable1->bits[3]);
  2821. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT, pTable1->bits[4]);
  2822. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT, pTable1->bits[5]);
  2823. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT, pTable1->bits[6]);
  2824. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT, pTable1->bits[7]);
  2825. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT, pTable1->bits[8]);
  2826. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT, pTable1->bits[9]);
  2827. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT, pTable1->bits[10]);
  2828. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT, pTable1->bits[11]);
  2829. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT, pTable1->bits[12]);
  2830. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT, pTable1->bits[13]);
  2831. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT, pTable1->bits[14]);
  2832. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT, pTable1->bits[15]);
  2833. return;
  2834. #undef JPG_SCN
  2835. #undef JPG_VLC
  2836. #undef JPG_QTB
  2837. #undef JPG_FRM
  2838. #undef PTR_JPGC
  2839. }
  2840. /*------------------------------------------------------------------------------
  2841. Function name: JpegDecWriteLenBitsProgressive
  2842. Functional description:
  2843. tell hw how many vlc words of different lengths we have
  2844. Inputs:
  2845. JpegDecContainer *pJpegDecCont
  2846. Outputs:
  2847. void
  2848. ------------------------------------------------------------------------------*/
  2849. static void JpegDecWriteLenBitsProgressive(JpegDecContainer * pJpegDecCont)
  2850. {
  2851. u32 i;
  2852. #define PTR_JPGC pJpegDecCont
  2853. #define JPG_SCN pJpegDecCont->scan
  2854. #define JPG_VLC pJpegDecCont->vlc
  2855. #define JPG_QTB pJpegDecCont->quant
  2856. #define JPG_FRM pJpegDecCont->frame
  2857. VlcTable *pTable1 = NULL;
  2858. VlcTable *pTable2 = NULL;
  2859. VlcTable *pTable3 = NULL;
  2860. //VlcTable *pTable4 = NULL;
  2861. /* reset swregs that contains vlc length information: swregs [16-28] */
  2862. for(i = JPEGDEC_VLC_LEN_START_REG; i < JPEGDEC_VLC_LEN_END_REG; i++)
  2863. PTR_JPGC->jpegRegs[i] = 0;
  2864. /* check if interleaved scan ==> only one table needed */
  2865. if(PTR_JPGC->info.nonInterleaved)
  2866. {
  2867. /* check if AC or DC coefficient scan */
  2868. if(PTR_JPGC->scan.Ss == 0) /* DC */
  2869. {
  2870. /* check component \CDD */
  2871. if(PTR_JPGC->info.componentId == 0)
  2872. {
  2873. if(JPG_SCN.Td[0] == 0)
  2874. pTable1 = &(JPG_VLC.dcTable0);
  2875. else if(JPG_SCN.Td[0] == 1)
  2876. pTable1 = &(JPG_VLC.dcTable1);
  2877. else if(JPG_SCN.Td[0] == 2)
  2878. pTable1 = &(JPG_VLC.dcTable2);
  2879. else
  2880. pTable1 = &(JPG_VLC.dcTable3);
  2881. }
  2882. else if(PTR_JPGC->info.componentId == 1)
  2883. {
  2884. if(JPG_SCN.Td[1] == 0)
  2885. pTable1 = &(JPG_VLC.dcTable0);
  2886. else if(JPG_SCN.Td[1] == 1)
  2887. pTable1 = &(JPG_VLC.dcTable1);
  2888. else if(JPG_SCN.Td[1] == 2)
  2889. pTable1 = &(JPG_VLC.dcTable2);
  2890. else
  2891. pTable1 = &(JPG_VLC.dcTable3);
  2892. }
  2893. else
  2894. {
  2895. if(JPG_SCN.Td[2] == 0)
  2896. pTable1 = &(JPG_VLC.dcTable0);
  2897. else if(JPG_SCN.Td[2] == 1)
  2898. pTable1 = &(JPG_VLC.dcTable1);
  2899. else if(JPG_SCN.Td[2] == 2)
  2900. pTable1 = &(JPG_VLC.dcTable2);
  2901. else
  2902. pTable1 = &(JPG_VLC.dcTable3);
  2903. }
  2904. ASSERT(pTable1);
  2905. /* if later stage DC ==> no need for table */
  2906. if(PTR_JPGC->scan.Ah == 0)
  2907. {
  2908. /* write DC table 1 */
  2909. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT,
  2910. pTable1->bits[0]);
  2911. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT,
  2912. pTable1->bits[1]);
  2913. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT,
  2914. pTable1->bits[2]);
  2915. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT,
  2916. pTable1->bits[3]);
  2917. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT,
  2918. pTable1->bits[4]);
  2919. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT,
  2920. pTable1->bits[5]);
  2921. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT,
  2922. pTable1->bits[6]);
  2923. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT,
  2924. pTable1->bits[7]);
  2925. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT,
  2926. pTable1->bits[8]);
  2927. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT,
  2928. pTable1->bits[9]);
  2929. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT,
  2930. pTable1->bits[10]);
  2931. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT,
  2932. pTable1->bits[11]);
  2933. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT,
  2934. pTable1->bits[12]);
  2935. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT,
  2936. pTable1->bits[13]);
  2937. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT,
  2938. pTable1->bits[14]);
  2939. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT,
  2940. pTable1->bits[15]);
  2941. }
  2942. else
  2943. {
  2944. /* write zero table */
  2945. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT, 0);
  2946. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT, 0);
  2947. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT, 0);
  2948. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT, 0);
  2949. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT, 0);
  2950. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT, 0);
  2951. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT, 0);
  2952. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT, 0);
  2953. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT, 0);
  2954. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT, 0);
  2955. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT, 0);
  2956. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT, 0);
  2957. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT, 0);
  2958. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT, 0);
  2959. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT, 0);
  2960. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT, 0);
  2961. }
  2962. }
  2963. else /* AC */
  2964. {
  2965. /* check component \CDD */
  2966. if(PTR_JPGC->info.componentId == 0)
  2967. {
  2968. if(JPG_SCN.Ta[0] == 0)
  2969. pTable1 = &(JPG_VLC.acTable0);
  2970. else if(JPG_SCN.Ta[0] == 1)
  2971. pTable1 = &(JPG_VLC.acTable1);
  2972. else if(JPG_SCN.Ta[0] == 2)
  2973. pTable1 = &(JPG_VLC.acTable2);
  2974. else
  2975. pTable1 = &(JPG_VLC.acTable3);
  2976. }
  2977. else if(PTR_JPGC->info.componentId == 1)
  2978. {
  2979. if(JPG_SCN.Ta[1] == 0)
  2980. pTable1 = &(JPG_VLC.acTable0);
  2981. else if(JPG_SCN.Ta[1] == 1)
  2982. pTable1 = &(JPG_VLC.acTable1);
  2983. else if(JPG_SCN.Ta[1] == 2)
  2984. pTable1 = &(JPG_VLC.acTable2);
  2985. else
  2986. pTable1 = &(JPG_VLC.acTable3);
  2987. }
  2988. else
  2989. {
  2990. if(JPG_SCN.Ta[2] == 0)
  2991. pTable1 = &(JPG_VLC.acTable0);
  2992. else if(JPG_SCN.Ta[2] == 1)
  2993. pTable1 = &(JPG_VLC.acTable1);
  2994. else if(JPG_SCN.Ta[2] == 2)
  2995. pTable1 = &(JPG_VLC.acTable2);
  2996. else
  2997. pTable1 = &(JPG_VLC.acTable3);
  2998. }
  2999. ASSERT(pTable1);
  3000. /* write AC table 1 */
  3001. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE1_CNT,
  3002. pTable1->bits[0]);
  3003. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE2_CNT,
  3004. pTable1->bits[1]);
  3005. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE3_CNT,
  3006. pTable1->bits[2]);
  3007. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE4_CNT,
  3008. pTable1->bits[3]);
  3009. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE5_CNT,
  3010. pTable1->bits[4]);
  3011. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE6_CNT,
  3012. pTable1->bits[5]);
  3013. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE7_CNT,
  3014. pTable1->bits[6]);
  3015. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE8_CNT,
  3016. pTable1->bits[7]);
  3017. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE9_CNT,
  3018. pTable1->bits[8]);
  3019. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE10_CNT,
  3020. pTable1->bits[9]);
  3021. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE11_CNT,
  3022. pTable1->bits[10]);
  3023. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE12_CNT,
  3024. pTable1->bits[11]);
  3025. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE13_CNT,
  3026. pTable1->bits[12]);
  3027. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE14_CNT,
  3028. pTable1->bits[13]);
  3029. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE15_CNT,
  3030. pTable1->bits[14]);
  3031. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_AC1_CODE16_CNT,
  3032. pTable1->bits[15]);
  3033. }
  3034. }
  3035. else /* interleaved */
  3036. {
  3037. /* first select the table we'll use */
  3038. /* this trick is done because hw always wants luma table as ac hw table 1 */
  3039. if(JPG_SCN.Td[0] == 0)
  3040. pTable1 = &(JPG_VLC.dcTable0);
  3041. else if(JPG_SCN.Td[0] == 1)
  3042. pTable1 = &(JPG_VLC.dcTable1);
  3043. else if(JPG_SCN.Td[0] == 2)
  3044. pTable1 = &(JPG_VLC.dcTable2);
  3045. else
  3046. pTable1 = &(JPG_VLC.dcTable3);
  3047. if(JPG_SCN.Td[1] == 0)
  3048. pTable2 = &(JPG_VLC.dcTable0);
  3049. else if(JPG_SCN.Td[1] == 1)
  3050. pTable2 = &(JPG_VLC.dcTable1);
  3051. else if(JPG_SCN.Td[1] == 2)
  3052. pTable2 = &(JPG_VLC.dcTable2);
  3053. else
  3054. pTable2 = &(JPG_VLC.dcTable3);
  3055. if(JPG_SCN.Td[2] == 0)
  3056. pTable3 = &(JPG_VLC.dcTable0);
  3057. else if(JPG_SCN.Td[2] == 1)
  3058. pTable3 = &(JPG_VLC.dcTable1);
  3059. else if(JPG_SCN.Td[2] == 2)
  3060. pTable3 = &(JPG_VLC.dcTable2);
  3061. else
  3062. pTable3 = &(JPG_VLC.dcTable3);
  3063. ASSERT(pTable1);
  3064. ASSERT(pTable2);
  3065. ASSERT(pTable3);
  3066. /* if later stage DC ==> no need for table */
  3067. if(PTR_JPGC->scan.Ah == 0)
  3068. {
  3069. /* write DC table 1 (luma) */
  3070. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT,
  3071. pTable1->bits[0]);
  3072. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT,
  3073. pTable1->bits[1]);
  3074. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT,
  3075. pTable1->bits[2]);
  3076. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT,
  3077. pTable1->bits[3]);
  3078. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT,
  3079. pTable1->bits[4]);
  3080. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT,
  3081. pTable1->bits[5]);
  3082. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT,
  3083. pTable1->bits[6]);
  3084. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT,
  3085. pTable1->bits[7]);
  3086. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT,
  3087. pTable1->bits[8]);
  3088. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT,
  3089. pTable1->bits[9]);
  3090. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT,
  3091. pTable1->bits[10]);
  3092. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT,
  3093. pTable1->bits[11]);
  3094. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT,
  3095. pTable1->bits[12]);
  3096. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT,
  3097. pTable1->bits[13]);
  3098. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT,
  3099. pTable1->bits[14]);
  3100. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT,
  3101. pTable1->bits[15]);
  3102. /* table DC2 (Cb) */
  3103. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE1_CNT,
  3104. pTable2->bits[0]);
  3105. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE2_CNT,
  3106. pTable2->bits[1]);
  3107. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE3_CNT,
  3108. pTable2->bits[2]);
  3109. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE4_CNT,
  3110. pTable2->bits[3]);
  3111. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE5_CNT,
  3112. pTable2->bits[4]);
  3113. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE6_CNT,
  3114. pTable2->bits[5]);
  3115. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE7_CNT,
  3116. pTable2->bits[6]);
  3117. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE8_CNT,
  3118. pTable2->bits[7]);
  3119. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE9_CNT,
  3120. pTable2->bits[8]);
  3121. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE10_CNT,
  3122. pTable2->bits[9]);
  3123. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE11_CNT,
  3124. pTable2->bits[10]);
  3125. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE12_CNT,
  3126. pTable2->bits[11]);
  3127. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE13_CNT,
  3128. pTable2->bits[12]);
  3129. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE14_CNT,
  3130. pTable2->bits[13]);
  3131. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE15_CNT,
  3132. pTable2->bits[14]);
  3133. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE16_CNT,
  3134. pTable2->bits[15]);
  3135. /* table DC2 (Cr) */
  3136. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE1_CNT,
  3137. pTable3->bits[0]);
  3138. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE2_CNT,
  3139. pTable3->bits[1]);
  3140. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE3_CNT,
  3141. pTable3->bits[2]);
  3142. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE4_CNT,
  3143. pTable3->bits[3]);
  3144. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE5_CNT,
  3145. pTable3->bits[4]);
  3146. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE6_CNT,
  3147. pTable3->bits[5]);
  3148. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE7_CNT,
  3149. pTable3->bits[6]);
  3150. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE8_CNT,
  3151. pTable3->bits[7]);
  3152. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE9_CNT,
  3153. pTable3->bits[8]);
  3154. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE10_CNT,
  3155. pTable3->bits[9]);
  3156. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE11_CNT,
  3157. pTable3->bits[10]);
  3158. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE12_CNT,
  3159. pTable3->bits[11]);
  3160. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE13_CNT,
  3161. pTable3->bits[12]);
  3162. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE14_CNT,
  3163. pTable3->bits[13]);
  3164. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE15_CNT,
  3165. pTable3->bits[14]);
  3166. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE16_CNT,
  3167. pTable3->bits[15]);
  3168. }
  3169. else
  3170. {
  3171. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE1_CNT, 0);
  3172. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE2_CNT, 0);
  3173. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE3_CNT, 0);
  3174. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE4_CNT, 0);
  3175. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE5_CNT, 0);
  3176. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE6_CNT, 0);
  3177. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE7_CNT, 0);
  3178. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE8_CNT, 0);
  3179. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE9_CNT, 0);
  3180. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE10_CNT, 0);
  3181. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE11_CNT, 0);
  3182. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE12_CNT, 0);
  3183. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE13_CNT, 0);
  3184. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE14_CNT, 0);
  3185. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE15_CNT, 0);
  3186. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC1_CODE16_CNT, 0);
  3187. /* table DC2 (Cb) */
  3188. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE1_CNT, 0);
  3189. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE2_CNT, 0);
  3190. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE3_CNT, 0);
  3191. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE4_CNT, 0);
  3192. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE5_CNT, 0);
  3193. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE6_CNT, 0);
  3194. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE7_CNT, 0);
  3195. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE8_CNT, 0);
  3196. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE9_CNT, 0);
  3197. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE10_CNT, 0);
  3198. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE11_CNT, 0);
  3199. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE12_CNT, 0);
  3200. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE13_CNT, 0);
  3201. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE14_CNT, 0);
  3202. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE15_CNT, 0);
  3203. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC2_CODE16_CNT, 0);
  3204. /* table DC2 (Cr) */
  3205. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE1_CNT, 0);
  3206. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE2_CNT, 0);
  3207. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE3_CNT, 0);
  3208. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE4_CNT, 0);
  3209. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE5_CNT, 0);
  3210. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE6_CNT, 0);
  3211. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE7_CNT, 0);
  3212. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE8_CNT, 0);
  3213. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE9_CNT, 0);
  3214. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE10_CNT, 0);
  3215. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE11_CNT, 0);
  3216. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE12_CNT, 0);
  3217. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE13_CNT, 0);
  3218. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE14_CNT, 0);
  3219. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE15_CNT, 0);
  3220. SetDecRegister(PTR_JPGC->jpegRegs, HWIF_DC3_CODE16_CNT, 0);
  3221. }
  3222. }
  3223. return;
  3224. #undef JPG_SCN
  3225. #undef JPG_VLC
  3226. #undef JPG_QTB
  3227. #undef JPG_FRM
  3228. #undef PTR_JPGC
  3229. }
  3230. /*------------------------------------------------------------------------------
  3231. Function name: JpegDecNextScanHdrs
  3232. Functional description:
  3233. Decodes next headers in case of non-interleaved stream
  3234. Inputs:
  3235. JpegDecContainer *pDecData Pointer to JpegDecContainer structure
  3236. Outputs:
  3237. OK/NOK
  3238. ------------------------------------------------------------------------------*/
  3239. JpegDecRet JpegDecNextScanHdrs(JpegDecContainer * pJpegDecCont)
  3240. {
  3241. u32 i;
  3242. u32 currentByte = 0;
  3243. u32 currentBytes = 0;
  3244. JpegDecRet retCode;
  3245. #define PTR_JPGC pJpegDecCont
  3246. #define JPG_SCN pJpegDecCont->scan
  3247. #define JPG_VLC pJpegDecCont->vlc
  3248. #define JPG_QTB pJpegDecCont->quant
  3249. #define JPG_FRM pJpegDecCont->frame
  3250. retCode = JPEGDEC_OK;
  3251. /* reset for new headers */
  3252. PTR_JPGC->image.headerReady = 0;
  3253. /* find markers and go ! */
  3254. do
  3255. {
  3256. /* Look for marker prefix byte from stream */
  3257. if(JpegDecGetByte(&(PTR_JPGC->stream)) == 0xFF)
  3258. {
  3259. currentByte = JpegDecGetByte(&(PTR_JPGC->stream));
  3260. /* switch to certain header decoding */
  3261. switch (currentByte)
  3262. {
  3263. case 0x00:
  3264. case SOF0:
  3265. case SOF2:
  3266. break;
  3267. /* Start of Scan */
  3268. case SOS:
  3269. /* reset image ready */
  3270. PTR_JPGC->image.imageReady = 0;
  3271. retCode = JpegDecDecodeScan(PTR_JPGC);
  3272. PTR_JPGC->image.headerReady = 1;
  3273. if(retCode != JPEGDEC_OK)
  3274. {
  3275. if(retCode == JPEGDEC_STRM_ERROR)
  3276. {
  3277. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Stream error"));
  3278. return (retCode);
  3279. }
  3280. else
  3281. {
  3282. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# JpegDecDecodeScan err\n"));
  3283. return (retCode);
  3284. }
  3285. }
  3286. if(PTR_JPGC->stream.bitPosInByte)
  3287. {
  3288. /* delete stuffing bits */
  3289. currentByte = (8 - PTR_JPGC->stream.bitPosInByte);
  3290. if(JpegDecFlushBits
  3291. (&(PTR_JPGC->stream),
  3292. 8 - PTR_JPGC->stream.bitPosInByte) == STRM_ERROR)
  3293. {
  3294. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Stream error"));
  3295. return (JPEGDEC_STRM_ERROR);
  3296. }
  3297. }
  3298. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# Stuffing bits deleted\n"));
  3299. break;
  3300. /* Start of Huffman tables */
  3301. case DHT:
  3302. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# JpegDecDecodeHuffmanTables dec"));
  3303. retCode = JpegDecDecodeHuffmanTables(PTR_JPGC);
  3304. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# JpegDecDecodeHuffmanTables stops"));
  3305. if(retCode != JPEGDEC_OK)
  3306. {
  3307. if(retCode == JPEGDEC_STRM_ERROR)
  3308. {
  3309. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Stream error"));
  3310. return (retCode);
  3311. }
  3312. else
  3313. {
  3314. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: JpegDecDecodeHuffmanTables err"));
  3315. return (retCode);
  3316. }
  3317. }
  3318. break;
  3319. /* start of Quantisation Tables */
  3320. case DQT:
  3321. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# JpegDecDecodeQuantTables dec"));
  3322. retCode = JpegDecDecodeQuantTables(PTR_JPGC);
  3323. if(retCode != JPEGDEC_OK)
  3324. {
  3325. if(retCode == JPEGDEC_STRM_ERROR)
  3326. {
  3327. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Stream error"));
  3328. return (retCode);
  3329. }
  3330. else
  3331. {
  3332. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: JpegDecDecodeQuantTables err"));
  3333. return (retCode);
  3334. }
  3335. }
  3336. break;
  3337. /* Start of Image */
  3338. case SOI:
  3339. /* no actions needed, continue */
  3340. break;
  3341. /* End of Image */
  3342. case EOI:
  3343. if(PTR_JPGC->image.imageReady)
  3344. {
  3345. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# EOI: OK\n"));
  3346. return (JPEGDEC_FRAME_READY);
  3347. }
  3348. else
  3349. {
  3350. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: EOI: NOK\n"));
  3351. return (JPEGDEC_ERROR);
  3352. }
  3353. /* Define Restart Interval */
  3354. case DRI:
  3355. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# DRI"));
  3356. currentBytes = JpegDecGet2Bytes(&(PTR_JPGC->stream));
  3357. if(currentBytes == STRM_ERROR)
  3358. {
  3359. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Read bits "));
  3360. return (JPEGDEC_STRM_ERROR);
  3361. }
  3362. PTR_JPGC->frame.Ri = JpegDecGet2Bytes(&(PTR_JPGC->stream));
  3363. break;
  3364. /* Restart with modulo 8 count m */
  3365. case RST0:
  3366. case RST1:
  3367. case RST2:
  3368. case RST3:
  3369. case RST4:
  3370. case RST5:
  3371. case RST6:
  3372. case RST7:
  3373. /* initialisation of DC predictors to zero value !!! */
  3374. for(i = 0; i < MAX_NUMBER_OF_COMPONENTS; i++)
  3375. {
  3376. PTR_JPGC->scan.pred[i] = 0;
  3377. }
  3378. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# DC predictors init"));
  3379. break;
  3380. /* unsupported features */
  3381. case DNL:
  3382. case SOF1:
  3383. case SOF3:
  3384. case SOF5:
  3385. case SOF6:
  3386. case SOF7:
  3387. case SOF9:
  3388. case SOF10:
  3389. case SOF11:
  3390. case SOF13:
  3391. case SOF14:
  3392. case SOF15:
  3393. case DAC:
  3394. case DHP:
  3395. case TEM:
  3396. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Unsupported Features"));
  3397. return (JPEGDEC_UNSUPPORTED);
  3398. /* application data & comments */
  3399. case APP0:
  3400. case APP1:
  3401. case APP2:
  3402. case APP3:
  3403. case APP4:
  3404. case APP5:
  3405. case APP6:
  3406. case APP7:
  3407. case APP8:
  3408. case APP9:
  3409. case APP10:
  3410. case APP11:
  3411. case APP12:
  3412. case APP13:
  3413. case APP14:
  3414. case APP15:
  3415. case COM:
  3416. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# COM"));
  3417. currentBytes = JpegDecGet2Bytes(&(PTR_JPGC->stream));
  3418. if(currentBytes == STRM_ERROR)
  3419. {
  3420. JPEGDEC_TRACE_INTERNAL(("JpegDecNextScanHdrs# ERROR: Read bits "));
  3421. return (JPEGDEC_STRM_ERROR);
  3422. }
  3423. /* jump over not supported header */
  3424. if(currentBytes != 0)
  3425. {
  3426. PTR_JPGC->stream.readBits += ((currentBytes * 8) - 16);
  3427. PTR_JPGC->stream.pCurrPos +=
  3428. (((currentBytes * 8) - 16) / 8);
  3429. }
  3430. break;
  3431. default:
  3432. break;
  3433. }
  3434. }
  3435. else
  3436. {
  3437. if(currentByte == 0xFFFFFFFF)
  3438. {
  3439. break;
  3440. }
  3441. }
  3442. if(PTR_JPGC->image.headerReady)
  3443. break;
  3444. }
  3445. while((PTR_JPGC->stream.readBits >> 3) <= PTR_JPGC->stream.streamLength);
  3446. return (JPEGDEC_OK);
  3447. #undef JPG_SCN
  3448. #undef JPG_VLC
  3449. #undef JPG_QTB
  3450. #undef JPG_FRM
  3451. #undef PTR_JPGC
  3452. }
  3453. /*------------------------------------------------------------------------------
  3454. Function name : JpegRefreshRegs
  3455. Description :
  3456. Return type : void
  3457. Argument : PPContainer * ppC
  3458. ------------------------------------------------------------------------------*/
  3459. void JpegRefreshRegs(JpegDecContainer * pJpegDecCont)
  3460. {
  3461. i32 i;
  3462. u32 offset = 0x0;
  3463. u32 *ppRegs = pJpegDecCont->jpegRegs;
  3464. for(i = DEC_X170_REGISTERS; i > 0; i--)
  3465. {
  3466. *ppRegs++ = DWLReadReg(pJpegDecCont->dwl, offset);
  3467. offset += 4;
  3468. }
  3469. }
  3470. /*------------------------------------------------------------------------------
  3471. Function name : JpegFlushRegs
  3472. Description :
  3473. Return type : void
  3474. Argument : PPContainer * ppC
  3475. ------------------------------------------------------------------------------*/
  3476. void JpegFlushRegs(JpegDecContainer * pJpegDecCont)
  3477. {
  3478. i32 i;
  3479. u32 offset = 0x4;
  3480. u32 *ppRegs = pJpegDecCont->jpegRegs;
  3481. #ifdef JPEGDEC_ASIC_TRACE
  3482. {
  3483. JPEGDEC_TRACE_INTERNAL(("INTERNAL: REGS BEFORE HW ENABLE\n"));
  3484. PrintJPEGReg(pJpegDecCont->jpegRegs);
  3485. }
  3486. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  3487. #ifdef JPEGDEC_INTEGRATOR
  3488. DWLWriteReg(pJpegDecCont->dwl, 0, 0x00000000);
  3489. #endif /* #ifdef JPEGDEC_INTEGRATOR */
  3490. /* skip id register */
  3491. ppRegs++;
  3492. for(i = DEC_X170_REGISTERS; i > 1; i--)
  3493. {
  3494. DWLWriteReg(pJpegDecCont->dwl, offset, *ppRegs);
  3495. *ppRegs = 0;
  3496. ppRegs++;
  3497. offset += 4;
  3498. }
  3499. }
  3500. /*------------------------------------------------------------------------------
  3501. Function name : JpegDecInitHWEmptyScan
  3502. Description :
  3503. Return type : void
  3504. Argument :
  3505. ------------------------------------------------------------------------------*/
  3506. static u32 NumBits(u32 value)
  3507. {
  3508. u32 numBits = 0;
  3509. while(value)
  3510. {
  3511. value >>= 1;
  3512. numBits++;
  3513. }
  3514. if(!numBits)
  3515. {
  3516. numBits = 1;
  3517. }
  3518. return (numBits);
  3519. }
  3520. void JpegDecInitHWEmptyScan(JpegDecContainer * pJpegDecCont, u32 componentId)
  3521. {
  3522. u32 i;
  3523. i32 n;
  3524. u32 coeffBuffer = 0;
  3525. u32 outputBuffer = 0;
  3526. u32 numBlocks;
  3527. u32 numMax;
  3528. u8 *pStrm;
  3529. u32 bits;
  3530. u32 bitPos;
  3531. u32 *pTableBase = NULL;
  3532. ASSERT(pJpegDecCont);
  3533. pJpegDecCont->info.nonInterleaved = 1;
  3534. pJpegDecCont->info.componentId = componentId;
  3535. if(pJpegDecCont->ppInstance == NULL && pJpegDecCont->info.userAllocMem == 1)
  3536. {
  3537. /* if user allocated memory ==> new addresses */
  3538. pJpegDecCont->asicBuff.outLumaBuffer.virtualAddress =
  3539. pJpegDecCont->info.givenOutLuma.virtualAddress;
  3540. pJpegDecCont->asicBuff.outLumaBuffer.busAddress =
  3541. pJpegDecCont->info.givenOutLuma.busAddress;
  3542. pJpegDecCont->asicBuff.outChromaBuffer.virtualAddress =
  3543. pJpegDecCont->info.givenOutChroma.virtualAddress;
  3544. pJpegDecCont->asicBuff.outChromaBuffer.busAddress =
  3545. pJpegDecCont->info.givenOutChroma.busAddress;
  3546. pJpegDecCont->asicBuff.outChromaBuffer2.virtualAddress =
  3547. pJpegDecCont->info.givenOutChroma2.virtualAddress;
  3548. pJpegDecCont->asicBuff.outChromaBuffer2.busAddress =
  3549. pJpegDecCont->info.givenOutChroma2.busAddress;
  3550. }
  3551. /*************** Set swreg13 data ************/
  3552. /* Luminance output */
  3553. if(componentId == 0)
  3554. outputBuffer = pJpegDecCont->asicBuff.outLumaBuffer.busAddress;
  3555. else if(componentId == 1)
  3556. outputBuffer = (pJpegDecCont->asicBuff.outChromaBuffer.busAddress);
  3557. else
  3558. outputBuffer = (pJpegDecCont->asicBuff.outChromaBuffer2.busAddress);
  3559. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_DEC_OUT_BASE, outputBuffer);
  3560. pJpegDecCont->info.yCbCrMode = 0;
  3561. pJpegDecCont->info.X = pJpegDecCont->frame.hwX;
  3562. pJpegDecCont->info.Y = pJpegDecCont->frame.hwY;
  3563. pJpegDecCont->info.fillX = 0;
  3564. pJpegDecCont->info.fillY = 0;
  3565. numBlocks = pJpegDecCont->frame.hwX * pJpegDecCont->frame.hwY / 64;
  3566. coeffBuffer = pJpegDecCont->info.pCoeffBase.busAddress;
  3567. if(componentId)
  3568. {
  3569. coeffBuffer += JPEGDEC_COEFF_SIZE * numBlocks;
  3570. if(pJpegDecCont->info.yCbCrModeOrig == JPEGDEC_YUV420)
  3571. {
  3572. pJpegDecCont->info.X /= 2;
  3573. if(pJpegDecCont->info.X & 0xF)
  3574. {
  3575. pJpegDecCont->info.X += 8;
  3576. pJpegDecCont->info.fillX = 1;
  3577. }
  3578. pJpegDecCont->info.Y /= 2;
  3579. if(pJpegDecCont->info.Y & 0xF)
  3580. {
  3581. pJpegDecCont->info.Y += 8;
  3582. pJpegDecCont->info.fillY = 1;
  3583. }
  3584. numBlocks /= 4;
  3585. }
  3586. else if(pJpegDecCont->info.yCbCrModeOrig == JPEGDEC_YUV422)
  3587. {
  3588. pJpegDecCont->info.X /= 2;
  3589. if(pJpegDecCont->info.X & 0xF)
  3590. {
  3591. pJpegDecCont->info.X += 8;
  3592. pJpegDecCont->info.fillX = 1;
  3593. }
  3594. numBlocks /= 2;
  3595. }
  3596. else if(pJpegDecCont->info.yCbCrModeOrig == JPEGDEC_YUV440)
  3597. {
  3598. pJpegDecCont->info.Y /= 2;
  3599. if(pJpegDecCont->info.Y & 0xF)
  3600. {
  3601. pJpegDecCont->info.Y += 8;
  3602. pJpegDecCont->info.fillY = 1;
  3603. }
  3604. numBlocks /= 2;
  3605. }
  3606. if(componentId > 1)
  3607. coeffBuffer += JPEGDEC_COEFF_SIZE * numBlocks;
  3608. }
  3609. pStrm = (u8*)pJpegDecCont->info.tmpStrm.virtualAddress;
  3610. numMax = 0;
  3611. while(numBlocks > 32767)
  3612. {
  3613. numBlocks -= 32767;
  3614. numMax++;
  3615. }
  3616. n = NumBits(numBlocks);
  3617. /* do we still have correct quantization tables ?? */
  3618. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Write AC,DC,QP tables to base\n"));
  3619. JpegDecWriteTablesProgressive(pJpegDecCont);
  3620. /* two vlc codes, both with length 1 (can be done?), 0 for largest eob, 1
  3621. * for last eob (EOBn) */
  3622. /* write "length amounts" */
  3623. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_AC1_CODE1_CNT, 2);
  3624. /* codeword values 0xE0 (for EOB run of 32767 blocks) and 0xn0 */
  3625. pTableBase = pJpegDecCont->frame.pTableBase.virtualAddress;
  3626. pTableBase += 48; /* start of vlc tables */
  3627. *pTableBase = (0xE0 << 24) | ((n - 1) << 20);
  3628. /* write numMax ext eobs of length 32767 followed by last ext eob */
  3629. bitPos = 0;
  3630. for(i = 0; i < numMax; i++)
  3631. {
  3632. bits = 0x3FFF << 17;
  3633. *pStrm = (bitPos ? *pStrm : 0) | bits >> (24 + bitPos);
  3634. pStrm++;
  3635. bits <<= 8 - bitPos;
  3636. *pStrm = bits >> 24;
  3637. if(bitPos >= 1)
  3638. {
  3639. pStrm++;
  3640. bits <<= 8;
  3641. *pStrm = bits >> 24;
  3642. }
  3643. bitPos = (bitPos + 15) & 0x7;
  3644. }
  3645. if(numBlocks)
  3646. {
  3647. /* codeword to be written:
  3648. * '1' to indicate EOBn followed by number of blocks - 2^(n-1) */
  3649. bits = numBlocks << (32 - n);
  3650. *pStrm = (bitPos ? *pStrm : 0) | bits >> (24 + bitPos);
  3651. pStrm++;
  3652. bits <<= 8 - bitPos;
  3653. n -= 8 - bitPos;
  3654. while(n > 0)
  3655. {
  3656. *pStrm++ = bits >> 24;
  3657. bits <<= 8;
  3658. n -= 8;
  3659. }
  3660. }
  3661. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_RLC_VLC_BASE,
  3662. pJpegDecCont->info.tmpStrm.busAddress);
  3663. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_STRM_START_BIT, 0);
  3664. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_STREAM_LEN, 100);
  3665. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set input format\n"));
  3666. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_JPEG_MODE, JPEGDEC_YUV400);
  3667. /* frame size, round up the number of mbs */
  3668. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width extension\n"));
  3669. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PIC_MB_W_EXT,
  3670. ((((pJpegDecCont->info.X) >> (4)) & 0xE00) >> 9));
  3671. /* frame size, round up the number of mbs */
  3672. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame width\n"));
  3673. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PIC_MB_WIDTH,
  3674. ((pJpegDecCont->info.X) >> (4)) & 0x1FF);
  3675. /* frame size, round up the number of mbs */
  3676. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height extension\n"));
  3677. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PIC_MB_H_EXT,
  3678. ((((pJpegDecCont->info.Y) >> (4)) & 0x700) >> 8));
  3679. /* frame size, round up the number of mbs */
  3680. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set Frame height\n"));
  3681. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PIC_MB_HEIGHT_P,
  3682. ((pJpegDecCont->info.Y) >> (4)) & 0x0FF);
  3683. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_WDIV8,
  3684. pJpegDecCont->info.fillX);
  3685. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_JPEG_FILRIGHT_E,
  3686. pJpegDecCont->info.fillX);
  3687. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_HDIV8,
  3688. pJpegDecCont->info.fillY);
  3689. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_FILDOWN_E,
  3690. pJpegDecCont->info.fillY);
  3691. /*************** Set swreg52 data ************/
  3692. /* Set JPEG operation mode */
  3693. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set JPEG operation mode\n"));
  3694. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_E, 1);
  3695. /* indicate first ac scan for any spectral coeffs, nothing will be changed
  3696. * as every block "skipped" by extended eobs */
  3697. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_SS, 1);
  3698. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_SE, 1);
  3699. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_AH, 0);
  3700. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_AL, 0);
  3701. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set coefficient buffer base address\n"));
  3702. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_PJPEG_COEFF_BUF, coeffBuffer);
  3703. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_DEC_OUT_DIS, 0);
  3704. /* write table base */
  3705. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Set AC,DC,QP table base address\n"));
  3706. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_QTABLE_BASE,
  3707. pJpegDecCont->frame.pTableBase.busAddress);
  3708. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_SYNC_MARKER_E, 0);
  3709. pJpegDecCont->asicRunning = 1;
  3710. /* Flush regs to hw register */
  3711. JpegFlushRegs(pJpegDecCont);
  3712. /* Enable jpeg mode and set slice mode */
  3713. JPEGDEC_TRACE_INTERNAL(("INTERNAL: Enable jpeg\n"));
  3714. SetDecRegister(pJpegDecCont->jpegRegs, HWIF_DEC_E, 1);
  3715. DWLEnableHW(pJpegDecCont->dwl, 4 * 1, pJpegDecCont->jpegRegs[1]);
  3716. #ifdef JPEGDEC_ASIC_TRACE
  3717. {
  3718. JPEGDEC_TRACE_INTERNAL(("PROGRESSIVE CONTINUE: REGS BEFORE IRQ CLEAN\n"));
  3719. PrintJPEGReg(pJpegDecCont->jpegRegs);
  3720. }
  3721. #endif /* #ifdef JPEGDEC_ASIC_TRACE */
  3722. }