cnm_video_helper.c 71 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003
  1. // SPDX-License-Identifier: LGPL-2.1 OR BSD-3-Clause
  2. //--=========================================================================--
  3. // This file is a part of QC Tool project
  4. //-----------------------------------------------------------------------------
  5. //
  6. // This confidential and proprietary software may be used only
  7. // as authorized by a licensing agreement from Chips&Media Inc.
  8. // In the event of publication, the following notice is applicable:
  9. //
  10. // (C) COPYRIGHT 2004 - 2011 CHIPS&MEDIA INC.
  11. // ALL RIGHTS RESERVED
  12. //
  13. // The entire notice above must be reproduced on all authorized
  14. // copies.
  15. //
  16. //--=========================================================================--
  17. #include "main_helper.h"
  18. #include <libavformat/avformat.h>
  19. #ifdef SUPPORT_ENCODE_CUSTOM_HEADER
  20. #include "header_struct.h"
  21. #include "pbu.h"
  22. #endif
  23. // include in the ffmpeg header
  24. typedef struct {
  25. CodStd codStd;
  26. Uint32 mp4Class;
  27. Uint32 codecId;
  28. Uint32 fourcc;
  29. } CodStdTab;
  30. #ifndef MKTAG
  31. #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
  32. #endif
  33. static const CodStdTab codstd_tab[] = {
  34. { STD_AVC, 0, AV_CODEC_ID_H264, MKTAG('H', '2', '6', '4') },
  35. { STD_AVC, 0, AV_CODEC_ID_H264, MKTAG('X', '2', '6', '4') },
  36. { STD_AVC, 0, AV_CODEC_ID_H264, MKTAG('A', 'V', 'C', '1') },
  37. { STD_AVC, 0, AV_CODEC_ID_H264, MKTAG('V', 'S', 'S', 'H') },
  38. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('H', '2', '6', '3') },
  39. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('X', '2', '6', '3') },
  40. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('T', '2', '6', '3') },
  41. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('L', '2', '6', '3') },
  42. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('V', 'X', '1', 'K') },
  43. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('Z', 'y', 'G', 'o') },
  44. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('H', '2', '6', '3') },
  45. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('I', '2', '6', '3') }, /* intel h263 */
  46. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('H', '2', '6', '1') },
  47. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('U', '2', '6', '3') },
  48. { STD_H263, 0, AV_CODEC_ID_H263, MKTAG('V', 'I', 'V', '1') },
  49. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('F', 'M', 'P', '4') },
  50. { STD_MPEG4, 5, AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X') }, // DivX 4
  51. { STD_MPEG4, 1, AV_CODEC_ID_MPEG4, MKTAG('D', 'X', '5', '0') },
  52. { STD_MPEG4, 2, AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') },
  53. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
  54. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') }, //MPEG-4 version 2 simple profile
  55. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 0 ) }, /* some broken avi use this */
  56. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', '1') },
  57. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('B', 'L', 'Z', '0') },
  58. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'V') },
  59. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('U', 'M', 'P', '4') },
  60. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('W', 'V', '1', 'F') },
  61. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('S', 'E', 'D', 'G') },
  62. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('R', 'M', 'P', '4') },
  63. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('3', 'I', 'V', '2') },
  64. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('F', 'F', 'D', 'S') },
  65. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('F', 'V', 'F', 'W') },
  66. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('D', 'C', 'O', 'D') },
  67. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', 'V', 'X', 'M') },
  68. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('P', 'M', '4', 'V') },
  69. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('S', 'M', 'P', '4') },
  70. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('D', 'X', 'G', 'M') },
  71. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('V', 'I', 'D', 'M') },
  72. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'T', '3') },
  73. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'X') },
  74. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('H', 'D', 'X', '4') }, /* flipped video */
  75. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('D', 'M', 'K', '2') },
  76. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('D', 'I', 'G', 'I') },
  77. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('I', 'N', 'M', 'C') },
  78. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('E', 'P', 'H', 'V') }, /* Ephv MPEG-4 */
  79. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('E', 'M', '4', 'A') },
  80. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'C', 'C') }, /* Divio MPEG-4 */
  81. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('S', 'N', '4', '0') },
  82. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('V', 'S', 'P', 'X') },
  83. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('U', 'L', 'D', 'X') },
  84. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('G', 'E', 'O', 'V') },
  85. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG('S', 'I', 'P', 'P') }, /* Samsung SHR-6040 */
  86. { STD_DIV3, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '3') }, /* default signature when using MSMPEG4 */
  87. { STD_DIV3, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
  88. { STD_DIV3, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', 'G', '3') },
  89. { STD_MPEG4, 1, AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '5') },
  90. { STD_MPEG4, 1, AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '6') },
  91. { STD_MPEG4, 5, AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '4') },
  92. { STD_DIV3, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('D', 'V', 'X', '3') },
  93. { STD_DIV3, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('A', 'P', '4', '1') }, //Another hacked version of Microsoft's MP43 codec.
  94. { STD_MPEG4, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '1') },
  95. { STD_MPEG4, 0, AV_CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '0') }, // not support ms mpeg4 v1, 2
  96. { STD_MPEG4, 256, AV_CODEC_ID_FLV1, MKTAG('F', 'L', 'V', '1') }, /* Sorenson spark */
  97. { STD_VC1, 0, AV_CODEC_ID_WMV1, MKTAG('W', 'M', 'V', '1') },
  98. { STD_VC1, 0, AV_CODEC_ID_WMV2, MKTAG('W', 'M', 'V', '2') },
  99. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG('M', 'P', 'G', '1') },
  100. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG('M', 'P', 'G', '2') },
  101. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', 'P', 'G', '2') },
  102. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', 'P', 'E', 'G') },
  103. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG('M', 'P', '2', 'V') },
  104. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG('P', 'I', 'M', '1') },
  105. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('P', 'I', 'M', '2') },
  106. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG('V', 'C', 'R', '2') },
  107. { STD_MPEG2, 0, AV_CODEC_ID_MPEG1VIDEO, MKTAG( 1 , 0 , 0 , 16) },
  108. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG( 2 , 0 , 0 , 16) },
  109. { STD_MPEG4, 0, AV_CODEC_ID_MPEG4, MKTAG( 4 , 0 , 0 , 16) },
  110. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('D', 'V', 'R', ' ') },
  111. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('M', 'M', 'E', 'S') },
  112. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('L', 'M', 'P', '2') }, /* Lead MPEG2 in avi */
  113. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('S', 'L', 'I', 'F') },
  114. { STD_MPEG2, 0, AV_CODEC_ID_MPEG2VIDEO, MKTAG('E', 'M', '2', 'V') },
  115. { STD_VC1, 0, AV_CODEC_ID_WMV3, MKTAG('W', 'M', 'V', '3') },
  116. { STD_VC1, 0, AV_CODEC_ID_VC1, MKTAG('W', 'V', 'C', '1') },
  117. { STD_VC1, 0, AV_CODEC_ID_VC1, MKTAG('W', 'M', 'V', 'A') },
  118. { STD_RV, 0, AV_CODEC_ID_RV30, MKTAG('R','V','3','0') },
  119. { STD_RV, 0, AV_CODEC_ID_RV40, MKTAG('R','V','4','0') },
  120. { STD_AVS, 0, AV_CODEC_ID_CAVS, MKTAG('C','A','V','S') },
  121. { STD_AVS, 0, AV_CODEC_ID_AVS, MKTAG('A','V','S','2') },
  122. { STD_VP3, 0, AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
  123. { STD_VP3, 0, AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
  124. { STD_THO, 0, AV_CODEC_ID_THEORA, MKTAG('T', 'H', 'E', 'O') },
  125. { STD_VP8, 0, AV_CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') },
  126. { STD_VP9, 0, AV_CODEC_ID_VP9, MKTAG('V', 'P', '9', '0') },
  127. // { STD_VP6, 0, AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
  128. // { STD_VP6, 0, AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
  129. // { STD_VP6, 0, AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
  130. // { STD_VP6, 0, AV_CODEC_ID_VP6F, MKTAG('V', 'P', '6', 'F') },
  131. // { STD_VP6, 0, AV_CODEC_ID_VP6F, MKTAG('F', 'L', 'V', '4') },
  132. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('H', 'E', 'V', 'C') },
  133. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('H', 'E', 'V', '1') },
  134. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('H', 'V', 'C', '1') },
  135. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('h', 'e', 'v', 'c') },
  136. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('h', 'e', 'v', '1') },
  137. { STD_HEVC, 0, AV_CODEC_ID_HEVC, MKTAG('h', 'v', 'c', '1') }
  138. };
  139. Int32 ConvFOURCCToMp4Class(
  140. Int32 fourcc
  141. )
  142. {
  143. Int32 i;
  144. Int32 mp4Class = -1;
  145. unsigned char str[5];
  146. str[0] = toupper((Int32)fourcc);
  147. str[1] = toupper((Int32)(fourcc>>8));
  148. str[2] = toupper((Int32)(fourcc>>16));
  149. str[3] = toupper((Int32)(fourcc>>24));
  150. str[4] = '\0';
  151. for(i=0; i<sizeof(codstd_tab)/sizeof(codstd_tab[0]); i++) {
  152. if (codstd_tab[i].fourcc == (Int32)MKTAG(str[0], str[1], str[2], str[3]) ) {
  153. mp4Class = codstd_tab[i].mp4Class;
  154. break;
  155. }
  156. }
  157. return mp4Class;
  158. }
  159. Int32 ConvFOURCCToCodStd(
  160. Uint32 fourcc
  161. )
  162. {
  163. Int32 codStd = -1;
  164. Int32 i;
  165. char str[5];
  166. str[0] = toupper((Int32)fourcc);
  167. str[1] = toupper((Int32)(fourcc>>8));
  168. str[2] = toupper((Int32)(fourcc>>16));
  169. str[3] = toupper((Int32)(fourcc>>24));
  170. str[4] = '\0';
  171. for(i=0; i<sizeof(codstd_tab)/sizeof(codstd_tab[0]); i++) {
  172. if (codstd_tab[i].fourcc == (Uint32)MKTAG(str[0], str[1], str[2], str[3])) {
  173. codStd = codstd_tab[i].codStd;
  174. break;
  175. }
  176. }
  177. return codStd;
  178. }
  179. Int32 ConvCodecIdToMp4Class(
  180. Uint32 codecId
  181. )
  182. {
  183. Int32 mp4Class = -1;
  184. Int32 i;
  185. for(i=0; i<sizeof(codstd_tab)/sizeof(codstd_tab[0]); i++) {
  186. if (codstd_tab[i].codecId == codecId) {
  187. mp4Class = codstd_tab[i].mp4Class;
  188. break;
  189. }
  190. }
  191. return mp4Class;
  192. }
  193. Int32 ConvCodecIdToCodStd(
  194. Int32 codecId
  195. )
  196. {
  197. Int32 codStd = -1;
  198. Int32 i;
  199. for(i=0; i<sizeof(codstd_tab)/sizeof(codstd_tab[0]); i++) {
  200. if (codstd_tab[i].codecId == codecId) {
  201. codStd = codstd_tab[i].codStd;
  202. break;
  203. }
  204. }
  205. return codStd;
  206. }
  207. Int32 ConvCodecIdToFourcc(
  208. Int32 codecId
  209. )
  210. {
  211. Int32 fourcc = 0;
  212. Int32 i;
  213. for(i=0; i<sizeof(codstd_tab)/sizeof(codstd_tab[0]); i++) {
  214. if (codstd_tab[i].codecId == codecId) {
  215. fourcc = codstd_tab[i].fourcc;
  216. break;
  217. }
  218. }
  219. return fourcc;
  220. }
  221. //////////////////// DRAM Read/Write helper Function ////////////////////////////
  222. BOOL LoadYuvImageBurstFormat(
  223. Uint32 coreIdx,
  224. Uint8* src,
  225. size_t picWidth,
  226. size_t picHeight,
  227. FrameBuffer* fb,
  228. BOOL convertCbcrIntl
  229. )
  230. {
  231. Int32 y, nY, nCb, nCr;
  232. Int32 addr;
  233. size_t lumaSize, chromaSize=0, chromaStride, chromaWidth=0;
  234. Uint8* puc;
  235. size_t stride = fb->stride;
  236. EndianMode endian = (EndianMode)fb->endian;
  237. FrameBufferFormat format = fb->format;
  238. BOOL interLeave = fb->cbcrInterleave;
  239. int twice = 1 << interLeave;
  240. switch (format) {
  241. case FORMAT_420:
  242. nY = picHeight;
  243. nCb = nCr = picHeight / 2;
  244. chromaSize = picWidth * picHeight / 4;
  245. chromaStride = stride / 2;
  246. chromaWidth = picWidth / 2;
  247. break;
  248. case FORMAT_224:
  249. nY = picHeight;
  250. nCb = nCr = picHeight / 2;
  251. chromaSize = picWidth * picHeight / 2;
  252. chromaStride = stride;
  253. chromaWidth = picWidth;
  254. break;
  255. case FORMAT_422:
  256. nY = picHeight;
  257. nCb = nCr = picHeight;
  258. chromaSize = picWidth * picHeight / 2;
  259. chromaStride = stride / 2;
  260. chromaWidth = picWidth / 2;
  261. break;
  262. case FORMAT_444:
  263. nY = picHeight;
  264. nCb = nCr = picHeight;
  265. chromaSize = picWidth * picHeight;
  266. chromaStride = stride;
  267. chromaWidth = picWidth;
  268. break;
  269. case FORMAT_400:
  270. nY = picHeight;
  271. nCb = nCr = 0;
  272. chromaSize = picWidth * picHeight / 4;
  273. chromaStride = stride / 2;
  274. chromaWidth = picWidth / 2;
  275. break;
  276. case FORMAT_YUYV:
  277. case FORMAT_YVYU:
  278. case FORMAT_UYVY:
  279. case FORMAT_VYUY:
  280. case FORMAT_YUYV_P10_16BIT_MSB:
  281. case FORMAT_YUYV_P10_16BIT_LSB:
  282. case FORMAT_YUYV_P10_32BIT_MSB:
  283. case FORMAT_YUYV_P10_32BIT_LSB:
  284. case FORMAT_YVYU_P10_16BIT_MSB:
  285. case FORMAT_YVYU_P10_16BIT_LSB:
  286. case FORMAT_YVYU_P10_32BIT_MSB:
  287. case FORMAT_YVYU_P10_32BIT_LSB:
  288. case FORMAT_UYVY_P10_16BIT_MSB:
  289. case FORMAT_UYVY_P10_16BIT_LSB:
  290. case FORMAT_UYVY_P10_32BIT_MSB:
  291. case FORMAT_UYVY_P10_32BIT_LSB:
  292. case FORMAT_VYUY_P10_16BIT_MSB:
  293. case FORMAT_VYUY_P10_16BIT_LSB:
  294. case FORMAT_VYUY_P10_32BIT_MSB:
  295. case FORMAT_VYUY_P10_32BIT_LSB:
  296. nY = picHeight;
  297. nCb = nCr = 0;
  298. break;
  299. case FORMAT_420_P10_16BIT_LSB:
  300. case FORMAT_420_P10_16BIT_MSB:
  301. nY = picHeight;
  302. nCb = nCr = picHeight/2;
  303. chromaSize = picWidth * picHeight/2;
  304. chromaStride = stride / 2;
  305. chromaWidth = picWidth;
  306. picWidth *= 2;
  307. break;
  308. case FORMAT_420_P10_32BIT_LSB:
  309. case FORMAT_420_P10_32BIT_MSB:
  310. nY = picHeight;
  311. nCb = nCr = picHeight/2;
  312. picWidth = VPU_ALIGN32(picWidth);
  313. chromaWidth = ((VPU_ALIGN16(picWidth/2*twice)+2)/3*4);
  314. chromaStride = VPU_ALIGN16(stride/2)*twice;
  315. if ( interLeave == 1)
  316. chromaStride = stride;
  317. chromaSize = chromaWidth * picHeight/2;
  318. picWidth = ((VPU_ALIGN16(picWidth)+2)/3)*4;
  319. break;
  320. default:
  321. nY = picHeight;
  322. nCb = nCr = picHeight / 2;
  323. chromaSize = picWidth * picHeight / 4;
  324. chromaStride = stride / 2;
  325. chromaWidth = picWidth / 2;
  326. break;
  327. }
  328. puc = src;
  329. addr = fb->bufY;
  330. lumaSize = picWidth * picHeight;
  331. if( picWidth == stride) { // for fast write
  332. vdi_write_memory(coreIdx, addr, (Uint8 *)( puc ), lumaSize, endian);
  333. if( format == FORMAT_400)
  334. return FALSE;
  335. if (format >= FORMAT_YUYV && format <= FORMAT_VYUY_P10_32BIT_LSB)
  336. return FALSE;
  337. if (interLeave == TRUE) {
  338. UNREFERENCED_PARAMETER(convertCbcrIntl);
  339. puc = src + lumaSize;
  340. addr = fb->bufCb;
  341. vdi_write_memory(coreIdx, addr, (Uint8 *)puc, chromaSize*2, endian);
  342. }
  343. else {
  344. if ( chromaWidth == chromaStride )
  345. {
  346. puc = src + lumaSize;
  347. addr = fb->bufCb;
  348. vdi_write_memory(coreIdx, addr, (Uint8 *)puc, chromaSize, endian);
  349. puc = src + lumaSize + chromaSize;
  350. addr = fb->bufCr;
  351. vdi_write_memory(coreIdx, addr, (Uint8 *)puc, chromaSize, endian);
  352. }
  353. else
  354. {
  355. puc = src + lumaSize;
  356. addr = fb->bufCb;
  357. for (y = 0; y < nCb; ++y) {
  358. vdi_write_memory(coreIdx, addr + chromaStride * y, (Uint8 *)(puc + y * chromaWidth), chromaWidth, endian);
  359. }
  360. puc = src + lumaSize + chromaSize;
  361. addr = fb->bufCr;
  362. for (y = 0; y < nCr; ++y) {
  363. vdi_write_memory(coreIdx, addr + chromaStride * y, (Uint8 *)(puc + y * chromaWidth), chromaWidth, endian);
  364. }
  365. }
  366. }
  367. }
  368. else {
  369. for (y = 0; y < nY; ++y) {
  370. vdi_write_memory(coreIdx, addr + stride * y, (Uint8 *)(puc + y * picWidth), picWidth, endian);
  371. }
  372. if (format == FORMAT_400) {
  373. return FALSE;
  374. }
  375. if (format >= FORMAT_YUYV && format <= FORMAT_VYUY_P10_32BIT_LSB) {
  376. return FALSE;
  377. }
  378. if (interLeave == TRUE) {
  379. UNREFERENCED_PARAMETER(convertCbcrIntl);
  380. puc = src + lumaSize;
  381. addr = fb->bufCb;
  382. for (y = 0; y < nCb; ++y) {
  383. vdi_write_memory(coreIdx, addr + stride * y, (Uint8 *)(puc + y * picWidth), picWidth, endian);
  384. }
  385. }
  386. else {
  387. puc = src + lumaSize;
  388. addr = fb->bufCb;
  389. for (y = 0; y < nCb; ++y) {
  390. vdi_write_memory(coreIdx, addr + chromaStride * y, (Uint8 *)(puc + y * chromaWidth), chromaWidth, endian);
  391. }
  392. puc = src + lumaSize + chromaSize;
  393. addr = fb->bufCr;
  394. for (y = 0; y < nCr; ++y) {
  395. vdi_write_memory(coreIdx, addr + chromaStride * y, (Uint8 *)(puc + y * chromaWidth), chromaWidth, endian);
  396. }
  397. }
  398. }
  399. return TRUE;
  400. }
  401. BOOL LoadTiledImageYuvBurst(
  402. Uint32 coreIdx,
  403. BYTE* pYuv,
  404. size_t picWidth,
  405. size_t picHeight,
  406. FrameBuffer* fb,
  407. TiledMapConfig mapCfg
  408. )
  409. {
  410. BYTE *pSrc;
  411. size_t divX, divY;
  412. size_t pix_addr;
  413. size_t rrow, ccol;
  414. size_t offsetX,offsetY;
  415. size_t stride_c;
  416. size_t stride = fb->stride;
  417. EndianMode endian = (EndianMode)fb->endian;
  418. FrameBufferFormat format = fb->format;
  419. BOOL interLeave = fb->cbcrInterleave;
  420. Int32 productId;
  421. Int32 dramBusWidth = 8;
  422. productId = VPU_GetProductId(coreIdx);
  423. if (PRODUCT_ID_W_SERIES(productId)) {
  424. dramBusWidth = 16;
  425. }
  426. offsetX = offsetY = 0;
  427. divX = format == FORMAT_420 || format == FORMAT_422 ? 2 : 1;
  428. divY = format == FORMAT_420 || format == FORMAT_224 ? 2 : 1;
  429. switch (format) {
  430. case FORMAT_400:
  431. stride_c = 0;
  432. break;
  433. case FORMAT_420:
  434. case FORMAT_422:
  435. stride_c = stride / 2;
  436. break;
  437. case FORMAT_224:
  438. case FORMAT_444:
  439. stride_c = stride;
  440. break;
  441. default:
  442. stride_c = stride / 2;
  443. break;
  444. }
  445. // Y
  446. pSrc = pYuv;
  447. // no opt code
  448. for (rrow=0; rrow <picHeight; rrow=rrow+1)
  449. {
  450. for (ccol=0; ccol<picWidth; ccol=ccol+dramBusWidth)
  451. {
  452. pix_addr = GetXY2AXIAddr(&mapCfg, 0/*luma*/, rrow +offsetY, ccol + offsetX, stride, fb);
  453. vdi_write_memory(coreIdx, pix_addr, pSrc+rrow*picWidth+ccol, 8, endian);
  454. }
  455. }
  456. if (format == FORMAT_400) {
  457. return 1;
  458. }
  459. if (interLeave == FALSE) {
  460. // CB
  461. pSrc = pYuv + picWidth*picHeight;
  462. for (rrow=0; rrow <(picHeight/divY) ; rrow=rrow+1) {
  463. for (ccol=0; ccol<(picWidth/divX); ccol=ccol+dramBusWidth) {
  464. pix_addr = GetXY2AXIAddr(&mapCfg, 2, rrow + offsetY, ccol +offsetX, stride_c, fb);
  465. vdi_write_memory(coreIdx, pix_addr, pSrc+rrow*picWidth/divX+ccol, 8, endian);
  466. }
  467. }
  468. // CR
  469. pSrc = pYuv + picWidth*picHeight+ (picWidth/divX)*(picHeight/divY);
  470. for (rrow=0; rrow <picHeight/divY ; rrow=rrow+1) {
  471. for (ccol=0; ccol<picWidth/divX; ccol=ccol+dramBusWidth) {
  472. pix_addr = GetXY2AXIAddr(&mapCfg, 3, rrow + offsetY ,ccol +offsetX, stride_c, fb);
  473. vdi_write_memory(coreIdx, pix_addr, pSrc+rrow*picWidth/divX+ccol, 8, endian);
  474. }
  475. }
  476. }
  477. else {
  478. BYTE * pTemp;
  479. BYTE * srcAddrCb;
  480. BYTE * srcAddrCr;
  481. size_t cbcr_x;
  482. switch( format) {
  483. case FORMAT_444 :
  484. cbcr_x = picWidth*2;
  485. break;
  486. case FORMAT_420 :
  487. cbcr_x = picWidth ;
  488. break;
  489. case FORMAT_422 :
  490. cbcr_x = picWidth ;
  491. break;
  492. case FORMAT_224 :
  493. cbcr_x = picWidth*2;
  494. break;
  495. default:
  496. cbcr_x = picWidth ;
  497. break;
  498. }
  499. stride = stride_c * 2;
  500. srcAddrCb = pYuv + picWidth*picHeight;
  501. srcAddrCr = pYuv + picWidth*picHeight + picWidth/divX*picHeight/divY;
  502. pTemp = (BYTE*)osal_malloc(sizeof(char)*8);
  503. if (!pTemp) {
  504. return FALSE;
  505. }
  506. for (rrow=0; rrow <picHeight/divY; rrow=rrow+1) {
  507. for (ccol=0; ccol<cbcr_x ; ccol=ccol+dramBusWidth) {
  508. pTemp[0 ] = *srcAddrCb++;
  509. pTemp[0+2] = *srcAddrCb++;
  510. pTemp[0+4] = *srcAddrCb++;
  511. pTemp[0+6] = *srcAddrCb++;
  512. pTemp[0+1] = *srcAddrCr++;
  513. pTemp[0+3] = *srcAddrCr++;
  514. pTemp[0+5] = *srcAddrCr++;
  515. pTemp[0+7] = *srcAddrCr++;
  516. pix_addr = GetXY2AXIAddr(&mapCfg, 2, rrow + offsetY ,ccol + (offsetX*2), stride, fb);
  517. vdi_write_memory(coreIdx, pix_addr, (unsigned char *)pTemp, 8, endian);
  518. }
  519. }
  520. osal_free(pTemp);
  521. }
  522. return TRUE;
  523. }
  524. static void SwapDword(unsigned char* data, int len)
  525. {
  526. Uint32 temp;
  527. Uint32* ptr = (Uint32*)data;
  528. Int32 i, size = len/sizeof(Uint32);
  529. for (i=0; i<size; i+=2) {
  530. temp = ptr[i];
  531. ptr[i] = ptr[i+1];
  532. ptr[i+1] = temp;
  533. }
  534. }
  535. static void SwapLword(unsigned char* data, int len)
  536. {
  537. Uint64 temp;
  538. Uint64* ptr = (Uint64*)data;
  539. Int32 i, size = len/sizeof(Uint64);
  540. for (i=0; i<size; i+=2) {
  541. temp = ptr[i];
  542. ptr[i] = ptr[i+1];
  543. ptr[i+1] = temp;
  544. }
  545. }
  546. static void SwapPixelOrder(
  547. Uint8* data
  548. )
  549. {
  550. Uint32* temp;
  551. Uint32 temp2[4]={0,};
  552. Int32 i,j;
  553. for (i=0, j=3 ; i < 16 ; i+=4, j--) {
  554. temp = (Uint32*)(data+i);
  555. temp2[j] = (*temp & 0xffc00000)>>20;
  556. temp2[j] |= (*temp & 0x003ff000);
  557. temp2[j] |= (*temp & 0x00000ffc)<<20;
  558. }
  559. osal_memcpy(data, temp2, 16);
  560. //for matching with Ref-C
  561. SwapDword(data, 16);
  562. SwapLword(data, 16);
  563. }
  564. Uint32 StoreYuvImageBurstLinear(
  565. Uint32 coreIdx,
  566. FrameBuffer *fbSrc,
  567. TiledMapConfig mapCfg,
  568. Uint8 *pDst,
  569. VpuRect cropRect,
  570. BOOL enableCrop,
  571. BOOL isVP9
  572. )
  573. {
  574. Uint32 y, x;
  575. Uint32 pix_addr, div_x, div_y, chroma_stride;
  576. Uint8* puc;
  577. Uint8* rowBufferY, *rowBufferCb, *rowBufferCr;
  578. Uint32 stride = fbSrc->stride;
  579. Uint32 height = fbSrc->height;
  580. int interLeave = fbSrc->cbcrInterleave;
  581. BOOL nv21 = fbSrc->nv21;
  582. EndianMode endian = (EndianMode)fbSrc->endian;
  583. FrameBufferFormat format = (FrameBufferFormat)fbSrc->format;
  584. Uint32 width;
  585. Uint32 dstWidth, dstHeight;
  586. Uint32 offsetX, offsetY;
  587. Uint32 dstChromaHeight;
  588. Uint32 dstChromaWidth;
  589. Uint32 chromaHeight;
  590. Uint32 bpp=8;
  591. Uint32 p10_32bit_interleave = 0;
  592. Int32 productId;
  593. Int32 dramBusWidth = 8;
  594. Uint32 totSize = 0;
  595. BOOL copyLumaOnly = FALSE;
  596. //Int32 addr;
  597. Int32 baseY;
  598. Int32 baseCb;
  599. Int32 baseCr;
  600. Uint8 *pY;
  601. Uint8 *pCbTemp;
  602. Uint8 *pCb;
  603. Uint8 *pCr;
  604. productId = VPU_GetProductId(coreIdx);
  605. if (PRODUCT_ID_W_SERIES(productId)) {
  606. dramBusWidth = 16;
  607. }
  608. switch (fbSrc->format) {
  609. case FORMAT_420:
  610. case FORMAT_420_P10_16BIT_LSB:
  611. case FORMAT_420_P10_16BIT_MSB:
  612. case FORMAT_420_P10_32BIT_LSB:
  613. case FORMAT_420_P10_32BIT_MSB:
  614. case FORMAT_422:
  615. case FORMAT_422_P10_16BIT_LSB:
  616. case FORMAT_422_P10_16BIT_MSB:
  617. case FORMAT_422_P10_32BIT_LSB:
  618. case FORMAT_422_P10_32BIT_MSB:
  619. div_x = 2;
  620. break;
  621. default:
  622. div_x = 1;
  623. }
  624. switch (fbSrc->format) {
  625. case FORMAT_420:
  626. case FORMAT_420_P10_16BIT_LSB:
  627. case FORMAT_420_P10_16BIT_MSB:
  628. case FORMAT_420_P10_32BIT_LSB:
  629. case FORMAT_420_P10_32BIT_MSB:
  630. case FORMAT_224:
  631. div_y = 2;
  632. break;
  633. default:
  634. div_y = 1;
  635. }
  636. //for matching with Ref-C
  637. width = (enableCrop == TRUE ? cropRect.right - cropRect.left : stride);
  638. dstHeight = (enableCrop == TRUE ? cropRect.bottom - cropRect.top : height);
  639. offsetX = (enableCrop == TRUE ? cropRect.left : 0);
  640. offsetY = (enableCrop == TRUE ? cropRect.top : 0);
  641. switch (fbSrc->format) {
  642. case FORMAT_400:
  643. copyLumaOnly = TRUE;
  644. break;
  645. case FORMAT_YUYV:
  646. case FORMAT_YVYU:
  647. case FORMAT_UYVY:
  648. case FORMAT_VYUY:
  649. copyLumaOnly = TRUE;
  650. dstWidth = width * 2;
  651. dstChromaHeight = 0;
  652. chromaHeight = 0;
  653. break;
  654. case FORMAT_YUYV_P10_16BIT_LSB:
  655. case FORMAT_YUYV_P10_16BIT_MSB:
  656. case FORMAT_YVYU_P10_16BIT_LSB:
  657. case FORMAT_YVYU_P10_16BIT_MSB:
  658. case FORMAT_UYVY_P10_16BIT_LSB:
  659. case FORMAT_UYVY_P10_16BIT_MSB:
  660. case FORMAT_VYUY_P10_16BIT_LSB:
  661. case FORMAT_VYUY_P10_16BIT_MSB:
  662. copyLumaOnly = TRUE;
  663. dstWidth = (width * 2)*2;
  664. dstChromaHeight = 0;
  665. chromaHeight = 0;
  666. break;
  667. case FORMAT_YUYV_P10_32BIT_LSB:
  668. case FORMAT_YUYV_P10_32BIT_MSB:
  669. case FORMAT_YVYU_P10_32BIT_LSB:
  670. case FORMAT_YVYU_P10_32BIT_MSB:
  671. case FORMAT_UYVY_P10_32BIT_LSB:
  672. case FORMAT_UYVY_P10_32BIT_MSB:
  673. case FORMAT_VYUY_P10_32BIT_LSB:
  674. case FORMAT_VYUY_P10_32BIT_MSB:
  675. copyLumaOnly = TRUE;
  676. dstWidth = ((width+2)/3*4)*2;
  677. dstChromaHeight = 0;
  678. chromaHeight = 0;
  679. break;
  680. case FORMAT_422_P10_16BIT_LSB:
  681. case FORMAT_422_P10_16BIT_MSB:
  682. dstWidth = width * 2;
  683. bpp = 16;
  684. dstChromaWidth = dstWidth / div_x;
  685. dstChromaHeight = dstHeight / div_y;
  686. chromaHeight = height / div_y;
  687. chroma_stride = (stride / div_x);
  688. break;
  689. case FORMAT_420_P10_16BIT_LSB:
  690. case FORMAT_420_P10_16BIT_MSB:
  691. dstWidth = width * 2;
  692. bpp = 16;
  693. dstChromaWidth = dstWidth / div_x;
  694. dstChromaHeight = dstHeight / div_y;
  695. chromaHeight = height / div_y;
  696. chroma_stride = (stride / div_x);
  697. break;
  698. case FORMAT_420_P10_32BIT_LSB:
  699. case FORMAT_420_P10_32BIT_MSB:
  700. #ifdef DUMP_YUV_WHOLE_DATA
  701. if (interLeave)
  702. {
  703. dstChromaWidth = ((VPU_ALIGN16(width/div_x))*2+11)/12*16;
  704. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  705. dstChromaHeight = dstHeight / div_y;
  706. stride = stride;
  707. chroma_stride = stride;
  708. dstWidth = (VPU_ALIGN16(width)+11)/12*16;
  709. interLeave = 0;
  710. }
  711. else
  712. {
  713. dstChromaWidth = ((VPU_ALIGN16(width/div_x))+11)/12*16;
  714. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  715. dstChromaHeight = dstHeight / div_y;
  716. chroma_stride = dstChromaWidth;
  717. stride = (VPU_ALIGN16(stride)+11)/12*16;
  718. dstWidth = (VPU_ALIGN16(dstWidth)+11)/12*16;
  719. }
  720. break;
  721. #else
  722. if (interLeave) {
  723. dstChromaWidth = ((VPU_ALIGN16(width*2/div_x))+11)/12*16;
  724. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  725. if(isVP9 == TRUE) {
  726. dstChromaWidth = VPU_ALIGN32(dstChromaWidth);
  727. }
  728. chroma_stride = stride;
  729. dstChromaWidth = (width/div_x+2)/3*4;
  730. dstChromaHeight = dstHeight / div_y;
  731. chromaHeight = height / div_y;
  732. dstWidth = (width+2)/3*4;
  733. interLeave = 0;
  734. p10_32bit_interleave = 1;
  735. }
  736. else {
  737. //dstChromaWidth = ((VPU_ALIGN16(width/div_x))+11)/12*16;
  738. // dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  739. //chroma_stride = dstChromaWidth;
  740. chroma_stride = stride / 2;
  741. dstChromaWidth = (width/2+2)/3*4;
  742. dstChromaHeight = dstHeight / div_y;
  743. chromaHeight = height / div_y;
  744. dstWidth = (width+2)/3*4;
  745. }
  746. break;
  747. #endif
  748. default:
  749. dstWidth = width;
  750. dstChromaWidth = width / div_x;
  751. dstChromaHeight = dstHeight / div_y;
  752. chromaHeight = height / div_y;
  753. chroma_stride = (stride / div_x);
  754. break;
  755. }
  756. puc = pDst;
  757. pY = (Uint8*)osal_malloc(stride * height);
  758. pCbTemp = (Uint8*)osal_malloc(stride*4 * chromaHeight);
  759. pCb = (Uint8*)osal_malloc(stride*4 * chromaHeight);
  760. pCr = (Uint8*)osal_malloc(stride*2 * chromaHeight);
  761. baseY = fbSrc->bufY;
  762. baseCb = fbSrc->bufCb;
  763. baseCr = fbSrc->bufCr;
  764. vdi_read_memory(coreIdx, fbSrc->bufY, pY, stride * height, endian);
  765. for (y=0 ; y<dstHeight ; y+=1) {
  766. pix_addr = GetXY2AXIAddr(&mapCfg, 0, y+offsetY, 0, stride, fbSrc);
  767. rowBufferY = pY + (pix_addr - baseY);
  768. // CHECK POINT
  769. for (x=0; x<stride ; x+=dramBusWidth) {
  770. if ( fbSrc->format == FORMAT_420_P10_32BIT_MSB )
  771. SwapPixelOrder(rowBufferY+x);
  772. }
  773. // CHECK POINT
  774. osal_memcpy(puc+y*dstWidth, rowBufferY+offsetX, dstWidth);
  775. totSize += dstWidth;
  776. }
  777. if (copyLumaOnly == TRUE) {
  778. osal_free(pY);
  779. osal_free(pCb);
  780. osal_free(pCr);
  781. osal_free(pCbTemp);
  782. return totSize;
  783. }
  784. if (interLeave || p10_32bit_interleave) {
  785. Int32 cbcr_per_2pix=1;
  786. cbcr_per_2pix = (format==FORMAT_224||format==FORMAT_444) ? 2 : 1;
  787. vdi_read_memory(coreIdx, fbSrc->bufCb, pCbTemp, stride*cbcr_per_2pix * chromaHeight, endian);
  788. } else {
  789. vdi_read_memory(coreIdx, fbSrc->bufCb, pCb, chroma_stride * chromaHeight, endian);
  790. if ( (fbSrc->format == FORMAT_420_P10_32BIT_LSB || fbSrc->format == FORMAT_420_P10_32BIT_MSB) &&
  791. p10_32bit_interleave == 1) {
  792. // Nothing to do
  793. }
  794. else {
  795. vdi_read_memory(coreIdx, fbSrc->bufCr, pCr, chroma_stride * chromaHeight, endian);
  796. }
  797. }
  798. if (interLeave == TRUE || p10_32bit_interleave == TRUE) {
  799. //Uint8 pTemp[16];
  800. Uint8* pTemp;
  801. Uint8* dstAddrCb;
  802. Uint8* dstAddrCr;
  803. Uint8* ptrCb, *ptrCr;
  804. Int32 cbcr_per_2pix=1, k;
  805. Uint32* pTempLeft32, *pTempRight32;
  806. Uint32 temp_32;
  807. dstAddrCb = pDst + dstWidth*dstHeight;
  808. dstAddrCr = dstAddrCb + dstChromaWidth*dstChromaHeight;
  809. cbcr_per_2pix = (format==FORMAT_224||format==FORMAT_444) ? 2 : 1;
  810. for ( y = 0 ; y < dstChromaHeight; ++y ) {
  811. ptrCb = pCb;
  812. ptrCr = pCr;
  813. for ( x = 0 ; x < stride*cbcr_per_2pix ; x += dramBusWidth ) {
  814. pix_addr = GetXY2AXIAddr(&mapCfg, 2, y+(offsetY/div_y), x, stride, fbSrc);
  815. pTemp = pCbTemp + (pix_addr - baseCb);
  816. // CHECK POINT
  817. if ( fbSrc->format == FORMAT_420_P10_32BIT_MSB )
  818. SwapPixelOrder(pTemp);
  819. // CHECK POINT
  820. if (interLeave == TRUE) {
  821. for (k=0; k<dramBusWidth && (x+k) < stride; k+=(2*bpp/8)) {
  822. if (bpp == 8) {
  823. if (nv21) {
  824. *ptrCr++ = pTemp[k];
  825. *ptrCb++ = pTemp[k+1];
  826. }
  827. else {
  828. *ptrCb++ = pTemp[k];
  829. *ptrCr++ = pTemp[k+1];
  830. }
  831. }
  832. else {
  833. if (nv21) {
  834. *ptrCr++ = pTemp[k];
  835. *ptrCr++ = pTemp[k+1];
  836. *ptrCb++ = pTemp[k+2];
  837. *ptrCb++ = pTemp[k+3];
  838. }
  839. else {
  840. *ptrCb++ = pTemp[k];
  841. *ptrCb++ = pTemp[k+1];
  842. *ptrCr++ = pTemp[k+2];
  843. *ptrCr++ = pTemp[k+3];
  844. }
  845. }
  846. }
  847. }
  848. else {
  849. for (k=0; k<dramBusWidth && (x+k) < stride; k+=8) {//(2*bpp/8)) {
  850. pTempLeft32 = (Uint32*)&pTemp[k];
  851. pTempRight32 = (Uint32*)&pTemp[k+4];
  852. if (format==FORMAT_420_P10_32BIT_MSB) {
  853. temp_32 = *pTempLeft32 & 0x003ff000;
  854. *pTempLeft32 = (*pTempLeft32 & 0xffc00000)
  855. | (*pTempLeft32 & 0x00000ffc) << 10
  856. | (*pTempRight32 & 0x003ff000) >> 10;
  857. *pTempRight32 = (temp_32) << 10
  858. | (*pTempRight32 & 0xffc00000) >> 10
  859. | (*pTempRight32 & 0x00000ffc);
  860. }
  861. else if (format==FORMAT_420_P10_32BIT_LSB) {
  862. temp_32 = *pTempLeft32 & 0x000ffc00;
  863. *pTempLeft32 = (*pTempLeft32 & 0x000003ff)
  864. | (*pTempLeft32 & 0x3ff00000) >> 10
  865. | (*pTempRight32 & 0x000ffc00) << 10;
  866. *pTempRight32 = (temp_32) >> 10
  867. | (*pTempRight32 & 0x000003ff) << 10
  868. | (*pTempRight32 & 0x3ff00000);
  869. }
  870. if (nv21) {
  871. *ptrCr++ = pTemp[k];
  872. *ptrCr++ = pTemp[k+1];
  873. *ptrCr++ = pTemp[k+2];
  874. *ptrCr++ = pTemp[k+3];
  875. *ptrCb++ = pTemp[k+4];
  876. *ptrCb++ = pTemp[k+5];
  877. *ptrCb++ = pTemp[k+6];
  878. *ptrCb++ = pTemp[k+7];
  879. }
  880. else {
  881. *ptrCb++ = pTemp[k];
  882. *ptrCb++ = pTemp[k+1];
  883. *ptrCb++ = pTemp[k+2];
  884. *ptrCb++ = pTemp[k+3];
  885. *ptrCr++ = pTemp[k+4];
  886. *ptrCr++ = pTemp[k+5];
  887. *ptrCr++ = pTemp[k+6];
  888. *ptrCr++ = pTemp[k+7];
  889. }
  890. }
  891. }
  892. }
  893. osal_memcpy(dstAddrCb+y*dstChromaWidth, pCb+offsetX/div_x, dstChromaWidth);
  894. totSize += dstChromaWidth;
  895. osal_memcpy(dstAddrCr+y*dstChromaWidth, pCr+offsetX/div_x, dstChromaWidth);
  896. totSize += dstChromaWidth;
  897. }
  898. }
  899. else {
  900. puc = pDst + dstWidth*dstHeight;
  901. for (y = 0 ; y < dstChromaHeight; y += 1) {
  902. x = 0;
  903. pix_addr = GetXY2AXIAddr(&mapCfg, 2, y+(offsetY/div_y), x, chroma_stride, fbSrc);
  904. rowBufferCb = pCb + (pix_addr - baseCb);
  905. // CHECK POINT
  906. for (x = 0 ; x < chroma_stride; x += dramBusWidth) {
  907. if ( fbSrc->format == FORMAT_420_P10_32BIT_MSB )
  908. SwapPixelOrder(rowBufferCb+x);
  909. }
  910. // CHECK POINT
  911. osal_memcpy(puc + (y*dstChromaWidth), rowBufferCb+offsetX/div_x, dstChromaWidth);
  912. totSize += dstChromaWidth;
  913. }
  914. puc += dstChromaWidth * dstChromaHeight;
  915. if ( (fbSrc->format == FORMAT_420_P10_32BIT_LSB || fbSrc->format == FORMAT_420_P10_32BIT_MSB) &&
  916. p10_32bit_interleave == 1)
  917. {
  918. }
  919. else
  920. {
  921. for (y = 0 ; y < dstChromaHeight; y += 1) {
  922. x = 0;
  923. pix_addr = GetXY2AXIAddr(&mapCfg, 3, y+(offsetY/div_y), x, chroma_stride, fbSrc);
  924. //vdi_read_memory(coreIdx, pix_addr, rowBufferCr+x, dramBusWidth, endian);
  925. rowBufferCr = pCr + (pix_addr - baseCr);
  926. // CHECK POINT
  927. for ( x = 0 ; x < chroma_stride; x += dramBusWidth ) {
  928. if ( fbSrc->format == FORMAT_420_P10_32BIT_MSB )
  929. SwapPixelOrder(rowBufferCr+x);
  930. }
  931. // CHECK POINT
  932. osal_memcpy(puc + (y*dstChromaWidth), rowBufferCr+offsetX/div_x, dstChromaWidth);
  933. totSize += dstChromaWidth;
  934. }
  935. }
  936. }
  937. osal_free(pY);
  938. osal_free(pCb);
  939. osal_free(pCr);
  940. osal_free(pCbTemp);
  941. return totSize;
  942. }
  943. Uint32 StoreYuvImageBurstFormat(
  944. Uint32 coreIdx,
  945. FrameBuffer* fbSrc,
  946. TiledMapConfig mapCfg,
  947. Uint8* pDst,
  948. VpuRect cropRect,
  949. BOOL enableCrop
  950. )
  951. {
  952. Uint32 y, x;
  953. Uint32 pix_addr, div_x, div_y, chroma_stride;
  954. Uint8* puc;
  955. Uint8* rowBufferY, *rowBufferCb, *rowBufferCr;
  956. Uint32 stride = fbSrc->stride;
  957. Uint32 height = fbSrc->height;
  958. int interLeave = fbSrc->cbcrInterleave;
  959. BOOL nv21 = fbSrc->nv21;
  960. EndianMode endian = (EndianMode)fbSrc->endian;
  961. FrameBufferFormat format = (FrameBufferFormat)fbSrc->format;
  962. Uint32 width;
  963. Uint32 dstWidth, dstHeight;
  964. Uint32 offsetX, offsetY;
  965. Uint32 dstChromaHeight;
  966. Uint32 dstChromaWidth;
  967. Uint32 bpp=8;
  968. Uint32 p10_32bit_interleave = 0;
  969. Int32 productId;
  970. Int32 dramBusWidth = 8;
  971. Uint32 totSize = 0;
  972. productId = VPU_GetProductId(coreIdx);
  973. if (PRODUCT_ID_W_SERIES(productId)) {
  974. dramBusWidth = 16;
  975. }
  976. switch (fbSrc->format) {
  977. case FORMAT_420:
  978. case FORMAT_420_P10_16BIT_LSB:
  979. case FORMAT_420_P10_16BIT_MSB:
  980. case FORMAT_420_P10_32BIT_LSB:
  981. case FORMAT_420_P10_32BIT_MSB:
  982. case FORMAT_422:
  983. case FORMAT_422_P10_16BIT_LSB:
  984. case FORMAT_422_P10_16BIT_MSB:
  985. case FORMAT_422_P10_32BIT_LSB:
  986. case FORMAT_422_P10_32BIT_MSB:
  987. div_x = 2;
  988. break;
  989. default:
  990. div_x = 1;
  991. }
  992. switch (fbSrc->format) {
  993. case FORMAT_420:
  994. case FORMAT_420_P10_16BIT_LSB:
  995. case FORMAT_420_P10_16BIT_MSB:
  996. case FORMAT_420_P10_32BIT_LSB:
  997. case FORMAT_420_P10_32BIT_MSB:
  998. case FORMAT_224:
  999. div_y = 2;
  1000. break;
  1001. default:
  1002. div_y = 1;
  1003. }
  1004. width = (enableCrop == TRUE ? cropRect.right - cropRect.left : stride);
  1005. dstHeight = (enableCrop == TRUE ? cropRect.bottom - cropRect.top : height);
  1006. offsetX = (enableCrop == TRUE ? cropRect.left : 0);
  1007. offsetY = (enableCrop == TRUE ? cropRect.top : 0);
  1008. switch (fbSrc->format) {
  1009. case FORMAT_420_P10_16BIT_LSB:
  1010. case FORMAT_420_P10_16BIT_MSB:
  1011. dstWidth = width * 2;
  1012. bpp = 16;
  1013. dstChromaWidth = dstWidth / div_x;
  1014. dstChromaHeight = dstHeight / div_y;
  1015. chroma_stride = (stride / div_x);
  1016. break;
  1017. case FORMAT_420_P10_32BIT_LSB:
  1018. case FORMAT_420_P10_32BIT_MSB:
  1019. #ifdef DUMP_YUV_WHOLE_DATA
  1020. if (interLeave)
  1021. {
  1022. dstChromaWidth = ((VPU_ALIGN16(width/div_x))*2+11)/12*16;
  1023. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  1024. dstChromaHeight = dstHeight / div_y;
  1025. stride = stride;
  1026. chroma_stride = stride;
  1027. dstWidth = (VPU_ALIGN16(width)+11)/12*16;
  1028. interLeave = 0;
  1029. }
  1030. else
  1031. {
  1032. dstChromaWidth = ((VPU_ALIGN16(width/div_x))+11)/12*16;
  1033. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  1034. dstChromaHeight = dstHeight / div_y;
  1035. chroma_stride = dstChromaWidth;
  1036. stride = (VPU_ALIGN16(stride)+11)/12*16;
  1037. dstWidth = (VPU_ALIGN16(dstWidth)+11)/12*16;
  1038. }
  1039. break;
  1040. #else
  1041. if (interLeave)
  1042. {
  1043. dstChromaWidth = ((VPU_ALIGN16(width*2/div_x))+11)/12*16;
  1044. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  1045. chroma_stride = stride;
  1046. dstChromaWidth = (width+2)/3*4;
  1047. dstChromaHeight = dstHeight / div_y;
  1048. dstWidth = (width+2)/3*4;
  1049. interLeave = 0;
  1050. p10_32bit_interleave = 1;
  1051. }
  1052. else
  1053. {
  1054. dstChromaWidth = ((VPU_ALIGN16(width/div_x))+11)/12*16;
  1055. dstChromaWidth = VPU_ALIGN16(dstChromaWidth);
  1056. chroma_stride = dstChromaWidth;
  1057. dstChromaWidth = (width/2+2)/3*4;
  1058. dstChromaHeight = dstHeight / div_y;
  1059. dstWidth = (width+2)/3*4;
  1060. }
  1061. break;
  1062. #endif
  1063. case FORMAT_YUYV:
  1064. case FORMAT_YUYV_P10_16BIT_MSB:
  1065. case FORMAT_YUYV_P10_16BIT_LSB:
  1066. case FORMAT_YUYV_P10_32BIT_MSB:
  1067. case FORMAT_YUYV_P10_32BIT_LSB:
  1068. case FORMAT_YVYU:
  1069. case FORMAT_YVYU_P10_16BIT_MSB:
  1070. case FORMAT_YVYU_P10_16BIT_LSB:
  1071. case FORMAT_YVYU_P10_32BIT_MSB:
  1072. case FORMAT_YVYU_P10_32BIT_LSB:
  1073. case FORMAT_UYVY:
  1074. case FORMAT_UYVY_P10_16BIT_MSB:
  1075. case FORMAT_UYVY_P10_16BIT_LSB:
  1076. case FORMAT_UYVY_P10_32BIT_MSB:
  1077. case FORMAT_UYVY_P10_32BIT_LSB:
  1078. case FORMAT_VYUY:
  1079. case FORMAT_VYUY_P10_16BIT_MSB:
  1080. case FORMAT_VYUY_P10_16BIT_LSB:
  1081. case FORMAT_VYUY_P10_32BIT_MSB:
  1082. case FORMAT_VYUY_P10_32BIT_LSB:
  1083. dstWidth = stride;
  1084. dstChromaWidth = 0;
  1085. dstChromaHeight = 0;
  1086. chroma_stride = 0;
  1087. break;
  1088. default:
  1089. dstWidth = width;
  1090. dstChromaWidth = width / div_x;
  1091. dstChromaHeight = dstHeight / div_y;
  1092. chroma_stride = (stride / div_x);
  1093. break;
  1094. }
  1095. puc = pDst;
  1096. rowBufferY = (Uint8*)osal_malloc(stride);
  1097. rowBufferCb = (Uint8*)osal_malloc(stride*4);
  1098. rowBufferCr = (Uint8*)osal_malloc(stride*2);
  1099. for ( y=0 ; y<dstHeight ; y+=1 )
  1100. {
  1101. for ( x=0; x<stride ; x+=dramBusWidth )
  1102. {
  1103. pix_addr = GetXY2AXIAddr(&mapCfg, 0, y+offsetY, x, stride, fbSrc);
  1104. vdi_read_memory(coreIdx, pix_addr, rowBufferY+x, dramBusWidth, endian);
  1105. }
  1106. osal_memcpy(puc+y*dstWidth, rowBufferY+offsetX, dstWidth);
  1107. totSize += dstWidth;
  1108. }
  1109. if (format == FORMAT_400) {
  1110. osal_free(rowBufferY);
  1111. osal_free(rowBufferCb);
  1112. osal_free(rowBufferCr);
  1113. return totSize;
  1114. }
  1115. if (interLeave == TRUE) {
  1116. Uint8 pTemp[16];
  1117. Uint8* dstAddrCb;
  1118. Uint8* dstAddrCr;
  1119. Uint8* ptrCb, *ptrCr;
  1120. Int32 cbcr_per_2pix=1, k;
  1121. dstAddrCb = pDst + dstWidth*dstHeight;
  1122. dstAddrCr = dstAddrCb + dstChromaWidth*dstChromaHeight;
  1123. cbcr_per_2pix = (format==FORMAT_224||format==FORMAT_444) ? 2 : 1;
  1124. for ( y = 0 ; y < dstChromaHeight; ++y ) {
  1125. ptrCb = rowBufferCb;
  1126. ptrCr = rowBufferCr;
  1127. for ( x = 0 ; x < stride*cbcr_per_2pix ; x += dramBusWidth ) {
  1128. pix_addr = GetXY2AXIAddr(&mapCfg, 2, y+(offsetY/div_y), x, stride, fbSrc);
  1129. vdi_read_memory(coreIdx, pix_addr, pTemp, dramBusWidth, endian);
  1130. // CHECK POINT
  1131. if ( fbSrc->format == FORMAT_420_P10_32BIT_MSB )
  1132. SwapPixelOrder(pTemp);
  1133. // CHECK POINT
  1134. for (k=0; k<dramBusWidth && (x+k) < stride; k+=(2*bpp/8)) {
  1135. if (bpp == 8) {
  1136. if (nv21) {
  1137. *ptrCr++ = pTemp[k];
  1138. *ptrCb++ = pTemp[k+1];
  1139. }
  1140. else {
  1141. *ptrCb++ = pTemp[k];
  1142. *ptrCr++ = pTemp[k+1];
  1143. }
  1144. }
  1145. else {
  1146. if (nv21) {
  1147. *ptrCr++ = pTemp[k];
  1148. *ptrCr++ = pTemp[k+1];
  1149. *ptrCb++ = pTemp[k+2];
  1150. *ptrCb++ = pTemp[k+3];
  1151. }
  1152. else {
  1153. *ptrCb++ = pTemp[k];
  1154. *ptrCb++ = pTemp[k+1];
  1155. *ptrCr++ = pTemp[k+2];
  1156. *ptrCr++ = pTemp[k+3];
  1157. }
  1158. }
  1159. }
  1160. }
  1161. osal_memcpy(dstAddrCb+y*dstChromaWidth, rowBufferCb+offsetX/div_x, dstChromaWidth);
  1162. totSize += dstChromaWidth;
  1163. osal_memcpy(dstAddrCr+y*dstChromaWidth, rowBufferCr+offsetX/div_x, dstChromaWidth);
  1164. totSize += dstChromaWidth;
  1165. }
  1166. }
  1167. else {
  1168. puc = pDst + dstWidth*dstHeight;
  1169. for (y = 0 ; y < dstChromaHeight; y += 1) {
  1170. for (x = 0 ; x < chroma_stride; x += dramBusWidth) {
  1171. pix_addr = GetXY2AXIAddr(&mapCfg, 2, y+(offsetY/div_y), x, chroma_stride, fbSrc);
  1172. vdi_read_memory(coreIdx, pix_addr, rowBufferCb+x, dramBusWidth, endian);
  1173. }
  1174. osal_memcpy(puc + (y*dstChromaWidth), rowBufferCb+offsetX/div_x, dstChromaWidth);
  1175. totSize += dstChromaWidth;
  1176. }
  1177. puc += dstChromaWidth * dstChromaHeight;
  1178. if ( (fbSrc->format == FORMAT_420_P10_32BIT_LSB || fbSrc->format == FORMAT_420_P10_32BIT_MSB) &&
  1179. p10_32bit_interleave == 1)
  1180. {
  1181. }
  1182. else
  1183. {
  1184. for (y = 0 ; y < dstChromaHeight; y += 1) {
  1185. for ( x = 0 ; x < chroma_stride; x += dramBusWidth ) {
  1186. pix_addr = GetXY2AXIAddr(&mapCfg, 3, y+(offsetY/div_y), x, chroma_stride, fbSrc);
  1187. vdi_read_memory(coreIdx, pix_addr, rowBufferCr+x, dramBusWidth, endian);
  1188. }
  1189. osal_memcpy(puc + (y*dstChromaWidth), rowBufferCr+offsetX/div_x, dstChromaWidth);
  1190. totSize += dstChromaWidth;
  1191. }
  1192. }
  1193. }
  1194. osal_free(rowBufferY);
  1195. osal_free(rowBufferCb);
  1196. osal_free(rowBufferCr);
  1197. return totSize;
  1198. }
  1199. Uint8* GetYUVFromFrameBuffer(
  1200. DecHandle decHandle,
  1201. FrameBuffer* fb,
  1202. VpuRect rcFrame,
  1203. Uint32* retWidth,
  1204. Uint32* retHeight,
  1205. Uint32* retBpp,
  1206. size_t* retSize
  1207. )
  1208. {
  1209. Uint32 coreIdx = VPU_HANDLE_CORE_INDEX(decHandle);
  1210. size_t frameSizeY; // the size of luma
  1211. size_t frameSizeC; // the size of chroma
  1212. size_t frameSize; // the size of frame
  1213. Uint32 Bpp = 1; //!<< Byte per pixel
  1214. Uint32 picWidth, picHeight;
  1215. Uint8* pYuv;
  1216. TiledMapConfig mapCfg;
  1217. picWidth = rcFrame.right - rcFrame.left;
  1218. picHeight = rcFrame.bottom - rcFrame.top;
  1219. CalcYuvSize(fb->format, picWidth, fb->height, fb->cbcrInterleave, &frameSizeY, &frameSizeC, &frameSize, NULL, NULL, NULL);
  1220. switch (fb->format) {
  1221. case FORMAT_422_P10_16BIT_MSB:
  1222. case FORMAT_422_P10_16BIT_LSB:
  1223. case FORMAT_420_P10_16BIT_LSB:
  1224. case FORMAT_420_P10_16BIT_MSB:
  1225. Bpp = 2;
  1226. break;
  1227. case FORMAT_420_P10_32BIT_LSB:
  1228. case FORMAT_420_P10_32BIT_MSB:
  1229. picWidth = (picWidth/3)*4 + ((picWidth%3) ? 4 : 0);
  1230. Bpp = 1;
  1231. break;
  1232. case FORMAT_422:
  1233. case FORMAT_422_P10_32BIT_MSB:
  1234. case FORMAT_422_P10_32BIT_LSB:
  1235. break;
  1236. default:
  1237. Bpp = 1;
  1238. break;
  1239. }
  1240. {
  1241. Int32 temp_picWidth;
  1242. Int32 chromaWidth;
  1243. switch (fb->format) {
  1244. case FORMAT_420_P10_32BIT_LSB:
  1245. case FORMAT_420_P10_32BIT_MSB:
  1246. temp_picWidth = VPU_ALIGN32(picWidth);
  1247. chromaWidth = ((VPU_ALIGN16(temp_picWidth / 2*(1 << 1)) + 2) / 3 * 4);
  1248. frameSizeY = (temp_picWidth + 2) / 3 * 4 * picHeight;
  1249. frameSizeC = chromaWidth * picHeight / 2 * 2;
  1250. frameSize = frameSizeY + frameSizeC;
  1251. break;
  1252. default:
  1253. break;
  1254. }
  1255. }
  1256. if ((pYuv=(Uint8*)osal_malloc(frameSize)) == NULL) {
  1257. VLOG(ERR, "%s:%d Failed to allocate memory\n", __FUNCTION__, __LINE__);
  1258. return NULL;
  1259. }
  1260. VPU_DecGiveCommand(decHandle, GET_TILEDMAP_CONFIG, &mapCfg);
  1261. if (fb->mapType == LINEAR_FRAME_MAP || fb->mapType == COMPRESSED_FRAME_MAP) {
  1262. if (decHandle->codecMode == C7_VP9_DEC) {
  1263. *retSize = StoreYuvImageBurstLinear(coreIdx, fb, mapCfg, pYuv, rcFrame, TRUE, TRUE);
  1264. }
  1265. else {
  1266. *retSize = StoreYuvImageBurstLinear(coreIdx, fb, mapCfg, pYuv, rcFrame, TRUE, FALSE);
  1267. }
  1268. }
  1269. else {
  1270. *retSize = StoreYuvImageBurstFormat(coreIdx, fb, mapCfg, pYuv, rcFrame, TRUE);
  1271. }
  1272. *retWidth = picWidth;
  1273. *retHeight = picHeight;
  1274. *retBpp = Bpp;
  1275. return pYuv;
  1276. }
  1277. void PrepareDecoderTest(
  1278. DecHandle decHandle
  1279. )
  1280. {
  1281. UNREFERENCED_PARAMETER(decHandle);
  1282. }
  1283. void PreparationWorkForDecTest(
  1284. DecHandle handle
  1285. )
  1286. {
  1287. UNREFERENCED_PARAMETER(handle);
  1288. }
  1289. void PreparationWorkForEncTest(
  1290. EncHandle handle
  1291. )
  1292. {
  1293. UNREFERENCED_PARAMETER(handle);
  1294. }
  1295. int ProcessEncodedBitstreamBurst(Uint32 coreIdx, osal_file_t fp, int targetAddr,
  1296. PhysicalAddress bsBufStartAddr, PhysicalAddress bsBufEndAddr,
  1297. int size, int endian, Comparator comparator)
  1298. {
  1299. Uint8 * buffer = 0;
  1300. int room = 0;
  1301. int file_wr_size = 0;
  1302. buffer = (Uint8 *)osal_malloc(size);
  1303. if( ( targetAddr + size ) > (int)bsBufEndAddr )
  1304. {
  1305. room = bsBufEndAddr - targetAddr;
  1306. vdi_read_memory(coreIdx, targetAddr, buffer, room, endian);
  1307. vdi_read_memory(coreIdx, bsBufStartAddr, buffer+room, (size-room), endian);
  1308. }
  1309. else
  1310. {
  1311. vdi_read_memory(coreIdx, targetAddr, buffer, size, endian);
  1312. }
  1313. if ( comparator) {
  1314. if (Comparator_Act(comparator, buffer, size) == FALSE) {
  1315. osal_free(buffer);
  1316. return 0;
  1317. }
  1318. }
  1319. if (fp) {
  1320. file_wr_size = osal_fwrite(buffer, sizeof(Uint8), size, fp);
  1321. osal_fflush(fp);
  1322. }
  1323. osal_free( buffer );
  1324. return file_wr_size;
  1325. }
  1326. #ifdef SUPPORT_ENCODE_CUSTOM_HEADER
  1327. Uint32 activeParameterSEIEncode(sei_active_parameter_t *sap, hrd_t *hrd, Uint8 *pBuffer, Uint32 bufferSize)
  1328. {
  1329. spp_enc_context spp;
  1330. Uint32 code;
  1331. const Uint32 layer_id = 0;
  1332. const Uint32 temporal_id_plus_one = 1;
  1333. const Uint32 payload_type = (Uint32)ACTIVE_PARAMETER_SETS;
  1334. Uint32 put_bit_byte_size;
  1335. Uint32 payload_bit_size;
  1336. Uint32 payload_byte_size;
  1337. int i;
  1338. payload_bit_size = 0;
  1339. payload_byte_size = 0;
  1340. spp = spp_enc_init(pBuffer, bufferSize, 1);
  1341. // put start code
  1342. spp_enc_put_nal_byte(spp, 1, 4);
  1343. // put nal header
  1344. code = (SNT_PREFIX_SEI << 9) | (layer_id << 3) | temporal_id_plus_one;
  1345. spp_enc_put_nal_byte(spp, code, 2);
  1346. // put payload type
  1347. spp_enc_put_nal_byte(spp, payload_type, 1);
  1348. // put payload size
  1349. payload_bit_size = 4/*active_video_parameter_set_id*/ + 1/*self_contained_cvs_flag*/ + 1/*no_parameter_set_update_flag*/;
  1350. payload_bit_size += spp_enc_get_ue_bit_size(sap->num_sps_ids_minus1);
  1351. for (i=0; i <= sap->num_sps_ids_minus1; i++)
  1352. payload_bit_size+= spp_enc_get_ue_bit_size(sap->active_seq_parameter_set_id[i]);
  1353. payload_byte_size = ((payload_bit_size+7)/8);
  1354. spp_enc_put_nal_byte(spp, payload_byte_size, 1);
  1355. spp_enc_put_bits(spp, sap->active_video_parameter_set_id, 4);
  1356. spp_enc_put_bits(spp, sap->self_contained_cvs_flag, 1);
  1357. spp_enc_put_bits(spp, sap->no_parameter_set_update_flag, 1);
  1358. spp_enc_put_ue(spp, sap->num_sps_ids_minus1);
  1359. for (i=0; i <= sap->num_sps_ids_minus1; i++)
  1360. {
  1361. spp_enc_put_ue(spp, sap->active_seq_parameter_set_id[i]);
  1362. }
  1363. if (payload_bit_size & 7)
  1364. {
  1365. spp_enc_put_bits(spp, 1/*payload_bit_equal_to_one*/, 1);
  1366. spp_enc_put_bits(spp, 0/*payload_bit_equal_to_zero*/, (8 - (payload_bit_size & 7)-1));
  1367. }
  1368. spp_enc_put_byte_align(spp, 1);
  1369. spp_enc_flush(spp);
  1370. put_bit_byte_size = spp_enc_get_nal_cnt(spp);
  1371. spp_enc_deinit(spp);
  1372. return put_bit_byte_size;
  1373. }
  1374. Uint32 picTimingSEIEncode(sei_pic_timing_t *spt, hrd_t *hrd, Uint8 *pBuffer, Uint32 bufferSize)
  1375. {
  1376. spp_enc_context spp;
  1377. Uint32 code;
  1378. const Uint32 layer_id = 0;
  1379. const Uint32 temporal_id_plus_one = 1;
  1380. const Uint32 payload_type = (Uint32)PICTURE_TIMING;
  1381. Uint32 put_bit_byte_size;
  1382. Uint32 payload_bit_size;
  1383. Uint32 payload_byte_size;
  1384. int i;
  1385. payload_bit_size = 0;
  1386. payload_byte_size = 0;
  1387. if (hrd->nal_hrd_parameters_present_flag || hrd->vcl_hrd_parameters_present_flag)
  1388. spt->CpbDpbDelaysPresentFlag = 1;
  1389. spp = spp_enc_init(pBuffer, bufferSize, 1);
  1390. // put start code
  1391. spp_enc_put_nal_byte(spp, 1, 4);
  1392. // put nal header
  1393. code = (SNT_PREFIX_SEI << 9) | (layer_id << 3) | temporal_id_plus_one;
  1394. spp_enc_put_nal_byte(spp, code, 2);
  1395. // put payload type
  1396. spp_enc_put_nal_byte(spp, payload_type, 1);
  1397. // put payload size
  1398. payload_bit_size = 4/*pic_struct*/ + 2/*source_scan_type*/ + 1/*duplicate_flag*/;
  1399. if (spt->CpbDpbDelaysPresentFlag)
  1400. {
  1401. payload_bit_size += (hrd->au_cpb_removal_delay_length_minus1 + 1); //spt->au_cpb_removal_delay_minus1
  1402. payload_bit_size += (hrd->dpb_output_delay_length_minus1+ 1); // spt->pic_dpb_output_delay
  1403. if (hrd->sub_pic_hrd_params_present_flag)
  1404. payload_bit_size += (hrd->dpb_output_delay_du_length_minus1 + 1); //spt->pic_dpb_output_du_delay
  1405. if (hrd->sub_pic_hrd_params_present_flag &&
  1406. hrd->sub_pic_cpb_params_in_pic_timing_sei_flag)
  1407. {
  1408. payload_bit_size += spp_enc_get_ue_bit_size(spt->num_decoding_units_minus1); //spt->num_decoding_units_minus1
  1409. payload_bit_size += 1; // spt->du_common_cpb_removal_delay_flag
  1410. if (spt->du_common_cpb_removal_delay_flag)
  1411. payload_bit_size += (hrd->du_cpb_removal_delay_increment_length_minus1 + 1); //spt->du_common_cpb_removal_delay_increment_minus1
  1412. for (i=0; i <= spt->num_decoding_units_minus1; i++)
  1413. {
  1414. payload_bit_size += spp_enc_get_ue_bit_size(spt->num_nalus_in_du_minus1[i]); //spt->num_nalus_in_du_minus1[i]
  1415. if (!spt->du_common_cpb_removal_delay_flag && i < spt->num_decoding_units_minus1)
  1416. {
  1417. payload_bit_size += (hrd->du_cpb_removal_delay_increment_length_minus1 + 1); // spt->du_cpb_removal_delay_increment_minus1[i]
  1418. }
  1419. }
  1420. }
  1421. }
  1422. payload_byte_size = ((payload_bit_size+7)/8);
  1423. spp_enc_put_nal_byte(spp, payload_byte_size, 1);
  1424. spp_enc_put_bits(spp, spt->pic_struct, 4);
  1425. spp_enc_put_bits(spp, spt->source_scan_type, 2);
  1426. spp_enc_put_bits(spp, spt->duplicate_flag, 1);
  1427. if (spt->CpbDpbDelaysPresentFlag)
  1428. {
  1429. spp_enc_put_bits(spp, spt->au_cpb_removal_delay_minus1, (hrd->au_cpb_removal_delay_length_minus1 + 1));
  1430. spp_enc_put_bits(spp, spt->pic_dpb_output_delay, (hrd->dpb_output_delay_length_minus1+ 1));
  1431. if (hrd->sub_pic_hrd_params_present_flag)
  1432. spp_enc_put_bits(spp, spt->pic_dpb_output_du_delay, (hrd->dpb_output_delay_du_length_minus1 + 1));
  1433. if (hrd->sub_pic_hrd_params_present_flag &&
  1434. hrd->sub_pic_cpb_params_in_pic_timing_sei_flag)
  1435. {
  1436. spp_enc_put_ue(spp, spt->num_decoding_units_minus1);
  1437. spp_enc_put_bits(spp, spt->du_common_cpb_removal_delay_flag, 1);
  1438. if (spt->du_common_cpb_removal_delay_flag)
  1439. spp_enc_put_bits(spp, spt->du_common_cpb_removal_delay_increment_minus1, (hrd->du_cpb_removal_delay_increment_length_minus1 + 1));
  1440. for (i=0; i <= spt->num_decoding_units_minus1; i++)
  1441. {
  1442. spp_enc_put_ue(spp, spt->num_nalus_in_du_minus1[i]);
  1443. if (!spt->du_common_cpb_removal_delay_flag && i < spt->num_decoding_units_minus1)
  1444. {
  1445. spp_enc_put_bits(spp, spt->du_cpb_removal_delay_increment_minus1[i], (hrd->du_cpb_removal_delay_increment_length_minus1 + 1));
  1446. }
  1447. }
  1448. }
  1449. }
  1450. if (payload_bit_size & 7)
  1451. {
  1452. spp_enc_put_bits(spp, 1/*payload_bit_equal_to_one*/, 1);
  1453. spp_enc_put_bits(spp, 0/*payload_bit_equal_to_zero*/, (8 - (payload_bit_size & 7)-1));
  1454. }
  1455. spp_enc_put_byte_align(spp, 1);
  1456. spp_enc_flush(spp);
  1457. put_bit_byte_size = spp_enc_get_nal_cnt(spp);
  1458. spp_enc_deinit(spp);
  1459. return put_bit_byte_size;
  1460. }
  1461. Uint32 bufferingPeriodSeiEncode(sei_buffering_period_t *sbp, hrd_t *hrd, Uint8 *pBuffer, Uint32 bufferSize)
  1462. {
  1463. spp_enc_context spp;
  1464. Uint32 code;
  1465. const Uint32 layer_id = 0;
  1466. const Uint32 temporal_id_plus_one = 1;
  1467. const Uint32 payload_type = (Uint32)BUFFERING_PERIOD;
  1468. int i;
  1469. Uint32 put_bit_byte_size;
  1470. Uint32 payload_bit_size;
  1471. Uint32 payload_byte_size;
  1472. payload_bit_size = 0;
  1473. payload_byte_size = 0;
  1474. sbp->sub_pic_hrd_params_present_flag = hrd->sub_pic_hrd_params_present_flag;
  1475. sbp->au_cpb_removal_delay_length_minus1 = hrd->au_cpb_removal_delay_length_minus1;
  1476. sbp->initial_cpb_removal_delay_length_minus1 = hrd->initial_cpb_removal_delay_length_minus1;
  1477. sbp->CpbCnt = hrd->cpb_cnt_minus1[0]+1;
  1478. sbp->NalHrdBpPresentFlag = hrd->nal_hrd_parameters_present_flag;
  1479. sbp->VclHrdBpPresentFlag = hrd->vcl_hrd_parameters_present_flag;
  1480. payload_bit_size += spp_enc_get_ue_bit_size(sbp->bp_seq_parameter_set_id);
  1481. if (!sbp->sub_pic_hrd_params_present_flag)
  1482. payload_bit_size += 1; //irap_cpb_params_present_flag
  1483. if (sbp->irap_cpb_params_present_flag)
  1484. {
  1485. payload_bit_size += (sbp->au_cpb_removal_delay_length_minus1+1); //cpb_delay_offset
  1486. payload_bit_size += (sbp->au_cpb_removal_delay_length_minus1+1); //dpb_delay_offset
  1487. }
  1488. payload_bit_size += 1; //concatenation_flag
  1489. payload_bit_size += (sbp->au_cpb_removal_delay_length_minus1+1); //au_cpb_removal_delay_delta_minus1
  1490. if (sbp->NalHrdBpPresentFlag)
  1491. {
  1492. for (i=0; i < (int)sbp->CpbCnt; i++)
  1493. {
  1494. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //nal_initial_cpb_removal_delay
  1495. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //nal_initial_cpb_removal_offset
  1496. if (sbp->sub_pic_hrd_params_present_flag || sbp->irap_cpb_params_present_flag)
  1497. {
  1498. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); // nal_initial_alt_cpb_removal_delay
  1499. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //nal_initial_alt_cpb_removal_offset
  1500. }
  1501. }
  1502. }
  1503. if (sbp->VclHrdBpPresentFlag )
  1504. {
  1505. for (i=0; i < (int)sbp->CpbCnt; i++)
  1506. {
  1507. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //vcl_initial_cpb_removal_delay
  1508. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //vcl_initial_cpb_removal_offset
  1509. if (sbp->sub_pic_hrd_params_present_flag || sbp->irap_cpb_params_present_flag)
  1510. {
  1511. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //vcl_initial_alt_cpb_removal_delay
  1512. payload_bit_size += (sbp->initial_cpb_removal_delay_length_minus1+1); //vcl_initial_alt_cpb_removal_offset
  1513. }
  1514. }
  1515. }
  1516. spp = spp_enc_init(pBuffer, bufferSize, 1);
  1517. // put start code
  1518. spp_enc_put_nal_byte(spp, 1, 4);
  1519. // put nal header
  1520. code = (SNT_PREFIX_SEI << 9) | (layer_id << 3) | temporal_id_plus_one;
  1521. spp_enc_put_nal_byte(spp, code, 2);
  1522. // put payload type
  1523. spp_enc_put_nal_byte(spp, payload_type, 1);
  1524. // put payload size
  1525. payload_byte_size = ((payload_bit_size+7)/8);
  1526. spp_enc_put_nal_byte(spp, payload_byte_size, 1);
  1527. // put buffering period
  1528. spp_enc_put_ue(spp, sbp->bp_seq_parameter_set_id);
  1529. if (!sbp->sub_pic_hrd_params_present_flag)
  1530. spp_enc_put_bits(spp, sbp->irap_cpb_params_present_flag, 1);
  1531. if (sbp->irap_cpb_params_present_flag)
  1532. {
  1533. spp_enc_put_bits(spp, sbp->dpb_delay_offset, (sbp->au_cpb_removal_delay_length_minus1+1));
  1534. spp_enc_put_bits(spp, sbp->dpb_delay_offset, (sbp->au_cpb_removal_delay_length_minus1+1));
  1535. }
  1536. spp_enc_put_bits(spp, sbp->concatenation_flag, 1);
  1537. spp_enc_put_bits(spp, sbp->au_cpb_removal_delay_delta_minus1, (sbp->au_cpb_removal_delay_length_minus1+1));
  1538. if (sbp->NalHrdBpPresentFlag)
  1539. {
  1540. for (i=0; i < (int)sbp->CpbCnt; i++)
  1541. {
  1542. spp_enc_put_bits(spp, sbp->nal_initial_cpb_removal_delay[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1543. spp_enc_put_bits(spp, sbp->nal_initial_cpb_removal_offset[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1544. if (sbp->sub_pic_hrd_params_present_flag || sbp->irap_cpb_params_present_flag)
  1545. {
  1546. spp_enc_put_bits(spp, sbp->nal_initial_alt_cpb_removal_delay[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1547. spp_enc_put_bits(spp, sbp->nal_initial_alt_cpb_removal_offset[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1548. }
  1549. }
  1550. }
  1551. if (sbp->VclHrdBpPresentFlag)
  1552. {
  1553. for (i=0; i < (int)sbp->CpbCnt; i++)
  1554. {
  1555. spp_enc_put_bits(spp, sbp->vcl_initial_cpb_removal_delay[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1556. spp_enc_put_bits(spp, sbp->vcl_initial_cpb_removal_offset[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1557. if (sbp->sub_pic_hrd_params_present_flag || sbp->irap_cpb_params_present_flag)
  1558. {
  1559. spp_enc_put_bits(spp, sbp->vcl_initial_alt_cpb_removal_delay[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1560. spp_enc_put_bits(spp, sbp->vcl_initial_alt_cpb_removal_offset[i], (sbp->initial_cpb_removal_delay_length_minus1+1));
  1561. }
  1562. }
  1563. }
  1564. if (payload_bit_size & 7)
  1565. {
  1566. spp_enc_put_bits(spp, 1/*payload_bit_equal_to_one*/, 1);
  1567. spp_enc_put_bits(spp, 0/*payload_bit_equal_to_zero*/, (8 - (payload_bit_size & 7)-1));
  1568. }
  1569. spp_enc_put_byte_align(spp, 1);
  1570. spp_enc_flush(spp);
  1571. put_bit_byte_size = spp_enc_get_nal_cnt(spp);
  1572. spp_enc_deinit(spp);
  1573. return put_bit_byte_size;
  1574. }
  1575. Uint32 EncodePrefixSEI( sei_active_parameter_t *sap, sei_pic_timing_t *spt, sei_buffering_period_t *sbp, hrd_t *hrd, Uint8 *pBuffer, Uint32 bufferSize)
  1576. {
  1577. Uint8 *ptrBuffer;
  1578. Uint32 byteSize;
  1579. byteSize = 0;
  1580. ptrBuffer = (Uint8 *)(pBuffer + byteSize);
  1581. byteSize += activeParameterSEIEncode(sap, hrd, ptrBuffer, bufferSize);
  1582. ptrBuffer = (Uint8 *)(pBuffer + byteSize);
  1583. byteSize += picTimingSEIEncode(spt, hrd, ptrBuffer, bufferSize);
  1584. ptrBuffer = (Uint8 *)(pBuffer + byteSize);
  1585. byteSize += bufferingPeriodSeiEncode(sbp, hrd, ptrBuffer, bufferSize);
  1586. return byteSize;
  1587. }
  1588. // calculate scale value of bitrate and initial delay
  1589. int calcScale(int x)
  1590. {
  1591. Uint32 iMask = 0xffffffff;
  1592. int scaleValue = 32;
  1593. if (x==0)
  1594. {
  1595. return 0;
  1596. }
  1597. while ((x&iMask) != 0)
  1598. {
  1599. scaleValue--;
  1600. iMask = (iMask >> 1);
  1601. }
  1602. return scaleValue;
  1603. }
  1604. static void hrdEncode(spp_enc_context spp, hrd_t *hrd)
  1605. {
  1606. Uint32 layer;
  1607. Uint32 cpb;
  1608. hrd->commonInfPresentFlag = 1;
  1609. // the other parameters can be configured according to the target application.
  1610. if (hrd->commonInfPresentFlag)
  1611. {
  1612. spp_enc_put_bits(spp, hrd->nal_hrd_parameters_present_flag, 1);
  1613. spp_enc_put_bits(spp, hrd->vcl_hrd_parameters_present_flag, 1);
  1614. if (hrd->nal_hrd_parameters_present_flag || hrd->vcl_hrd_parameters_present_flag)
  1615. {
  1616. spp_enc_put_bits(spp, hrd->sub_pic_hrd_params_present_flag, 1);
  1617. if (hrd->sub_pic_hrd_params_present_flag)
  1618. {
  1619. spp_enc_put_bits(spp, hrd->tick_divisor_minus2, 8);
  1620. spp_enc_put_bits(spp, hrd->du_cpb_removal_delay_increment_length_minus1, 5);
  1621. spp_enc_put_bits(spp, hrd->sub_pic_cpb_params_in_pic_timing_sei_flag, 1);
  1622. spp_enc_put_bits(spp, hrd->dpb_output_delay_du_length_minus1, 5);
  1623. }
  1624. spp_enc_put_bits(spp, hrd->bit_rate_scale, 4);
  1625. spp_enc_put_bits(spp, hrd->cpb_size_scale, 4);
  1626. if (hrd->sub_pic_hrd_params_present_flag)
  1627. {
  1628. spp_enc_put_bits(spp, hrd->cpb_size_du_scale, 4);
  1629. }
  1630. spp_enc_put_bits(spp, hrd->initial_cpb_removal_delay_length_minus1, 5);
  1631. spp_enc_put_bits(spp, hrd->au_cpb_removal_delay_length_minus1, 5);
  1632. spp_enc_put_bits(spp, hrd->dpb_output_delay_length_minus1, 5);
  1633. }
  1634. }
  1635. for (layer=0; layer <= (Uint32)hrd->vps_max_sub_layers_minus1; layer++)
  1636. {
  1637. spp_enc_put_bits(spp, hrd->fixed_pic_rate_general_flag[layer], 1);
  1638. if (!hrd->fixed_pic_rate_general_flag[layer])
  1639. spp_enc_put_bits(spp, hrd->fixed_pic_rate_within_cvs_flag[layer], 1);
  1640. if (hrd->fixed_pic_rate_within_cvs_flag[layer])
  1641. spp_enc_put_ue(spp, hrd->elemental_duration_in_tc_minus1[layer]);
  1642. else
  1643. spp_enc_put_bits(spp, hrd->low_delay_hrd_flag[layer], 1);
  1644. if (!hrd->low_delay_hrd_flag[layer])
  1645. spp_enc_put_ue(spp, hrd->cpb_cnt_minus1[layer]);
  1646. if (hrd->nal_hrd_parameters_present_flag)
  1647. {
  1648. for(cpb=0; cpb <= (Uint32)hrd->cpb_cnt_minus1[layer]; cpb++ )
  1649. {
  1650. spp_enc_put_ue(spp, hrd->bit_rate_value_minus1[cpb][layer]);
  1651. spp_enc_put_ue(spp, hrd->cpb_size_value_minus1[cpb][layer]);
  1652. if (hrd->sub_pic_hrd_params_present_flag)
  1653. {
  1654. spp_enc_put_ue(spp, hrd->cpb_size_du_value_minus1[cpb][layer]);
  1655. spp_enc_put_ue(spp, hrd->bit_rate_du_value_minus1[cpb][layer]);
  1656. }
  1657. spp_enc_put_bits(spp, hrd->cbr_flag[cpb][layer], 1);
  1658. }
  1659. }
  1660. if (hrd->vcl_hrd_parameters_present_flag)
  1661. {
  1662. for(cpb=0; cpb <= (Uint32)hrd->cpb_cnt_minus1[layer]; cpb++ )
  1663. {
  1664. spp_enc_put_ue(spp, hrd->bit_rate_value_minus1[cpb][layer]);
  1665. spp_enc_put_ue(spp, hrd->cpb_size_value_minus1[cpb][layer]);
  1666. if (hrd->sub_pic_hrd_params_present_flag)
  1667. {
  1668. spp_enc_put_ue(spp, hrd->cpb_size_du_value_minus1[cpb][layer]);
  1669. spp_enc_put_ue(spp, hrd->bit_rate_du_value_minus1[cpb][layer]);
  1670. }
  1671. spp_enc_put_bits(spp, hrd->cbr_flag[cpb][layer], 1);
  1672. }
  1673. }
  1674. }
  1675. }
  1676. BOOL EncodeVUI(hrd_t *hrd, vui_t *vui, Uint8 *pBuffer, Uint32 bufferSize, Uint32 *pByteSize, Uint32 *pBitSize, double dframeRate)
  1677. {
  1678. spp_enc_context spp;
  1679. Uint32 put_bit_byte_size;
  1680. Uint32 put_bit_bit_size;
  1681. // the other parameters can be configured according to the target application.
  1682. spp = spp_enc_init(pBuffer, bufferSize, 0);
  1683. spp_enc_put_bits(spp, vui->aspect_ratio_info_present_flag, 1);
  1684. if (vui->aspect_ratio_info_present_flag)
  1685. {
  1686. spp_enc_put_bits(spp, vui->aspect_ratio_idc, 8);
  1687. if (vui->aspect_ratio_idc == EXTENDED_SAR)
  1688. {
  1689. spp_enc_put_bits(spp, vui->sar_width, 16);
  1690. spp_enc_put_bits(spp, vui->sar_height, 16);
  1691. }
  1692. }
  1693. spp_enc_put_bits(spp, vui->overscan_info_present_flag, 1);
  1694. if (vui->overscan_info_present_flag)
  1695. {
  1696. spp_enc_put_bits(spp, vui->overscan_appropriate_flag, 1);
  1697. }
  1698. spp_enc_put_bits(spp, vui->video_signal_type_present_flag, 1);
  1699. if (vui->video_signal_type_present_flag)
  1700. {
  1701. spp_enc_put_bits(spp, vui->video_format, 3);
  1702. spp_enc_put_bits(spp, vui->video_full_range_flag, 1);
  1703. spp_enc_put_bits(spp, vui->colour_description_present_flag, 1);
  1704. if (vui->colour_description_present_flag)
  1705. {
  1706. spp_enc_put_bits(spp, vui->colour_primaries, 8);
  1707. spp_enc_put_bits(spp, vui->transfer_characteristics, 1);
  1708. spp_enc_put_bits(spp, vui->matrix_coeffs, 1);
  1709. }
  1710. }
  1711. spp_enc_put_bits(spp, vui->chroma_loc_info_present_flag, 1);
  1712. if (vui->chroma_loc_info_present_flag)
  1713. {
  1714. spp_enc_put_ue(spp, vui->chroma_sample_loc_type_top_field);
  1715. spp_enc_put_ue(spp, vui->chroma_sample_loc_type_bottom_field);
  1716. }
  1717. spp_enc_put_bits(spp, vui->neutral_chroma_indication_flag, 1);
  1718. spp_enc_put_bits(spp, vui->field_seq_flag, 1);
  1719. spp_enc_put_bits(spp, vui->frame_field_info_present_flag, 1);
  1720. spp_enc_put_bits(spp, vui->default_display_window_flag, 1);
  1721. if (vui->default_display_window_flag)
  1722. {
  1723. spp_enc_put_ue(spp, vui->def_disp_win_left_offset);
  1724. spp_enc_put_ue(spp, vui->def_disp_win_right_offset);
  1725. spp_enc_put_ue(spp, vui->def_disp_win_top_offset);
  1726. spp_enc_put_ue(spp, vui->def_disp_win_bottom_offset);
  1727. }
  1728. spp_enc_put_bits(spp, vui->vui_timing_info_present_flag, 1);
  1729. if (vui->vui_timing_info_present_flag)
  1730. {
  1731. spp_enc_put_bits(spp, vui->vui_num_units_in_tick, 32);
  1732. spp_enc_put_bits(spp, vui->vui_time_scale, 32);
  1733. spp_enc_put_bits(spp, vui->vui_poc_proportional_to_timing_flag, 1);
  1734. if (vui->vui_poc_proportional_to_timing_flag)
  1735. {
  1736. spp_enc_put_ue(spp, vui->vui_num_ticks_poc_diff_one_minus1);
  1737. }
  1738. spp_enc_put_bits(spp, vui->vui_hrd_parameters_present_flag, 1);
  1739. if (vui->vui_hrd_parameters_present_flag)
  1740. hrdEncode(spp, hrd);
  1741. }
  1742. spp_enc_put_bits(spp, vui->bitstream_restriction_flag, 1);
  1743. if (vui->bitstream_restriction_flag)
  1744. {
  1745. spp_enc_put_bits(spp, vui->tiles_fixed_structure_flag, 1);
  1746. spp_enc_put_bits(spp, vui->motion_vectors_over_pic_boundaries_flag, 1);
  1747. spp_enc_put_bits(spp, vui->restricted_ref_pic_lists_flag, 1);
  1748. spp_enc_put_ue(spp, vui->min_spatial_segmentation_idc);
  1749. spp_enc_put_ue(spp, vui->max_bytes_per_pic_denom);
  1750. spp_enc_put_ue(spp, vui->max_bits_per_min_cu_denom);
  1751. spp_enc_put_ue(spp, vui->log2_max_mv_length_horizontal);
  1752. spp_enc_put_ue(spp, vui->log2_max_mv_length_vertical);
  1753. }
  1754. spp_enc_flush(spp);
  1755. put_bit_byte_size = spp_enc_get_nal_cnt(spp);
  1756. put_bit_bit_size = spp_enc_get_rbsp_bit(spp);
  1757. if (pByteSize)
  1758. *pByteSize = put_bit_byte_size;
  1759. if (pBitSize)
  1760. *pBitSize = put_bit_bit_size;
  1761. spp_enc_deinit(spp);
  1762. return 1;
  1763. }
  1764. #endif