From 012ad0be089105c175e74decb26e9914735ed72e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sergio=20Valor=20Mart=C3=ADnez?= Date: Mon, 6 Sep 2021 20:02:58 +0200 Subject: [PATCH] Commit to continue on other pc --- Makefile | 9 + media/font/8bithud.png | Bin 0 -> 1094 bytes media/font/8bithud.txt | 194 + media/font/nokia.png | Bin 0 -> 2044 bytes media/font/nokia.txt | 194 + media/font/nokia2.png | Bin 0 -> 2464 bytes media/font/nokia2.txt | 194 + media/font/smb2.png | Bin 0 -> 1344 bytes media/font/smb2.txt | 194 + media/lang/ba_BA.txt | 158 + media/lang/en_UK.txt | 158 + media/lang/es_ES.txt | 158 + source/animatedsprite.cpp | 123 + source/animatedsprite.h | 69 + source/const.h | 358 ++ source/director.cpp | 538 +++ source/director.h | 109 + source/fade.cpp | 172 + source/fade.h | 55 + source/game.cpp | 3483 ++++++++++++++++ source/game.h | 512 +++ source/ifdefs.h | 22 + source/input.cpp | 209 + source/input.h | 87 + source/jail_audio.cpp | 213 + source/jail_audio.h | 26 + source/lang.cpp | 73 + source/lang.h | 37 + source/ltexture.cpp | 166 + source/ltexture.h | 66 + source/main.cpp | 57 + source/menu.cpp | 599 +++ source/menu.h | 195 + source/movingsprite.cpp | 286 ++ source/movingsprite.h | 137 + source/smartsprite.cpp | 233 ++ source/smartsprite.h | 73 + source/sprite.cpp | 165 + source/sprite.h | 86 + source/stb_image.h | 7897 +++++++++++++++++++++++++++++++++++++ source/stb_vorbis.c | 5565 ++++++++++++++++++++++++++ source/text.cpp | 177 + source/text.h | 66 + source/utils.cpp | 124 + source/utils.h | 78 + source/writer.cpp | 158 + source/writer.h | 80 + 47 files changed, 23553 insertions(+) create mode 100644 Makefile create mode 100644 media/font/8bithud.png create mode 100644 media/font/8bithud.txt create mode 100644 media/font/nokia.png create mode 100644 media/font/nokia.txt create mode 100644 media/font/nokia2.png create mode 100644 media/font/nokia2.txt create mode 100644 media/font/smb2.png create mode 100644 media/font/smb2.txt create mode 100644 media/lang/ba_BA.txt create mode 100644 media/lang/en_UK.txt create mode 100644 media/lang/es_ES.txt create mode 100644 source/animatedsprite.cpp create mode 100644 source/animatedsprite.h create mode 100644 source/const.h create mode 100644 source/director.cpp create mode 100644 source/director.h create mode 100644 source/fade.cpp create mode 100644 source/fade.h create mode 100644 source/game.cpp create mode 100644 source/game.h create mode 100644 source/ifdefs.h create mode 100644 source/input.cpp create mode 100644 source/input.h create mode 100644 source/jail_audio.cpp create mode 100644 source/jail_audio.h create mode 100644 source/lang.cpp create mode 100644 source/lang.h create mode 100644 source/ltexture.cpp create mode 100644 source/ltexture.h create mode 100644 source/main.cpp create mode 100644 source/menu.cpp create mode 100644 source/menu.h create mode 100644 source/movingsprite.cpp create mode 100644 source/movingsprite.h create mode 100644 source/smartsprite.cpp create mode 100644 source/smartsprite.h create mode 100644 source/sprite.cpp create mode 100644 source/sprite.h create mode 100644 source/stb_image.h create mode 100644 source/stb_vorbis.c create mode 100644 source/text.cpp create mode 100644 source/text.h create mode 100644 source/utils.cpp create mode 100644 source/utils.h create mode 100644 source/writer.cpp create mode 100644 source/writer.h diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8da8c3f --- /dev/null +++ b/Makefile @@ -0,0 +1,9 @@ +executable = njg + +macos: + mkdir -p bin + g++ -std=c++11 -Wall -O2 source/*.cpp -o bin/$(executable)_macos -lSDL2 +linux: + mkdir -p bin + g++ source/*.cpp -std=c++11 -Os -lSDL2 -ffunction-sections -fdata-sections -Wl,--gc-sections -o bin/$(executable)_linux + strip -s -R .comment -R .gnu.version bin/$(executable)_linux --strip-unneeded \ No newline at end of file diff --git a/media/font/8bithud.png b/media/font/8bithud.png new file mode 100644 index 0000000000000000000000000000000000000000..2ac5e4c8d74520242b2fb7a2bcf709bd8fc9a0e7 GIT binary patch literal 1094 zcmV-M1iAZ(P)Px(07*naRCt{2o7t9PF$hJ~<^TWk?H5xE5jcmCsMlscl|l#^7*f@Jxd4s_NXPow zvfhpT_qdRiy5p+oojAhM0dTk`RJWapbNLHU3$m*>sV z8)eDlcgJxYTF3hA9fUjpZOij%CFp`j-@k+M0Y`_+vMPctdpi$T+qdRIrHPS!bB1_w zFmhIYZ>3o&i!MZVBbd#LbgB_tJv=lXMsU>ul%lIxDLUgXss(-(ua zvAff1^8voP&YYN+#zaStx9O3d*YH^5SvmS#wZB{LWhEr9a%UBz1x1mEE)092SpTx} z?1i3{SDC#C_sZZw)Yvc!UZIn{IN7yk=V#|({D{uS%bWu`f~!OeiBkHi3{Z_QZ~Tf3 zG`fFJX3gWxuet560slLwc|;e2dB#O^&=Fj%E#A#vZMUkI9lxUHGHHAqqSo!eY?@z& z3h&j84SFXt_M;TP@*U33uk|zbCEA|#+49Y^cSj1=1bP9?FCn}QKytPT%-BccCDkT0 zyN-yc+xECe1zbDCbc4fQ_W9slhE*W@)%jO6Tgd*5U-!!;?$YE0Ll-$>eV<9ovx|wC zjbM$p4{RXJ;sp-kCLM|fUmq}zWE?mftJjyg4C9b9_F)ayj_f)>FGb4iBK4yZfKsrh zW8uxuqQ`kn8EcO%fkVFJu(F+E(=>~?>eR+Ob-cHj*0W?P?z?CRwoQoEMQur?PGbx&vIiRfX)zY%;e>TYU zI8$So#=^o%&9n1+{*TYm#q(;c_GvaqPzgF?=4zS-g1SzoGp%&4om%z+n=Di_Dh-6R zftnZTk0-O_NC%C#)*g+|`lxHPSHnHq);v-N{ylg%nF};NGtG`SKJtUHkH#bav&j9~ z{!H>5uzsGk;ek?lbtBpNcOB%eQbqs4e-_X2>^$fRg(9%ZYy@kV43zN;trte{S(+d( zg5>3u-?8JhJkqhS=FcFYa zH?6qa;aRNc(#&KKFLGBQQ!NT2YyWi$&d&exPj);bhafviL}mlf_?b=6>#EEjMVV*Y z^8cGMNYgY;vkkLmbq)AYb~I7VXL +4 +# 63 ? +6 +# 64 @ +8 +# 65 A +6 +# 66 B +6 +# 67 C +6 +# 68 D +6 +# 69 E +6 +# 70 F +6 +# 71 G +6 +# 72 H +6 +# 73 I +6 +# 74 J +6 +# 75 K +6 +# 76 L +6 +# 77 M +6 +# 78 N +6 +# 79 O +6 +# 80 P +6 +# 81 Q +6 +# 82 R +6 +# 83 S +6 +# 84 T +6 +# 85 U +6 +# 86 V +5 +# 87 W +6 +# 88 X +6 +# 89 Y +6 +# 90 Z +6 +# 91 [ +3 +# 92 \ +5 +# 93 ] +3 +# 94 ^ +4 +# 95 _ +6 +# 96 ` +2 +# 97 a +5 +# 98 b +5 +# 99 c +5 +# 100 d +5 +# 101 e +5 +# 102 f +5 +# 103 g +5 +# 104 h +5 +# 105 i +4 +# 106 j +5 +# 107 k +5 +# 108 l +5 +# 109 m +6 +# 110 n +5 +# 111 o +5 +# 112 p +5 +# 113 q +5 +# 114 r +5 +# 115 s +5 +# 116 t +4 +# 117 u +5 +# 118 v +5 +# 119 w +6 +# 120 x +4 +# 121 y +4 +# 122 z +5 +# 123 { +3 +# 124 | +2 +# 125 } +3 +# 126 ~ +3 \ No newline at end of file diff --git a/media/font/nokia.png b/media/font/nokia.png new file mode 100644 index 0000000000000000000000000000000000000000..6f9d351f136c8bf1d68c8198445838e02fab9ce0 GIT binary patch literal 2044 zcmVPx+wn;=mRCt{2T}yT&Aq>QMKB#?z?6b~3H?Z$Fhwy9$k4)=R1?tAJyEd7z6$yk8 zP@+4f5ICJaZ>Q7ejrko!r~GNj+-`qv@+Z>1NN3a^wy%+Vw!W7@9aL{%rL6oJ=|lpi z+P2!zw$Ibq>homK!A1Lk=xf{m(gB7B)=01*0b@B^lSB1+a%dnRL4fGg{D=Hb)W)rG zoZSEhm&@1v-`DHUL4Nn|{|^p6pT8G6s@&!Bb=T*~MQu8rK5t&TH2jmld9qcf)E(G& z^=*xhY=zhB&!G;KHejBdHNfrXm&=zrORHnOfo=oA(|NuA9JU@Tt-qEZwJdAtWtQNK z<#&~gg$#xqVENMv#`F0*oWWAI+OgVG^`SbqfEM_gUs^fw??r!+tY%C&RlWwDH_mWi zp-V$Hv;g#GFzW1QM-6&wGRg7qCZv_2J$)V;eWqXGz>*5Rtb#)Bb)*v!Iq|uQXbCRL z9;-KNNqs1g_961u>(4)oAKPHh9`8Y(x&V&*($?>zz=0^f7X40f_}z z5lY@gL@7e1B5XP%huUZKF${fAUqLKh(sIEC>Nv2wWlr%YzD0M5IM!p!fsSb%0>@A<(*tnBK6o)>&k#NJ0iNF z4vaM@#4?;#yhUcZwZygZS^zqIfZHEUy4J3joe{hDjJ0*PVt_7}1=#DL`bIE1IopY( zfmycDZH^MuUU}#a&Hlquh!AmWr1GYr;b9<{O<^$>(U;v{MjyIGV1Vj~_Q-I?Vp6Im z8!cUoE=I1Gjb`*^_IFeta!n|*iDpue&EK(Od)$`}hRv?XX4Ny8cSN?A@kjNcIwKiL zv-DnHVdUHIEqTZ;%Ce3y)){xtv+RyA{;0mJ{-PBGl;dOUTJosf`{q63Xi)w~JFRH4 z48vT(FxChdyQn@3TN9|G7;Wo)^Nu)}Wtg*XW-^`4++a$(o?cXrwYxPCqBO!s{Y9Bw zyrqUQnmsdR8@I&y{0;R5l`G|c7WbBunVD@Qs7g_4g-mB6qi6uknwbp9qx!E0QXcbg zWU>%jMqu|knP5*$TkG2rY^8yzjarPtqNIaf!H8-}ZLKR~-{IMIYHX%sI`@iQHwn-h zU^aSLd?dKM+Z7MYd*rZDw%n6pi=Nqxe+ILiAv@|9L=N#?;HS5^UcKW9;WF>-=i2{E z>1VfRG3u=>!@O(qy-Yd7Y$Knc`XV{6udSTvV~crjKezth%WltN)HPX#d5@TAlqqMJ zZR9glA0o&2+48ZiZ%O?r8~2Ys4m84C~GnAmR!~wP-X$WvprLHW*bpmj7>zAexu*B^H=OL zY1K(teauYv^s$#NSpwJUZ}u&X^hlkF-WuRYO_9;r(>^rIjMh-IRB zPREn8c%l|)hOug%Nc%?YYWlVyh1FW&=t)a-I_PBgedcDWB?6ZGK&wTz=X?$9snqjpCs z2$4?NmuJB}u%ewly39yD=zS+f=cpV~6w4&uLx_mB{kNU zVZbf95q%L*+Jt#4%`9w1ODvYc(YwyC2sQw>cz@UE&DFK_E$+NO8`0K-i1_Sz&(`&- z|9$ATJ~)Q*nGaenmuQ#)Q8 zcY-u}#mxxzrSSdmv37=ehSvn`*dE$bIu&W}Gk+!~f5$d}|H5i7Q(nsrdr<92#l8%_ aC;kF|qa=GTWuGAc0000 +6 +# 63 ? +7 +# 64 @ +8 +# 65 A +7 +# 66 B +7 +# 67 C +7 +# 68 D +7 +# 69 E +7 +# 70 F +7 +# 71 G +7 +# 72 H +7 +# 73 I +4 +# 74 J +6 +# 75 K +8 +# 76 L +6 +# 77 M +9 +# 78 N +8 +# 79 O +8 +# 80 P +7 +# 81 Q +8 +# 82 R +7 +# 83 S +6 +# 84 T +8 +# 85 U +7 +# 86 V +8 +# 87 W +9 +# 88 X +8 +# 89 Y +8 +# 90 Z +7 +# 91 [ +4 +# 92 \ +5 +# 93 ] +4 +# 94 ^ +5 +# 95 _ +8 +# 96 ` +4 +# 97 a +7 +# 98 b +7 +# 99 c +6 +# 100 d +7 +# 101 e +7 +# 102 f +5 +# 103 g +7 +# 104 h +7 +# 105 i +4 +# 106 j +5 +# 107 k +7 +# 108 l +4 +# 109 m +10 +# 110 n +7 +# 111 o +7 +# 112 p +7 +# 113 q +7 +# 114 r +6 +# 115 s +6 +# 116 t +5 +# 117 u +7 +# 118 v +7 +# 119 w +9 +# 120 x +7 +# 121 y +7 +# 122 z +7 +# 123 { -> ñ +7 +# 124 | -> ç +7 +# 125 } +0 +# 126 ~ +0 \ No newline at end of file diff --git a/media/font/nokia2.png b/media/font/nokia2.png new file mode 100644 index 0000000000000000000000000000000000000000..7e40857b8d270c0f2965b36d2c6f79dc8e17548a GIT binary patch literal 2464 zcmV;R319Y!P)Px;T1iAfRCt{2UAuDJI1q&7{S*hQ+~KOq$trW|k2%HCSNIDqaH7OzC91NryWFbs zeTuJmiH9Bz=g|XzyL(!8m1@_^W)A>@AlVqgr6jQ5?uPw#H)QrfH2J5+8HQotpGf&4 z&8R-vx<>rodanX>P`v}ox%@NIL^_Owpa&PN1EMF(|EfC}+Ob+X3({e% z#@2YKp2tHw0@4W(O|AWqeWEfR8kff|Kn7pGe;dC)zC2&>ZI3U{7dKbe<>u;o{EdH? zJgyh&MUGuOC0V1m$}C&${2CZBZFG*SchKjVN}e9>_f< zTK=eAYTFMf8&bxot{ZP7$K%WMMfvc)YcGEH_D#s)BaC(LlKG z-o7a}SJ&n1_iy8;1V0|c(_oFzo}LG;C)JhgT`$VEP;BBI{OB9pq$v>+OQGHYQ4}AFR zb?>3w*Yw~$zC2%e<+XFTad=%?c&HAFCHlb%2Z-HpYEN%VVRjay zXGbZ1Z$-|M-lG*7Kck1#*Ly;((aZ3b0@4>?A=JE!j8eo*McniZ4~?JEL+Xnfy{KM> zhax*tX3XJcu^MMPDjc^2q632PkoeLiw;El>@(vDCzMA$!+eL3(UC-mz@GV@D81hJp z0ClX1+mlE2K;nP>{%!n2xl#EdJESM5u036MVI{b{=wzGtSchm34%wkmFGk~`o$6P| z9~*-Xj_1jcmlW}294#*Iq=#s4SzilUr?T!(Ts$!5RZ4fhXE4Y( zRS}B&$A|ah?^=A`IQI`v<^JJmvJa1W|L_#Xrx^R~Zt!?$eXY899IGBwSK4mHMLP_^ zYBMXY#YN+8O8M>dM#wnUsKbna54YAn(mD1nU5K9CmZ`6Ga-w?DRo9TYY@xR~6xSP_ zjS*|6wJD{9ZZ>VZxw;BY_1F=$+m55+}Y))vRwGx)Nc*0{B0%jos0Z^lT~+9Si) z3}KCr#vRjUBBPC`{_@mbt-}0i#o}sDHBlL|aib^QOk7mY;#uu-s%Z7vE@cjQ)VVT2 zQD+-Prm|5^Q8q5c_ViF*ChjqS7^M*|X-A}Uq3$f9_gN`lf;be=5hgPdA=5F(9MxJn zRVlxGEW|k`a3|ObN*vEQuHnh=9?wIK9y%k@W9FiFeNjH&?z!(s+)ZW_Li3`@RgTU$ z&hthg)UoE^*q$XMR^{m?C9)4G&d^SMQfAMc}G%axg+ek-`rs)XeqngIrdy+ z?$D!7`3T|Uqk58u=y}kbcMI8e@qoJcQt#&Kx{Pfp>O5-~rA?Zg_l%#U@t1JkYvZE+ zRHT=g5y+IUC2p;!XzAC?gsfQ61+Mchf7kw9O1-;%EJs~(d(CBLo$`#cjr@k{MLe&r zl4rKD<-E(^t$(9#bgct^2)&H+9y!rS`LfP7@*Ap$@VvG`+O8DCdFM}x5|Q_UI`14k zocvZj2|m-nb&ru{dx$vN%t{20H+d794n$-?9?KD40-if>WwRdgM%8L-X=+=u5-5+j zUQDYT+V8Vh>`~GGYv;;LVJ#UKnVyQ4GUA$COCD^LCkK_5(RowKZzq*bt$O4sQGR#%@ZL=u$~e|F?*j1HylfJ(K77WclsK>5n<0=|q@%S9{dI+NtSmgB2A^pUfTIP~1f_nvBM9P?;9lFN>aR&H*8v9m+GH;FRNJHqoY z$$6)O@3(r+xa4WM(V7EpIlfX)E1>0AM|!lHjF&@?=7M_;w^qJL6R9_^rFDS}Agbk+NlC_s(){@z7AG9F2>{jHc>JNiJh_D#&!m z75xF9MCg+d8El7ol3EH&)}fbn&oZJ~nV2Eha^5Xot9eHHSXpZc3Ru!X6^mm7ht`dQzxwf~-p=&)_9;=&kr!y&ldsKW5Q! z>zzZ7a3?qKnH6Fpj^`McGB?^LU~cck;a6N>LQPJ2I)`3~kH%H?N<4$$f!{=XZQV16 z9_7OC{Tq9QsUMPjrDCZ*K>@MGvWO@A4s9nd5=-=uh%{$DO@QQA)p6PP9C0&GpSV;1;h%FG92e zb9UXUW3D1|sJY%r&U-2Cxz3X3xxPy}$31!I3OwZcBf0ynj=Id-N8cHs?^3r_Phyty z?)~o$t*fedx$r$#UkP7vs&K5`SHyxf*^#nayzF}Vnt?0ptF@0dbD{MGwEZSI@8p(S zE_Y^K@#uTBjaLNCDcADhqZAR;v9`bs!)OiqiSusEB4lO|I2X;cmop-~45&kowBIb3 zT?+7jXB=U(RBV4VuBNG#&B}%M%IWP>Ti>PfyP~JznqyM?&Oqe&zbfav=8?arO>j<# zPNsEAXT@=m@rhQfFz>Ny?sF{eIzIPI;8CzT)+v+IjbQoJ-RUYo}V# e73&k>dE!4YM)#xcvo!($0000 +6 +# 63 ? +7 +# 64 @ +8 +# 65 A +7 +# 66 B +7 +# 67 C +7 +# 68 D +7 +# 69 E +7 +# 70 F +7 +# 71 G +7 +# 72 H +7 +# 73 I +4 +# 74 J +6 +# 75 K +8 +# 76 L +6 +# 77 M +9 +# 78 N +8 +# 79 O +8 +# 80 P +7 +# 81 Q +8 +# 82 R +7 +# 83 S +6 +# 84 T +8 +# 85 U +7 +# 86 V +8 +# 87 W +9 +# 88 X +8 +# 89 Y +8 +# 90 Z +7 +# 91 [ +4 +# 92 \ +5 +# 93 ] +4 +# 94 ^ +5 +# 95 _ +8 +# 96 ` +4 +# 97 a +7 +# 98 b +7 +# 99 c +6 +# 100 d +7 +# 101 e +7 +# 102 f +5 +# 103 g +7 +# 104 h +7 +# 105 i +4 +# 106 j +5 +# 107 k +7 +# 108 l +4 +# 109 m +10 +# 110 n +7 +# 111 o +7 +# 112 p +7 +# 113 q +7 +# 114 r +6 +# 115 s +6 +# 116 t +5 +# 117 u +7 +# 118 v +7 +# 119 w +9 +# 120 x +7 +# 121 y +7 +# 122 z +7 +# 123 { -> ñ +7 +# 124 | -> ç +7 +# 125 } +0 +# 126 ~ +0 \ No newline at end of file diff --git a/media/font/smb2.png b/media/font/smb2.png new file mode 100644 index 0000000000000000000000000000000000000000..b11fade07e8e2852e1f68483c91a170ee3ebdaae GIT binary patch literal 1344 zcmV-G1;6@Px(`bk7VRCt{2Tv3keFbGVmUSaQlz;}p!U#=*HVE{Wxw;5@r#$b$XjDfVfZ6tnw z|NV|XkETDfbjgQgdu>Q&hKC*RlW;#;fo4S+wJGp-2^F1wvT6In5+TsZ79n( zSf4cgS+?D7KezFx+bmu*W_BUH&DG;say1Rr+2-4hULrt1Wt7s^1=ipc5Qfr?t6^ysoFI(q_oW>W%t8 zx&pe;r#89+t#*0m%IB=EUSIZpMm!Pi!XL)U=-RX>#*NMlg4iGex$CU_sDH$h4H9P| z>q*~SG|DsOvvgxj-irD&?l7`&Z^GeRN9!H5 z3mw)8$mF__%ZqT9h#rm41(|aF*gyGJZ74;u{QJ%@ttLv8;zp@5*&5#X{GHH-SpWPqH zL~W}Pt*?inE332Sd-+ynH27J94TK{$Zy-}un;D}Zq`x+M^d@VUXI0pa)=|UqAl7H8 zJIb*$#_?9kLY=!O15H5Fz5Z5T%Z<(2WN)Fpc57Tz-LquP+T3kZCpeSKRuJ7Ko@MJc zIpIA{trh$rJ_&DgDy7=W+P8n%z`7W=|7c^YMYG38UINMO(iuo&MnUh{uBZzOQTj&5 ziV8|pe#^Q#bdO1TCi1oTx_N4p2QxaNG2ZfEPti;nv*IGqVnsoUrKi595nc9YFCJVVxqqJoL1!>oJk==<>H8y!QTqY4FGtS+=i@|p1w z&kAFBzApTPO^y~op1u`xh~%+pCYvEJh>Xh3gO7GC7G~UE+lEt#Y?@UWe^0#q_{_4f zGj6s8&zi@aSQpEbU0c7j(=?&wX{Mywa`jKz9X$+Gm9?XHWiDuE27Ydq20qG)r_n<8CCoVCeJ%p%*Z zaif?88GxAwcQ?7qgZeUMMsFNzetVo+FL?F%B(g7AG+Y;rf})uV61kXc|Ix-)i)N3H zyabZlrC<0`wBKj4^b5zJ^hU(%!`?L)_Jey0Q57qyq+B=;%x`qC#r6y5NBaL{{e^1P zH{qVyT$Ec%oUt18tq7xN=53Q~)4Uh{7_O6hF8l}VkUZ!_lAqoH0000 +7 +# 63 ? +7 +# 64 @ +7 +# 65 A +7 +# 66 B +7 +# 67 C +7 +# 68 D +7 +# 69 E +7 +# 70 F +7 +# 71 G +7 +# 72 H +7 +# 73 I +7 +# 74 J +7 +# 75 K +7 +# 76 L +7 +# 77 M +7 +# 78 N +7 +# 79 O +7 +# 80 P +7 +# 81 Q +7 +# 82 R +7 +# 83 S +7 +# 84 T +7 +# 85 U +7 +# 86 V +7 +# 87 W +7 +# 88 X +7 +# 89 Y +7 +# 90 Z +7 +# 91 [ +7 +# 92 \ +7 +# 93 ] +7 +# 94 ^ +7 +# 95 _ +7 +# 96 ` +7 +# 97 a +7 +# 98 b +7 +# 99 c +7 +# 100 d +7 +# 101 e +7 +# 102 f +7 +# 103 g +7 +# 104 h +7 +# 105 i +7 +# 106 j +7 +# 107 k +7 +# 108 l +7 +# 109 m +7 +# 110 n +7 +# 111 o +7 +# 112 p +7 +# 113 q +7 +# 114 r +7 +# 115 s +7 +# 116 t +7 +# 117 u +7 +# 118 v +7 +# 119 w +7 +# 120 x +7 +# 121 y +7 +# 122 z +7 +# 123 { +7 +# 124 | +7 +# 125 } +7 +# 126 ~ +7 \ No newline at end of file diff --git a/media/lang/ba_BA.txt b/media/lang/ba_BA.txt new file mode 100644 index 0000000..af96a2a --- /dev/null +++ b/media/lang/ba_BA.txt @@ -0,0 +1,158 @@ +## 0 - MENU DEL TITULO +JUGAR +## 1 - MENU DEL TITULO +OPCIONS +## 2 - MENU DEL TITULO +INSTRUCCIONS +## 3 - MENU DEL TITULO +EIXIR +## 4 - MENU DE OPCIONES +FINESTRA +## 5 - MENU DE OPCIONES +PANTALLA COMPLETA +## 6 - MENU DE OPCIONES +PANTALLA COMPLETA FALSA +## 7 - MENU DE OPCIONES +TAMANY DE FINESTRA +## 8 - MENU DE OPCIONES +IDIOMA +## 9 - MENU DE OPCIONES +[ ACEPTAR ] +## 10 - MENU DE OPCIONES +[ CANCELAR ] +## 11 - INSTRUCCIONES +OBJECTIU +## 12 - INSTRUCCIONES +HAS D'EXPLOTAR +## 13 - INSTRUCCIONES +TANTS GLOBUS COM PUGUES +## 14 - INSTRUCCIONES +LA DIFICULTAT AUGMENTA +## 15 - INSTRUCCIONES +A MESURA QUE VAS PUNTUANT +## 16 - INSTRUCCIONES +OBJECTES +## 17 - INSTRUCCIONES +1.000 PUNTS +## 18 - INSTRUCCIONES +2.500 PUNTS +## 19 - INSTRUCCIONES +5.000 PUNTS +## 20 - INSTRUCCIONES +PARA EL TEMPS +## 21 - INSTRUCCIONES +VIDA EXTRA +## 22 - INSTRUCCIONES +PREM UNA TECLA PER A TORNAR +## 23 - TITULO +PREM QUALSEVOL TECLA +## 24 - MENU SELECCION DE IDIOMA +ESPA{OL (ESPANYOL) +## 25 - MENU SELECCION DE IDIOMA +BALOONCIA +## 26 - MENU SELECCION DE IDIOMA +ENGLISH (ANGLES) +## 27 - INTRO +Un dia qualsevol de l'any 2000 +## 28 - INTRO +Tot esta tranquil a la UPV +## 29 - INTRO +Fins que un desaprensiu... +## 30 - INTRO +HEY! ME ANE A FERME UN CORTAET... +## 31 - INTRO +UAAAAAAAAAAAAA!!! +## 32 - INTRO +Espera un moment... +## 33 - INTRO +Si resulta que no tinc solt! +## 34 - INTRO +MERDA DE MAQUINA! +## 35 - INTRO +Blop... blop... blop... +## 36 - TEXTOS DEL JUEGO +Temps detes: +## 37 - TEXTOS DEL JUEGO +D E M O +## 38 - TEXTOS DEL JUEGO +Pantalla +## 39 - MARCADOR +PUNTS +## 40 - MARCADOR +MAX.PUNT. +## 41 - MARCADOR +MULT +## 42 - MARCADOR +PANTALLA +## 43 - PANTALLA DE GAME OVER +FI DEL JOC +## 44 - PANTALLA DE GAME OVER +ELS TEUS PUNTS: +## 45 - PANTALLA DE GAME OVER +REINTENTAR? +## 46 - MENU DE PAUSA +CONTINUAR +## 47 - MENU DE PAUSA +EIXIR DEL JOC +## 48 - MENU GAME OVER +SI +## 49 - MENU GAME OVER +NO +## 50 - TEXTO DE COMPLETAR EL JUEGO +Felicitats!! +## 51 - MENU DEL TITULO +1 JUGADOR +## 52 - MENU DEL TITULO +2 JUGADORS +## 53 MARCADOR +jugador 1 +## 54 MARCADOR +jugador 2 +## 55 MARCADOR +mult +## 56 MARCADOR +max. puntuacio +## 57 MARCADOR +pantalla +## 58 - MENU DE OPCIONES +MODE DE VISUALITZACIO +## 59 - MENU DE OPCIONES +DIFICULTAT +## 60 - MENU DE OPCIONES +FILTRE +## 61 - MENU DE OPCIONES +SINC. VERTICAL +## 62 - MENU DE OPCIONES +CONTROLS DEL JUGADOR 1 +## 63 - MENU DE OPCIONES +CONTROLS DEL JUGADOR 2 +## 64 - MENU DE OPCIONES +TECLAT +## 65 - MENU DE OPCIONES +MANDO +## 66 - MENU DE OPCIONES +FACIL +## 67 - MENU DE OPCIONES +NORMAL +## 68 - MENU DE OPCIONES +DIFICIL +## 69 - MENU DE OPCIONES +TECLAT +## 70 - MENU DE OPCIONES +MANDO +## 71 - MENU DE OPCIONES +LINEAL +## 72 - MENU DE OPCIONES +NEAREST +## 73 - MENU DE OPCIONES +ACTIVADA +## 74 - MENU DE OPCIONES +DESACTIVADA +## 75 - JUEGO +Endavant! +## 76 - JUEGO +1.000.000 de punts! +## 77 - PANTALLA DE GAME OVER +PUNTS J1: +## 78 - PANTALLA DE GAME OVER +PUNTS J2: \ No newline at end of file diff --git a/media/lang/en_UK.txt b/media/lang/en_UK.txt new file mode 100644 index 0000000..d8e3ebc --- /dev/null +++ b/media/lang/en_UK.txt @@ -0,0 +1,158 @@ +## 0 - MENU DEL TITULO +PLAY +## 1 - MENU DEL TITULO +OPTIONS +## 2 - MENU DEL TITULO +HOW TO PLAY +## 3 - MENU DEL TITULO +QUIT +## 4 - MENU DE OPCIONES +WINDOW +## 5 - MENU DE OPCIONES +FULLSCREEN +## 6 - MENU DE OPCIONES +FAKE FULLSCREEN +## 7 - MENU DE OPCIONES +WINDOW SIZE +## 8 - MENU DE OPCIONES +LANGUAGE +## 9 - MENU DE OPCIONES +[ ACCEPT ] +## 10 - MENU DE OPCIONES +[ CANCEL ] +## 11 - INSTRUCCIONES +OBJECTIVE +## 12 - INSTRUCCIONES +YOU HAVE TO POP AS MANY +## 13 - INSTRUCCIONES +BALLOONS AS YOU CAN +## 14 - INSTRUCCIONES +DIFFICULTY WILL BE INCREASED +## 15 - INSTRUCCIONES +AS YOU SCORE POINTS +## 16 - INSTRUCCIONES +ITEMS +## 17 - INSTRUCCIONES +1.000 POINTS +## 18 - INSTRUCCIONES +2.500 POINTS +## 19 - INSTRUCCIONES +5.000 POINTS +## 20 - INSTRUCCIONES +TIME STOPPER +## 21 - INSTRUCCIONES +EXTRA HIT +## 22 - INSTRUCCIONES +PRESS ANY KEY TO RETURN +## 23 - TITULO +PRESS ANY KEY +## 24 - MENU SELECCION DE IDIOMA +ESPA{OL (SPANISH) +## 25 - MENU SELECCION DE IDIOMA +BALOONCIA (VALENCIAN) +## 26 - MENU SELECCION DE IDIOMA +ENGLISH +## 27 - INTRO +Any day of the year 2000 +## 28 - INTRO +Everything is quiet at the UPV +## 29 - INTRO +Until a bastard arrives... +## 30 - INTRO + YO! GONNA TAKE A CAFELITO... +## 31 - INTRO +AAAAAAAARGHHHH!!! +## 32 - INTRO +Wait a moment... +## 33 - INTRO + I don't have any loose! +## 34 - INTRO +FUCKING MACHINE! +## 35 - INTRO +Blop... blop... blop... +## 36 - TEXTOS DEL JUEGO +Time stopped: +## 37 - TEXTOS DEL JUEGO +D E M O +## 38 - TEXTOS DEL JUEGO +Stage +## 39 - MARCADOR +SCORE +## 40 - MARCADOR +HI-SCORE +## 41 - MARCADOR +MULT +## 42 - MARCADOR +STAGE +## 43 - PANTALLA DE GAME OVER +GAME OVER +## 44 - PANTALLA DE GAME OVER +YOUR SCORE: +## 45 - PANTALLA DE GAME OVER +RETRY? +## 46 - MENU DE PAUSA +CONTINUE +## 47 - MENU DE PAUSA +LEAVE GAME +## 48 - MENU GAME OVER +YES +## 49 - MENU GAME OVER +NO +## 50 - TEXTO DE COMPLETAR EL JUEGO +Congratulations!! +## 51 - MENU DEL TITULO +1 PLAYER +## 52 - MENU DEL TITULO +2 PLAYERS +## 53 - MARCADOR +player 1 +## 54 - MARCADOR +player 2 +## 55 - MARCADOR +mult +## 56 - MARCADOR +high score +## 57 - MARCADOR +stage +## 58 - MENU DE OPCIONES +DISPLAY MODE +## 59 - MENU DE OPCIONES +DIFFICULTY +## 60 - MENU DE OPCIONES +FILTER +## 61 - MENU DE OPCIONES +VSYNC +## 62 - MENU DE OPCIONES +PLAYER 1 CONTROLS +## 63 - MENU DE OPCIONES +PLAYER 2 CONTROLS +## 64 - MENU DE OPCIONES +KEYBOARD +## 65 - MENU DE OPCIONES +GAME CONTROLLER +## 66 - MENU DE OPCIONES +EASY +## 67 - MENU DE OPCIONES +NORMAL +## 68 - MENU DE OPCIONES +HARD +## 69 - MENU DE OPCIONES +KEYBOARD +## 70 - MENU DE OPCIONES +GAME CONTROLLER +## 71 - MENU DE OPCIONES +LINEAL +## 72 - MENU DE OPCIONES +NEAREST +## 73 - MENU DE OPCIONES +ON +## 74 - MENU DE OPCIONES +OFF +## 75 - JUEGO +Get Ready! +## 76 - JUEGO +1.000.000 points! +## 77 - PANTALLA DE GAME OVER +PLAYER1 SCORE: +## 78 - PANTALLA DE GAME OVER +PLAYER2 SCORE: \ No newline at end of file diff --git a/media/lang/es_ES.txt b/media/lang/es_ES.txt new file mode 100644 index 0000000..6c21712 --- /dev/null +++ b/media/lang/es_ES.txt @@ -0,0 +1,158 @@ +## 0 - MENU DEL TITULO +JUGAR +## 1 - MENU DEL TITULO +OPCIONES +## 2 - MENU DEL TITULO +INSTRUCCIONES +## 3 - MENU DEL TITULO +SALIR +## 4 - MENU DE OPCIONES +VENTANA +## 5 - MENU DE OPCIONES +PANTALLA COMPLETA +## 6 - MENU DE OPCIONES +PANTALLA COMPLETA FALSA +## 7 - MENU DE OPCIONES +TAMA{O DE VENTANA +## 8 - MENU DE OPCIONES +IDIOMA +## 9 - MENU DE OPCIONES +[ ACEPTAR ] +## 10 - MENU DE OPCIONES +[ CANCELAR ] +## 11 - INSTRUCCIONES +OBJETIVO +## 12 - INSTRUCCIONES +TIENES QUE EXPLOTAR +## 13 - INSTRUCCIONES +TANTOS GLOBOS COMO PUEDAS +## 14 - INSTRUCCIONES +LA DIFICULTAD SE INCREMENTA +## 15 - INSTRUCCIONES +A MEDIDA QUE VAS PUNTUANDO +## 16 - INSTRUCCIONES +OBJETOS +## 17 - INSTRUCCIONES +1.000 PUNTOS +## 18 - INSTRUCCIONES +2.500 PUNTOS +## 19 - INSTRUCCIONES +5.000 PUNTOS +## 20 - INSTRUCCIONES +DETIENE EL TIEMPO +## 21 - INSTRUCCIONES +VIDA EXTRA +## 22 - INSTRUCCIONES +PULSA UNA TECLA PARA VOLVER +## 23 - TITULO +PULSA CUALQUIER TECLA +## 24 - MENU SELECCION DE IDIOMA +ESPA{OL +## 25 - MENU SELECCION DE IDIOMA +BALOONCIA (VALENCIANO) +## 26 - MENU SELECCION DE IDIOMA +ENGLISH (INGLES) +## 27 - INTRO +Un dia cualquiera del a{o 2000 +## 28 - INTRO +Todo esta tranquilo en la UPV +## 29 - INTRO +Hasta que un desaprensivo... +## 30 - INTRO +HEY! VOY A SACARME UN TALLADET... +## 31 - INTRO +UAAAAAAAAAAAAA!!! +## 32 - INTRO +Espera un momento... +## 33 - INTRO +Si no llevo suelto encima! +## 34 - INTRO +MIERDA DE MAQUINA! +## 35 - INTRO +Blop... blop... blop... +## 36 - TEXTOS DEL JUEGO +Tiempo: +## 37 - TEXTOS DEL JUEGO +D E M O +## 38 - TEXTOS DEL JUEGO +Fase +## 39 - MARCADOR +PUNTOS +## 40 - MARCADOR +MAX.PUNT. +## 41 - MARCADOR +MULT +## 42 - MARCADOR +FASE +## 43 - PANTALLA DE GAME OVER +FIN DE JUEGO +## 44 - PANTALLA DE GAME OVER +TU PUNTUACION: +## 45 - PANTALLA DE GAME OVER +REINTENTAR? +## 46 - MENU DE PAUSA +CONTINUAR +## 47 - MENU DE PAUSA +SALIR DEL JUEGO +## 48 - MENU GAME OVER +SI +## 49 - MENU GAME OVER +NO +## 50 - TEXTO DE COMPLETAR EL JUEGO +Felicidades!! +## 51 - MENU DEL TITULO +1 JUGADOR +## 52 - MENU DEL TITULO +2 JUGADORES +## 53 - MARCADOR +jugador 1 +## 54 - MARCADOR +jugador 2 +## 55 - MARCADOR +mult +## 56 - MARCADOR +max. puntuacion +## 57 - MARCADOR +fase +## 58 - MENU DE OPCIONES +MODO DE VISUALIZACION +## 59 - MENU DE OPCIONES +DIFICULTAD +## 60 - MENU DE OPCIONES +FILTRO +## 61 - MENU DE OPCIONES +SINC. VERTICAL +## 62 - MENU DE OPCIONES +CONTROLES DEL JUGADOR 1 +## 63 - MENU DE OPCIONES +CONTROLES DEL JUGADOR 2 +## 64 - MENU DE OPCIONES +TECLADO +## 65 - MENU DE OPCIONES +MANDO +## 66 - MENU DE OPCIONES +FACIL +## 67 - MENU DE OPCIONES +NORMAL +## 68 - MENU DE OPCIONES +DIFICIL +## 69 - MENU DE OPCIONES +TECLADO +## 70 - MENU DE OPCIONES +MANDO +## 71 - MENU DE OPCIONES +LINEAL +## 72 - MENU DE OPCIONES +NEAREST +## 73 - MENU DE OPCIONES +ACTIVADA +## 74 - MENU DE OPCIONES +DESACTIVADA +## 75 - JUEGO +Adelante! +## 76 - JUEGO +1.000.000 de puntos! +## 77 - PANTALLA DE GAME OVER +PUNTUACION J1: +## 78 - PANTALLA DE GAME OVER +PUNTUACION J2: \ No newline at end of file diff --git a/source/animatedsprite.cpp b/source/animatedsprite.cpp new file mode 100644 index 0000000..faf4ad4 --- /dev/null +++ b/source/animatedsprite.cpp @@ -0,0 +1,123 @@ +#include "const.h" +#include "animatedsprite.h" + +// Constructor +AnimatedSprite::AnimatedSprite() +{ + //init(nullptr, nullptr); +} + +// Destructor +AnimatedSprite::~AnimatedSprite() +{ + //init(nullptr, nullptr); +} + +// Iniciador +void AnimatedSprite::init(LTexture *texture, SDL_Renderer *renderer) +{ + mRenderer = renderer; + mTexture = texture; + for (int i = 0; i < 20; i++) + { + mAnimation[i].numFrames = 0; + mAnimation[i].speed = 0; + mAnimation[i].loop = true; + mAnimation[i].completed = false; + for (int j = 0; i < 20; i++) + { + mAnimation[i].frames[j].x = 0; + mAnimation[i].frames[j].y = 0; + mAnimation[i].frames[j].w = 0; + mAnimation[i].frames[j].h = 0; + } + } + mCurrentFrame = 0; + mAnimationCounter = 0; +} + +// Calcula el frame correspondiente a la animación +void AnimatedSprite::animate(int index) +{ + if (mEnabled) + { + // Calculamos el frame actual a partir del contador + mCurrentFrame = mAnimationCounter / mAnimation[index].speed; + + // Si alcanzamos el final de la animación, reiniciamos el contador de la animación + // en función de la variable loop + if (mCurrentFrame >= mAnimation[index].numFrames) + { + if (mAnimation[index].loop) + mAnimationCounter = 0; + else + mCurrentFrame = mAnimation[index].numFrames; + } + // En caso contrario + else + { + // Escogemos el frame correspondiente de la animación + setSpriteClip(mAnimation[index].frames[mCurrentFrame]); + + // Incrementamos el contador de la animacion + mAnimationCounter++; + } + } +} + +// Establece el frame actual de la animación +void AnimatedSprite::setCurrentFrame(Uint8 num) +{ + mCurrentFrame = num; +} + +// Establece el valor del contador +void AnimatedSprite::setAnimationCounter(Uint16 num) +{ + mAnimationCounter = num; +} + +// Establece el rectangulo para un frame de una animación +void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h) +{ + mAnimation[index_animation].frames[index_frame].x = x; + mAnimation[index_animation].frames[index_frame].y = y; + mAnimation[index_animation].frames[index_frame].w = w; + mAnimation[index_animation].frames[index_frame].h = h; +} + +// Establece la velocidad de una animación +void AnimatedSprite::setAnimationSpeed(Uint8 index, Uint8 speed) +{ + mAnimation[index].speed = speed; +} + +// Establece el numero de frames de una animación +void AnimatedSprite::setAnimationNumFrames(Uint8 index, Uint8 num) +{ + mAnimation[index].numFrames = num; +} + +// Establece si la animación se reproduce en bucle +void AnimatedSprite::setAnimationLoop(Uint8 index, bool loop) +{ + mAnimation[index].loop = loop; +} + +// Establece el valor de la variable +void AnimatedSprite::setCompleted(Uint8 index, bool value) +{ + mAnimation[index].completed = value; +} + +// Comprueba si ha terminado la animación +bool AnimatedSprite::isCompleted(Uint8 index) +{ + return mAnimation[index].completed; +} + +// Devuelve el rectangulo de una animación y frame concreto +SDL_Rect AnimatedSprite::getAnimationClip(Uint8 index_animation, Uint8 index_frame) +{ + return mAnimation[index_animation].frames[index_frame]; +} \ No newline at end of file diff --git a/source/animatedsprite.h b/source/animatedsprite.h new file mode 100644 index 0000000..f1c84bc --- /dev/null +++ b/source/animatedsprite.h @@ -0,0 +1,69 @@ +#pragma once +#include "ifdefs.h" +#include "movingsprite.h" + +#ifndef ANIMATEDSPRITE_H +#define ANIMATEDSPRITE_H + +#define MAX_FRAMES 30 +#define MAX_ANIMATIONS 20 + +// Clase AnimatedSprite +class AnimatedSprite : public MovingSprite +{ +private: + struct sAnimation + { + SDL_Rect frames[MAX_FRAMES]; // Cada uno de los frames que componen la animación + Uint8 numFrames; // Numero de frames que componen la animación + Uint8 speed; // Velocidad de la animación + bool loop; // Indica si la animación se reproduce en bucle + bool completed; // Indica si ha finalizado la animación + }; + sAnimation mAnimation[MAX_ANIMATIONS]; // Vector con las diferentes animaciones + + Uint8 mCurrentFrame; // Frame actual + Uint16 mAnimationCounter; // Contador para las animaciones + +public: + // Constructor + AnimatedSprite(); + + // Destructor + ~AnimatedSprite(); + + // Iniciador + void init(LTexture *texture, SDL_Renderer *renderer); + + // Calcula el frame correspondiente a la animación + void animate(int index); + + // Establece el frame actual de la animación + void setCurrentFrame(Uint8 num); + + // Establece el valor del contador + void setAnimationCounter(Uint16 num); + + // Establece el rectangulo para un frame de una animación + void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h); + + // Establece la velocidad de una animación + void setAnimationSpeed(Uint8 index, Uint8 speed); + + // Establece el numero de frames de una animación + void setAnimationNumFrames(Uint8 index, Uint8 num); + + // Establece si la animación se reproduce en bucle + void setAnimationLoop(Uint8 index, bool loop); + + // Establece el valor de la variable + void setCompleted(Uint8 index, bool value); + + // Comprueba si ha terminado la animación + bool isCompleted(Uint8 index); + + // Devuelve el rectangulo de una animación y frame concreto + SDL_Rect getAnimationClip(Uint8 index_animation, Uint8 index_frame); +}; + +#endif \ No newline at end of file diff --git a/source/const.h b/source/const.h new file mode 100644 index 0000000..10e8cd6 --- /dev/null +++ b/source/const.h @@ -0,0 +1,358 @@ +#pragma once +#include "ifdefs.h" +#include "utils.h" +#include "lang.h" +#include + +#ifndef CONST_H +#define CONST_H + +// Textos +#define WINDOW_CAPTION "Coffee Crisis" +#define TEXT_COPYRIGHT "@2020,2021 JailDesigner (v2.0.1)" + +// Recursos +#define BINFILE_SCORE 0 +#define BINFILE_DEMO 1 +#define BINFILE_CONFIG 2 + +#define TOTAL_BINFILE 3 + +#define MUSIC_INTRO 0 +#define MUSIC_PLAYING 1 +#define MUSIC_TITLE 2 + +#define TOTAL_MUSIC 3 + +#define SOUND_BALLOON 0 +#define SOUND_BUBBLE1 1 +#define SOUND_BUBBLE2 2 +#define SOUND_BUBBLE3 3 +#define SOUND_BUBBLE4 4 +#define SOUND_BULLET 5 +#define SOUND_COFFEE_OUT 6 +#define SOUND_HISCORE 7 +#define SOUND_ITEM_DROP 8 +#define SOUND_ITEM_PICKUP 9 +#define SOUND_MENU_CANCEL 10 +#define SOUND_MENU_MOVE 11 +#define SOUND_MENU_SELECT 12 +#define SOUND_PLAYER_COLLISION 13 +#define SOUND_STAGE_CHANGE 14 +#define SOUND_TITLE 15 +#define SOUND_CLOCK 16 +#define SOUND_POWERBALL 17 + +#define TOTAL_SOUND 18 + +#define TEXTURE_BALLOON 0 +#define TEXTURE_BULLET 1 +#define TEXTURE_FONT_BLACK 2 +#define TEXTURE_FONT_BLACK_X2 3 +#define TEXTURE_FONT_NOKIA 4 +#define TEXTURE_FONT_WHITE 5 +#define TEXTURE_FONT_WHITE_X2 6 +#define TEXTURE_GAME_BG 7 +#define TEXTURE_GAME_TEXT 8 +#define TEXTURE_INTRO 9 +#define TEXTURE_ITEMS 10 +#define TEXTURE_LOGO 11 +#define TEXTURE_MENU 12 +#define TEXTURE_PLAYER_BODY 13 +#define TEXTURE_PLAYER_DEATH 14 +#define TEXTURE_PLAYER_LEGS 15 +#define TEXTURE_TITLE 16 + +#define TOTAL_TEXTURE 17 + +// Tamaño de bloque +#define BLOCK 8 +#define HALF_BLOCK BLOCK / 2 + +// Tamaño de la pantalla real +#define SCREEN_WIDTH 256 +const int SCREEN_HEIGHT = SCREEN_WIDTH * 3 / 4; + +// Tamaño de la pantalla que se muestra +const int VIEW_WIDTH = SCREEN_WIDTH * 3; +const int VIEW_HEIGHT = SCREEN_HEIGHT * 3; + +// Cantidad de enteros a escribir en los ficheros de datos +#define TOTAL_SCORE_DATA 3 +#define TOTAL_DEMO_DATA 2000 + +// Zona de juego +const int PLAY_AREA_TOP = (0 * BLOCK); +const int PLAY_AREA_BOTTOM = SCREEN_HEIGHT - (4 * BLOCK); +const int PLAY_AREA_LEFT = (0 * BLOCK); +const int PLAY_AREA_RIGHT = SCREEN_WIDTH - (0 * BLOCK); +const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT; +const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP; +const int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2); +const int PLAY_AREA_CENTER_FIRST_QUARTER_X = (PLAY_AREA_WIDTH / 4); +const int PLAY_AREA_CENTER_THIRD_QUARTER_X = (PLAY_AREA_WIDTH / 4) * 3; +const int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2); +const int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4; +const int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3; + +// Anclajes de pantalla +const int SCREEN_CENTER_X = SCREEN_WIDTH / 2; +const int SCREEN_FIRST_QUARTER_X = SCREEN_WIDTH / 4; +const int SCREEN_THIRD_QUARTER_X = (SCREEN_WIDTH / 4) * 3; +const int SCREEN_CENTER_Y = SCREEN_HEIGHT / 2; +const int SCREEN_FIRST_QUARTER_Y = SCREEN_HEIGHT / 4; +const int SCREEN_THIRD_QUARTER_Y = (SCREEN_HEIGHT / 4) * 3; + +// Opciones de menu +#define MENU_NO_OPTION -1 +#define MENU_OPTION_START 0 +#define MENU_OPTION_QUIT 1 +#define MENU_OPTION_TOTAL 2 + +// Tipos de fondos para el menu +#define MENU_BACKGROUND_TRANSPARENT 0 +#define MENU_BACKGROUND_SOLID 1 + +// Estados del jugador +#define PLAYER_STATUS_WALKING_LEFT 0 +#define PLAYER_STATUS_WALKING_RIGHT 1 +#define PLAYER_STATUS_WALKING_STOP 2 + +#define PLAYER_STATUS_FIRING_UP 0 +#define PLAYER_STATUS_FIRING_LEFT 1 +#define PLAYER_STATUS_FIRING_RIGHT 2 +#define PLAYER_STATUS_FIRING_NO 3 + +#define PLAYER_ANIMATION_LEGS_WALKING_LEFT 0 +#define PLAYER_ANIMATION_LEGS_WALKING_RIGHT 1 +#define PLAYER_ANIMATION_LEGS_WALKING_STOP 2 + +#define PLAYER_ANIMATION_BODY_WALKING_LEFT 0 +#define PLAYER_ANIMATION_BODY_FIRING_LEFT 1 +#define PLAYER_ANIMATION_BODY_WALKING_RIGHT 2 +#define PLAYER_ANIMATION_BODY_FIRING_RIGHT 3 +#define PLAYER_ANIMATION_BODY_WALKING_STOP 4 +#define PLAYER_ANIMATION_BODY_FIRING_UP 5 + +#define PLAYER_ANIMATION_HEAD_WALKING_LEFT 0 +#define PLAYER_ANIMATION_HEAD_FIRING_LEFT 1 +#define PLAYER_ANIMATION_HEAD_WALKING_RIGHT 2 +#define PLAYER_ANIMATION_HEAD_FIRING_RIGHT 3 +#define PLAYER_ANIMATION_HEAD_WALKING_STOP 4 +#define PLAYER_ANIMATION_HEAD_FIRING_UP 5 + +// Variables del jugador +#define PLAYER_INVULNERABLE_COUNTER 200 +#define PLAYER_POWERUP_COUNTER 1500 + +// Secciones del programa +#define PROG_SECTION_LOGO 0 +#define PROG_SECTION_INTRO 1 +#define PROG_SECTION_TITLE 2 +#define PROG_SECTION_GAME 3 +#define PROG_SECTION_QUIT 4 + +// Subsecciones +#define GAME_SECTION_PLAY_1P 0 +#define GAME_SECTION_PLAY_2P 1 +#define GAME_SECTION_PAUSE 2 +#define GAME_SECTION_GAMEOVER 3 +#define TITLE_SECTION_1 3 +#define TITLE_SECTION_2 4 +#define TITLE_SECTION_3 5 +#define TITLE_SECTION_INSTRUCTIONS 6 + +// Modo para las instrucciones +#define INSTRUCTIONS_MODE_MANUAL 0 +#define INSTRUCTIONS_MODE_AUTO 1 + +// Estados de cada elemento que pertenece a un evento +#define EVENT_WAITING 1 +#define EVENT_RUNNING 2 +#define EVENT_COMPLETED 3 + +// Cantidad de eventos de la intro +#define INTRO_TOTAL_BITMAPS 6 +#define INTRO_TOTAL_TEXTS 9 +const int INTRO_TOTAL_EVENTS = INTRO_TOTAL_BITMAPS + INTRO_TOTAL_TEXTS; + +// Cantidad de eventos de la pantalla de titulo +#define TITLE_TOTAL_EVENTS 2 + +// Relaciones de Id con nomnbres +#define BITMAP0 0 +#define BITMAP1 1 +#define BITMAP2 2 +#define BITMAP3 3 +#define BITMAP4 4 +#define BITMAP5 5 +#define TEXT0 6 +#define TEXT1 7 +#define TEXT2 8 +#define TEXT3 9 +#define TEXT4 10 +#define TEXT5 11 +#define TEXT6 12 +#define TEXT7 13 +#define TEXT8 14 + +// Anclajes para el marcador de puntos +const int SCORE_WORD_X = (SCREEN_WIDTH / 4) - ((5 * BLOCK) / 2); +const int SCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 2; +const int SCORE_NUMBER_X = (SCREEN_WIDTH / 4) - ((6 * BLOCK) / 2); +const int SCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 2; + +const int HISCORE_WORD_X = ((SCREEN_WIDTH / 4) * 3) - ((8 * BLOCK) / 2); +const int HISCORE_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 2; +const int HISCORE_NUMBER_X = ((SCREEN_WIDTH / 4) * 3) - ((6 * BLOCK) / 2); +const int HISCORE_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 2; + +const int MULTIPLIER_WORD_X = (SCREEN_WIDTH / 2) - ((4 * BLOCK) / 2); +const int MULTIPLIER_WORD_Y = SCREEN_HEIGHT - (3 * BLOCK) + 2; +const int MULTIPLIER_NUMBER_X = (SCREEN_WIDTH / 2) - ((3 * BLOCK) / 2); +const int MULTIPLIER_NUMBER_Y = SCREEN_HEIGHT - (2 * BLOCK) + 2; + +// Ningun tipo +#define NO_KIND 0 + +// Tipos de globo +#define BALLOON_1 1 +#define BALLOON_2 2 +#define BALLOON_3 3 +#define BALLOON_4 4 +#define HEXAGON_1 5 +#define HEXAGON_2 6 +#define HEXAGON_3 7 +#define HEXAGON_4 8 +#define POWER_BALL 9 + +// Puntos de globo +#define BALLOON_SCORE_1 50 +#define BALLOON_SCORE_2 100 +#define BALLOON_SCORE_3 200 +#define BALLOON_SCORE_4 400 + +// Tamaños de globo +#define BALLOON_SIZE_1 1 +#define BALLOON_SIZE_2 2 +#define BALLOON_SIZE_3 3 +#define BALLOON_SIZE_4 4 + +// Clases de globo +#define BALLOON_CLASS 0 +#define HEXAGON_CLASS 1 + +// Velocidad del globo +#define BALLOON_VELX_POSITIVE 0.7f +#define BALLOON_VELX_NEGATIVE -0.7f + +// Indice para las animaciones de los globos +#define BALLOON_MOVING_ANIMATION 0 +#define BALLOON_POP_ANIMATION 1 +#define BALLOON_BORN_ANIMATION 2 + +// Cantidad posible de globos +#define MAX_BALLOONS 100 + +// Velocidades a las que se mueven los enemigos +#define BALLOON_SPEED_1 0.60f +#define BALLOON_SPEED_2 0.70f +#define BALLOON_SPEED_3 0.80f +#define BALLOON_SPEED_4 0.90f +#define BALLOON_SPEED_5 1.00f + +// Tamaño de los globos +#define BALLOON_WIDTH_1 8 +#define BALLOON_WIDTH_2 13 +#define BALLOON_WIDTH_3 21 +#define BALLOON_WIDTH_4 37 + +// PowerBall +#define POWERBALL_SCREENPOWER_MINIMUM 10 +#define POWERBALL_COUNTER 8 + +// Tipos de bala +#define BULLET_UP 1 +#define BULLET_LEFT 2 +#define BULLET_RIGHT 3 + +// Cantidad posible de globos +#define MAX_BULLETS 50 + +// Tipos de objetos +#define ITEM_POINTS_1_DISK 1 +#define ITEM_POINTS_2_GAVINA 2 +#define ITEM_POINTS_3_PACMAR 3 +#define ITEM_CLOCK 4 +#define ITEM_COFFEE 5 +#define ITEM_POWER_BALL 6 +#define ITEM_COFFEE_MACHINE 7 + +// Porcentaje de aparición de los objetos +#define ITEM_POINTS_1_DISK_ODDS 10 +#define ITEM_POINTS_2_GAVINA_ODDS 6 +#define ITEM_POINTS_3_PACMAR_ODDS 3 +#define ITEM_CLOCK_ODDS 5 +#define ITEM_COFFEE_ODDS 5 +#define ITEM_POWER_BALL_ODDS 0 +#define ITEM_COFFEE_MACHINE_ODDS 4 + +// Cantidad de objetos simultaneos +#define MAX_ITEMS 10 + +// Valores para las variables asociadas a los objetos +#define REMAINING_EXPLOSIONS 3 +#define REMAINING_EXPLOSIONS_COUNTER 50 +#define TIME_STOPPED_COUNTER 300 + +// Estados de entrada +#define NO_INPUT 0 +#define INPUT_FIRE_LEFT 7 +#define INPUT_FIRE_UP 8 +#define INPUT_FIRE_RIGHT 9 +#define INPUT_PAUSE 10 + +// Zona muerta del mando analógico +#define JOYSTICK_DEAD_ZONE 8000 + +// Tipos de mensajes para el retorno de las funciones +#define MSG_OK 0 +#define MSG_BULLET_OUT 1 + +// Tipos de texto +#define TEXT_FIXED 0 +#define TEXT_VARIABLE 1 + +// Cantidad de elementos del vector de SmartSprites +#define MAX_SMART_SPRITES 10 + +// Cantidad máxima de gotas de café +#define MAX_COFFEE_DROPS 100 + +// Contadores +#define TITLE_COUNTER 800 +#define STAGE_COUNTER 200 +#define INSTRUCTIONS_COUNTER 600 +#define DEATH_COUNTER 350 +#define SHAKE_COUNTER 10 +#define HELP_COUNTER 1000 + +// Colores +const color_t bgColor = {0x27, 0x27, 0x36}; +const color_t noColor = {0xFF, 0xFF, 0xFF}; +const color_t shdwTxtColor = {0x43, 0x43, 0x4F}; + +// Formaciones enemigas +#define NUMBER_OF_ENEMY_FORMATIONS 100 +#define MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION 50 + +// Dificultad del juego +#define DIFFICULTY_EASY 0 +#define DIFFICULTY_NORMAL 1 +#define DIFFICULTY_HARD 2 + +// Tipo de filtro +#define FILTER_NEAREST 0 +#define FILTER_LINEAL 1 + +#endif \ No newline at end of file diff --git a/source/director.cpp b/source/director.cpp new file mode 100644 index 0000000..dca9901 --- /dev/null +++ b/source/director.cpp @@ -0,0 +1,538 @@ +#include "const.h" +#include "utils.h" +#include "director.h" +#include +#include +#ifdef __MIPSEL__ +#include +#include +#endif + +// Constructor +Director::Director(std::string path) +{ + // Inicializa la ruta + setExecutablePath(path); + + // Establece la lista de ficheros + setFileList(); + + // Si falta algún fichero no inicies el programa + Uint8 section = PROG_SECTION_LOGO; + if (!checkFileList()) + section = PROG_SECTION_QUIT; + + // Inicializa el objeto de idioma + mLang = new Lang(mFileList); + + // Crea el puntero a la estructura y carga el fichero de configuración + mOptions = new options_t; + if (!loadConfigFile()) + { + mOptions->fullScreenMode = 0; + mOptions->windowSize = 3; + mOptions->language = en_UK; + mOptions->difficulty = DIFFICULTY_NORMAL; + mOptions->input[0].deviceType = INPUT_USE_KEYBOARD; + mOptions->input[1].deviceType = INPUT_USE_GAMECONTROLLER; + mOptions->filter = FILTER_NEAREST; + mOptions->vSync = true; + } + + // Crea los objetos + mInput = new Input(mFileList[53]); + + // Inicializa SDL + initSDL(); + + // Inicializa JailAudio + initJailAudio(); + + // Aplica las opciones + SDL_SetWindowFullscreen(mWindow, mOptions->fullScreenMode); + SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mOptions->windowSize, SCREEN_HEIGHT * mOptions->windowSize); + mLang->setLang(mOptions->language); + +#ifdef __MIPSEL__ + DIR *dir = opendir("/media/data/local/home/.coffee_crisis"); + if (dir) + { + closedir(dir); + } + else if (ENOENT == errno) + { + int status = mkdir("/media/data/local/home/.coffee_crisis", 755); + } +#endif + + // Inicializa el resto de variables + init(section); +} + +Director::~Director() +{ + saveConfigFile(); + + delete mInput; + mInput = nullptr; + + delete mLang; + mLang = nullptr; + + delete mOptions; + mOptions = nullptr; + + SDL_DestroyRenderer(mRenderer); + SDL_DestroyWindow(mWindow); + mRenderer = nullptr; + mWindow = nullptr; + + SDL_Quit(); +} + +// Inicia las variables necesarias para arrancar el programa +void Director::init(Uint8 name) +{ + // Sección + mSection.name = name; + mSection.subsection = 0; + + // Textos + mLang->setLang(mOptions->language); + + // Controles + mInput->bindKey(INPUT_UP, SDL_SCANCODE_UP); + mInput->bindKey(INPUT_DOWN, SDL_SCANCODE_DOWN); + mInput->bindKey(INPUT_LEFT, SDL_SCANCODE_LEFT); + mInput->bindKey(INPUT_RIGHT, SDL_SCANCODE_RIGHT); + mInput->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN); + mInput->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE); +#ifdef __MIPSEL__ + mInput->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_LSHIFT); + mInput->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_SPACE); + mInput->bindKey(INPUT_BUTTON_3, SDL_SCANCODE_LCTRL); +#else + mInput->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_Q); + mInput->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_W); + mInput->bindKey(INPUT_BUTTON_3, SDL_SCANCODE_E); +#endif + mInput->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE); // PAUSE + mInput->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE); // ESCAPE + + mInput->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP); + mInput->bindGameControllerButton(INPUT_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN); + mInput->bindGameControllerButton(INPUT_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT); + mInput->bindGameControllerButton(INPUT_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); + mInput->bindGameControllerButton(INPUT_ACCEPT, SDL_CONTROLLER_BUTTON_B); + mInput->bindGameControllerButton(INPUT_CANCEL, SDL_CONTROLLER_BUTTON_A); + mInput->bindGameControllerButton(INPUT_BUTTON_1, SDL_CONTROLLER_BUTTON_X); + mInput->bindGameControllerButton(INPUT_BUTTON_2, SDL_CONTROLLER_BUTTON_Y); + mInput->bindGameControllerButton(INPUT_BUTTON_3, SDL_CONTROLLER_BUTTON_B); + mInput->bindGameControllerButton(INPUT_BUTTON_PAUSE, SDL_CONTROLLER_BUTTON_GUIDE); // PAUSE + mInput->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE); // ESCAPE +} + +// Inicializa JailAudio +void Director::initJailAudio() +{ + JA_Init(48000, AUDIO_S16, 2); +} + +// Arranca SDL y crea la ventana +bool Director::initSDL() +{ + // Indicador de éxito + bool success = true; + + // Inicializa SDL + //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_AUDIO) < 0) + if (SDL_Init(SDL_INIT_EVERYTHING) < 0) + { + printf("SDL could not initialize!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + else + { + // Inicia el generador de numeros aleatorios + std::srand(static_cast(SDL_GetTicks())); + + // Establece el filtro de la textura a nearest + if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(mOptions->filter).c_str())) + { + printf("Warning: Nearest texture filtering not enabled!\n"); + } + + // Crea la ventana + mWindow = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI); + if (mWindow == NULL) + { + printf("Window could not be created!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + else + { + // Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones + if (mOptions->vSync) + mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); + else + mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED); + + if (mRenderer == NULL) + { + printf("Renderer could not be created!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + else + { + // Inicializa el color de renderizado + SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); + + // Establece el tamaño del buffer de renderizado + SDL_RenderSetLogicalSize(mRenderer, SCREEN_WIDTH, SCREEN_HEIGHT); + + // Establece el modo de mezcla + SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND); + } + } + } + + printf("\n"); + return success; +} + +// Crea el indice de ficheros +void Director::setFileList() +{ + // Inicializa el vector + for (int i = 0; i < MAX_FILE_LIST; i++) + mFileList[i] = ""; + + // Ficheros binarios +#ifdef __MIPSEL__ + mFileList[0] = "/media/data/local/home/.coffee_crisis/score.bin"; + mFileList[1] = "/media/data/local/home/.coffee_crisis/demo.bin"; + mFileList[2] = "/media/data/local/home/.coffee_crisis/config.bin"; +#else + mFileList[0] = mExecutablePath + "/" + "../data/score.bin"; + mFileList[1] = mExecutablePath + "/" + "../data/demo.bin"; + mFileList[2] = mExecutablePath + "/" + "../data/config.bin"; +#endif + + // Musicas + mFileList[3] = mExecutablePath + "/" + "../media/music/intro.ogg"; + mFileList[4] = mExecutablePath + "/" + "../media/music/playing.ogg"; + mFileList[5] = mExecutablePath + "/" + "../media/music/title.ogg"; + + // Sonidos + mFileList[6] = mExecutablePath + "/" + "../media/sound/balloon.wav"; + mFileList[7] = mExecutablePath + "/" + "../media/sound/bubble1.wav"; + mFileList[8] = mExecutablePath + "/" + "../media/sound/bubble2.wav"; + mFileList[9] = mExecutablePath + "/" + "../media/sound/bubble3.wav"; + mFileList[10] = mExecutablePath + "/" + "../media/sound/bubble4.wav"; + mFileList[11] = mExecutablePath + "/" + "../media/sound/bullet.wav"; + mFileList[12] = mExecutablePath + "/" + "../media/sound/coffeeout.wav"; + mFileList[13] = mExecutablePath + "/" + "../media/sound/hiscore.wav"; + mFileList[14] = mExecutablePath + "/" + "../media/sound/itemdrop.wav"; + mFileList[15] = mExecutablePath + "/" + "../media/sound/itempickup.wav"; + mFileList[16] = mExecutablePath + "/" + "../media/sound/menu_cancel.wav"; + mFileList[17] = mExecutablePath + "/" + "../media/sound/menu_move.wav"; + mFileList[18] = mExecutablePath + "/" + "../media/sound/menu_select.wav"; + mFileList[19] = mExecutablePath + "/" + "../media/sound/player_collision.wav"; + mFileList[20] = mExecutablePath + "/" + "../media/sound/stage_change.wav"; + mFileList[21] = mExecutablePath + "/" + "../media/sound/title.wav"; + mFileList[22] = mExecutablePath + "/" + "../media/sound/clock.wav"; + mFileList[23] = mExecutablePath + "/" + "../media/sound/powerball.wav"; + + // Texturas + mFileList[24] = mExecutablePath + "/" + "../media/gfx/balloon.png"; + mFileList[25] = mExecutablePath + "/" + "../media/gfx/bullet.png"; + mFileList[31] = mExecutablePath + "/" + "../media/gfx/game_bg.png"; + mFileList[32] = mExecutablePath + "/" + "../media/gfx/game_text.png"; + mFileList[33] = mExecutablePath + "/" + "../media/gfx/intro.png"; + mFileList[34] = mExecutablePath + "/" + "../media/gfx/items.png"; + mFileList[35] = mExecutablePath + "/" + "../media/gfx/logo.png"; + mFileList[37] = mExecutablePath + "/" + "../media/gfx/player1_body.png"; + mFileList[38] = mExecutablePath + "/" + "../media/gfx/player1_death.png"; + mFileList[39] = mExecutablePath + "/" + "../media/gfx/player1_legs.png"; + mFileList[40] = mExecutablePath + "/" + "../media/gfx/title.png"; + mFileList[41] = mExecutablePath + "/" + "../media/gfx/player1_head.png"; + mFileList[42] = mExecutablePath + "/" + "../media/gfx/player2_body.png"; + mFileList[43] = mExecutablePath + "/" + "../media/gfx/player2_death.png"; + mFileList[44] = mExecutablePath + "/" + "../media/gfx/player2_legs.png"; + mFileList[45] = mExecutablePath + "/" + "../media/gfx/player2_head.png"; + + // Fuentes + mFileList[27] = mExecutablePath + "/" + "../media/font/8bithud.png"; + mFileList[46] = mExecutablePath + "/" + "../media/font/8bithud.txt"; + mFileList[28] = mExecutablePath + "/" + "../media/font/nokia.png"; + mFileList[54] = mExecutablePath + "/" + "../media/font/nokia_big2.png"; + mFileList[52] = mExecutablePath + "/" + "../media/font/nokia.txt"; + mFileList[56] = mExecutablePath + "/" + "../media/font/nokia2.png"; + mFileList[57] = mExecutablePath + "/" + "../media/font/nokia2.txt"; + mFileList[55] = mExecutablePath + "/" + "../media/font/nokia_big2.txt"; + mFileList[29] = mExecutablePath + "/" + "../media/font/smb2_big.png"; + mFileList[47] = mExecutablePath + "/" + "../media/font/smb2_big.txt"; + mFileList[30] = mExecutablePath + "/" + "../media/font/smb2.png"; + mFileList[48] = mExecutablePath + "/" + "../media/font/smb2.txt"; + + // Textos + mFileList[49] = mExecutablePath + "/" + "../media/lang/es_ES.txt"; + mFileList[50] = mExecutablePath + "/" + "../media/lang/en_UK.txt"; + mFileList[51] = mExecutablePath + "/" + "../media/lang/ba_BA.txt"; + + // DATA + mFileList[53] = mExecutablePath + "/" + "../data/gamecontrollerdb.txt"; +} + +// Comprueba los ficheros del vector de ficheros que coinciden con una ruta dada +bool Director::checkFolder(std::string name, std::string path) +{ + bool success = true; + std::string p; + std::string filename; + SDL_RWops *file; + + // Comprueba los ficheros de la carpeta + printf("\n>> %s FILES\n", name.c_str()); + for (int i = 3; i < MAX_FILE_LIST; i++) + { + if (mFileList[i].find(path.c_str()) != std::string::npos) + { + p = mFileList[i].c_str(); + filename = p.substr(p.find_last_of("\\/") + 1); + file = SDL_RWFromFile(p.c_str(), "r+b"); + if (file != NULL) + { + printf("Checking file %-20s [OK]\n", filename.c_str()); + } + else + { + printf("Checking file %-20s [ERROR]\n", filename.c_str()); + success = false; + break; + } + SDL_RWclose(file); + } + } + return success; +} + +// Comprueba que todos los ficheros existen +bool Director::checkFileList() +{ + bool success = true; + printf("Checking files...\n"); + + if (success) + success &= checkFolder("MUSIC", "/media/music/"); + + if (success) + success &= checkFolder("SOUND", "/media/sound/"); + + if (success) + success &= checkFolder("BITMAP", "/media/gfx/"); + + if (success) + success &= checkFolder("FONT", "/media/font/"); + + if (success) + success &= checkFolder("LANG", "/media/lang/"); + + // Resultado + if (success) + printf("\n** All files OK.\n\n"); + else + printf("\n** A file is missing. Exiting.\n\n"); + + return success; +} + +// Carga el fichero de configuración +bool Director::loadConfigFile() +{ + // Pone unos valores por defecto + mOptions->fullScreenMode = 0; + mOptions->windowSize = 3; + mOptions->language = en_UK; + mOptions->difficulty = DIFFICULTY_NORMAL; + mOptions->input[0].deviceType = INPUT_USE_KEYBOARD; + mOptions->input[1].deviceType = INPUT_USE_GAMECONTROLLER; + mOptions->filter = FILTER_NEAREST; + mOptions->vSync = true; + + // Indicador de éxito en la carga + bool success = true; + + const std::string p = mFileList[2]; + std::string filename = p.substr(p.find_last_of("\\/") + 1); + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b"); + + // El fichero no existe + if (file == NULL) + { + printf("Warning: Unable to open %s file\n", filename.c_str()); + + // Crea el fichero para escritura + file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + printf("New file (%s) created!\n", filename.c_str()); + + // Escribe los datos + SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1); + SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1); + SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1); + SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1); + SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1); + SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1); + SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1); + SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1); + + // Cierra el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to create file %s\n", filename.c_str()); + success = false; + } + } + // El fichero existe + else + { + // Carga los datos + printf("Reading file %s\n", filename.c_str()); + SDL_RWread(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1); + SDL_RWread(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1); + SDL_RWread(file, &mOptions->language, sizeof(mOptions->language), 1); + SDL_RWread(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1); + SDL_RWread(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1); + SDL_RWread(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1); + SDL_RWread(file, &mOptions->filter, sizeof(mOptions->filter), 1); + SDL_RWread(file, &mOptions->vSync, sizeof(mOptions->vSync), 1); + + // Normaliza los valores + if (!((mOptions->fullScreenMode == 0) || + (mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN) || + (mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN_DESKTOP))) + mOptions->fullScreenMode = 0; + if ((mOptions->windowSize < 1) || (mOptions->windowSize > 4)) + mOptions->windowSize = 3; + if ((mOptions->language < 0) || (mOptions->language > MAX_LANGUAGES)) + mOptions->language = en_UK; + + // Cierra el fichero + SDL_RWclose(file); + } + + return success; +} + +// Guarda el fichero de configuración +bool Director::saveConfigFile() +{ + bool success = true; + const std::string p = mFileList[2]; + std::string filename = p.substr(p.find_last_of("\\/") + 1); + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + // Guarda los datos + SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1); + SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1); + SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1); + SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1); + SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1); + SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1); + SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1); + SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1); + + printf("Writing file %s\n", filename.c_str()); + + // Cierra el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError()); + } + return success; +} + +// Establece el valor de la variable +void Director::setExecutablePath(std::string path) +{ + mExecutablePath = path.substr(0, path.find_last_of("\\/")); +} + +// Obtiene el valor de la variable +Uint8 Director::getSubsection() +{ + return mSection.subsection; +} + +// Obtiene el valor de la variable +Uint8 Director::getSection() +{ + return mSection.name; +} + +// Establece el valor de la variable +void Director::setSection(section_t section) +{ + mSection = section; +} + +void Director::runLogo() +{ + mLogo = new Logo(mRenderer, mFileList); + setSection(mLogo->run()); + delete mLogo; +} + +void Director::runIntro() +{ + mIntro = new Intro(mRenderer, mFileList, mLang); + setSection(mIntro->run()); + delete mIntro; +} + +void Director::runTitle() +{ + mTitle = new Title(mWindow, mRenderer, mInput, mFileList, mOptions, mLang); + setSection(mTitle->run(mSection.subsection)); + delete mTitle; +} + +void Director::runGame() +{ + if (mSection.subsection == GAME_SECTION_PLAY_1P) + mGame = new Game(1, mRenderer, mFileList, mLang, mInput, false, mOptions); + if (mSection.subsection == GAME_SECTION_PLAY_2P) + mGame = new Game(2, mRenderer, mFileList, mLang, mInput, false, mOptions); + setSection(mGame->run()); + delete mGame; +} + +void Director::run() +{ + // Bucle principal + while (!(getSection() == PROG_SECTION_QUIT)) + { + switch (getSection()) + { + case PROG_SECTION_LOGO: + runLogo(); + break; + case PROG_SECTION_INTRO: + runIntro(); + break; + case PROG_SECTION_TITLE: + runTitle(); + break; + case PROG_SECTION_GAME: + runGame(); + break; + } + } +} \ No newline at end of file diff --git a/source/director.h b/source/director.h new file mode 100644 index 0000000..0d23e60 --- /dev/null +++ b/source/director.h @@ -0,0 +1,109 @@ +#pragma once +#include "ifdefs.h" +#include "sprite.h" +#include "movingsprite.h" +#include "smartsprite.h" +#include "player.h" +#include "balloon.h" +#include "bullet.h" +#include "coffeedrop.h" +#include "item.h" +#include "text.h" +#include "writer.h" +#include "menu.h" +#include "const.h" +#include "jail_audio.h" +#include "utils.h" +#include "logo.h" +#include "intro.h" +#include "title.h" +#include "game.h" +#include "input.h" +#include "fade.h" +//#include + +#ifndef DIRECTOR_H +#define DIRECTOR_H + +#define MAX_FILE_LIST 100 + +// Director +class Director +{ +private: + SDL_Window *mWindow; // La ventana donde dibujamos + SDL_Renderer *mRenderer; // El renderizador de la ventana + + Logo *mLogo; // Objeto para la sección del logo + Intro *mIntro; // Objeto para la sección de la intro + Title *mTitle; // Objeto para la sección del titulo y el menu de opciones + Game *mGame; // Objeto para la sección del juego + Input *mInput; // Objeto Input para gestionar las entradas + Lang *mLang; // Objeto para gestionar los textos en diferentes idiomas + + std::string mFileList[MAX_FILE_LIST]; // Vector con las rutas a los ficheros de recursos + struct options_t *mOptions; // Variable con todas las opciones del programa + + std::string mExecutablePath; // Path del ejecutable + section_t mSection; // Sección y subsección actual del programa; + + // Inicializa jail_audio + void initJailAudio(); + + // Arranca SDL y crea la ventana + bool initSDL(); + + // Crea el indice de ficheros + void setFileList(); + + // Comprueba que todos los ficheros existen + bool checkFileList(); + + // Carga el fichero de configuración + bool loadConfigFile(); + + // Guarda el fichero de configuración + bool saveConfigFile(); + + // Establece el valor de la variable + void setExecutablePath(std::string path); + + // Obtiene el valor de la variable + Uint8 getSubsection(); + + // Obtiene el valor de la variable + Uint8 getSection(); + + // Establece el valor de la variable + void setSection(section_t section); + + // Ejecuta la seccion de juego con el logo + void runLogo(); + + // Ejecuta la seccion de juego de la introducción + void runIntro(); + + // Ejecuta la seccion de juego con el titulo y los menus + void runTitle(); + + // Ejecuta la seccion de juego donde se juega + void runGame(); + + // Comprueba los ficheros del vector de ficheros que coinciden con una ruta dada + bool checkFolder(std::string name, std::string path); + +public: + // Constructor + Director(std::string path); + + // Destructor + ~Director(); + + // Inicia las variables necesarias para arrancar el programa + void init(Uint8 name); + + // Bucle principal + void run(); +}; + +#endif diff --git a/source/fade.cpp b/source/fade.cpp new file mode 100644 index 0000000..17a96de --- /dev/null +++ b/source/fade.cpp @@ -0,0 +1,172 @@ +#include "fade.h" +#include "const.h" + +// Constructor +Fade::Fade(SDL_Renderer *renderer) +{ + mRenderer = renderer; + + mBackbuffer = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT); + if (mBackbuffer == NULL) + printf("Backbuffer could not be created!\nSDL Error: %s\n", SDL_GetError()); +} + +// Destructor +Fade::~Fade() +{ + SDL_DestroyTexture(mBackbuffer); + mBackbuffer = nullptr; +} + +// Inicializa las variables +void Fade::init(Uint8 r, Uint8 g, Uint8 b) +{ + mFadeType = FADE_CENTER; + mEnabled = false; + mFinished = false; + mCounter = 0; + //mR = 0x27; + //mG = 0x27; + //mB = 0x36; + mR = r; + mG = g; + mB = b; +} + +// Pinta una transición en pantalla +void Fade::render() +{ + if (mEnabled && !mFinished) + { + switch (mFadeType) + { + case FADE_FULLSCREEN: + mRect1 = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + + for (int i = 0; i < 256; i += 4) + { + // Dibujamos sobre el renderizador + SDL_SetRenderTarget(mRenderer, NULL); + + // Copia el backbuffer con la imagen que había al renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, i); + SDL_RenderFillRect(mRenderer, &mRect1); + + // Vuelca el renderizador en pantalla + SDL_RenderPresent(mRenderer); + } + + // Deja todos los buffers del mismo color + SDL_SetRenderTarget(mRenderer, mBackbuffer); + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255); + SDL_RenderClear(mRenderer); + + SDL_SetRenderTarget(mRenderer, NULL); + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255); + SDL_RenderClear(mRenderer); + break; + + case FADE_CENTER: + mRect1 = {0, 0, SCREEN_WIDTH, 0}; + mRect2 = {0, 0, SCREEN_WIDTH, 0}; + + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 64); + + for (int i = 0; i < mCounter; i++) + { + mRect1.h = mRect2.h = i * 4; + mRect2.y = SCREEN_HEIGHT - (i * 4); + + SDL_RenderFillRect(mRenderer, &mRect1); + SDL_RenderFillRect(mRenderer, &mRect2); + } + + if ((mCounter * 4) > SCREEN_HEIGHT) + mFinished = true; + break; + + case FADE_RANDOM_SQUARE: + mRect1 = {0, 0, 32, 32}; + + for (Uint16 i = 0; i < 50; i++) + { + // Crea un color al azar + mR = 255 * (rand() % 2); + mG = 255 * (rand() % 2); + mB = 255 * (rand() % 2); + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 64); + + // Dibujamos sobre el backbuffer + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + mRect1.x = rand() % (SCREEN_WIDTH - mRect1.w); + mRect1.y = rand() % (SCREEN_HEIGHT - mRect1.h); + SDL_RenderFillRect(mRenderer, &mRect1); + + // Volvemos a usar el renderizador de forma normal + SDL_SetRenderTarget(mRenderer, NULL); + + // Copiamos el backbuffer al renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Volcamos el renderizador en pantalla + SDL_RenderPresent(mRenderer); + SDL_Delay(100); + } + break; + + default: + break; + } + } + + if (mFinished) + { + SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255); + SDL_RenderClear(mRenderer); + } +} + +// Actualiza las variables internas +void Fade::update() +{ + if (mEnabled) + mCounter++; +} + +// Activa el fade +void Fade::activateFade() +{ + mEnabled = true; + mFinished = false; + mCounter = 0; +} + +// Comprueba si está activo +bool Fade::isEnabled() +{ + return mEnabled; +} + +// Comprueba si ha terminado la transicion +bool Fade::hasEnded() +{ + if (mFinished) + { + //mEnabled = false; + //mFinished = false; + return true; + } + else + { + return false; + } +} + +// Establece el tipo de fade +void Fade::setFadeType(Uint8 fadeType) +{ + mFadeType = fadeType; +} \ No newline at end of file diff --git a/source/fade.h b/source/fade.h new file mode 100644 index 0000000..b5612ad --- /dev/null +++ b/source/fade.h @@ -0,0 +1,55 @@ +#pragma once +#include "ifdefs.h" +#include "ltexture.h" + +#ifndef FADE_H +#define FADE_H + +#define FADE_FULLSCREEN 0 +#define FADE_CENTER 1 +#define FADE_RANDOM_SQUARE 2 + +// Fade +class Fade +{ +private: + SDL_Renderer *mRenderer; // El renderizador de la ventana + SDL_Texture *mBackbuffer; // Textura para usar como backbuffer + Uint8 mFadeType; // Tipo de fade a realizar + Uint16 mCounter; // Contador interno + bool mEnabled; // Indica si el fade está activo + bool mFinished; // Indica si ha terminado la transición + Uint8 mR, mG, mB; // Colores para el fade + SDL_Rect mRect1; // Rectangulo usado para crear los efectos de transición + SDL_Rect mRect2; // Rectangulo usado para crear los efectos de transición + +public: + // Constructor + Fade(SDL_Renderer *renderer); + + // Destructor + ~Fade(); + + // Inicializa las variables + void init(Uint8 r, Uint8 g, Uint8 b); + + // Pinta una transición en pantalla + void render(); + + // Actualiza las variables internas + void update(); + + // Activa el fade + void activateFade(); + + // Comprueba si ha terminado la transicion + bool hasEnded(); + + // Comprueba si está activo + bool isEnabled(); + + // Establece el tipo de fade + void setFadeType(Uint8 fadeType); +}; + +#endif \ No newline at end of file diff --git a/source/game.cpp b/source/game.cpp new file mode 100644 index 0000000..e35e889 --- /dev/null +++ b/source/game.cpp @@ -0,0 +1,3483 @@ +#include "game.h" +#ifdef __MIPSEL__ +#include +#include +#endif + +// Constructor +Game::Game(int numPlayers, SDL_Renderer *renderer, std::string *filelist, Lang *lang, Input *input, bool demo, options_t *options) +{ + // Copia los punteros + mRenderer = renderer; + mFileList = filelist; + mLang = lang; + mInput = input; + mOptions = options; + mOnePlayerControl = mOptions->input[0].deviceType; + + // Pasa variables + mDemo.enabled = demo; + mNumPlayers = numPlayers; + if (mNumPlayers == 1) + mOptions->input[0].deviceType = INPUT_USE_ANY; + mDifficulty = mOptions->difficulty; + + // Crea los objetos + for (int i = 0; i < mNumPlayers; i++) + mPlayer[i] = new Player(); + for (int i = 0; i < MAX_BALLOONS; i++) + mBalloon[i] = new Balloon(); + for (int i = 0; i < MAX_BULLETS; i++) + mBullet[i] = new Bullet(); + for (int i = 0; i < MAX_ITEMS; i++) + mItem[i] = new Item(); + for (int i = 0; i < MAX_SMART_SPRITES; i++) + mSmartSprite[i] = new SmartSprite(); + + mTextureBalloon = new LTexture(); + mTextureBullet = new LTexture(); + mTextureGameBG = new LTexture(); + mTextureGameText = new LTexture(); + mTextureItems = new LTexture(); + mTexturePlayer1Head = new LTexture(); + mTexturePlayer1Body = new LTexture(); + mTexturePlayer1Death = new LTexture(); + mTexturePlayer1Legs = new LTexture(); + mTexturePlayer2Head = new LTexture(); + mTexturePlayer2Body = new LTexture(); + mTexturePlayer2Death = new LTexture(); + mTexturePlayer2Legs = new LTexture(); + mTextureText = new LTexture(); + mTextureTextScoreBoard = new LTexture(); + mTextureTextBig = new LTexture(); + mTextureTextNokia2 = new LTexture(); + mTextureTextNokiaBig2 = new LTexture(); + + mText = new Text(mFileList[48], mTextureText, mRenderer); + mTextScoreBoard = new Text(mFileList[46], mTextureTextScoreBoard, mRenderer); + mTextBig = new Text(mFileList[47], mTextureTextBig, mRenderer); + mTextNokia2 = new Text(mFileList[57], mTextureTextNokia2, mRenderer); + mTextNokiaBig2 = new Text(mFileList[55], mTextureTextNokiaBig2, mRenderer); + + mMenuGameOver = new Menu(mRenderer, mText, mInput, mFileList); + mMenuPause = new Menu(mRenderer, mText, mInput, mFileList); + + mFade = new Fade(mRenderer); + mEventHandler = new SDL_Event(); + + mClouds1a = new MovingSprite(); + mClouds1b = new MovingSprite(); + mClouds2a = new MovingSprite(); + mClouds2b = new MovingSprite(); + m1000Bitmap = new SmartSprite(); + m2500Bitmap = new SmartSprite(); + m5000Bitmap = new SmartSprite(); + mSpriteBackground = new Sprite(); + mSpriteGetReady = new Sprite(); + mSpriteGradient = new Sprite(); + mSpriteGrass = new Sprite(); + mSpritePowerMeter = new Sprite(); + mSpriteScoreBoard = new Sprite(); + +#ifdef __MIPSEL__ + DIR *dir = opendir("/media/data/local/home/.coffee_crisis"); + if (dir) + { + closedir(dir); + } + else if (ENOENT == errno) + { + int status = mkdir("/media/data/local/home/.coffee_crisis", 755); + } +#endif +} + +Game::~Game() +{ + saveScoreFile(); + saveDemoFile(); + + mOptions->input[0].deviceType = mOnePlayerControl; + + mRenderer = nullptr; + mFileList = nullptr; + mLang = nullptr; + mInput = nullptr; + + for (int i = 0; i < mNumPlayers; i++) + { + delete mPlayer[i]; + mPlayer[i] = nullptr; + } + for (int i = 0; i < MAX_BALLOONS; i++) + { + delete mBalloon[i]; + mBalloon[i] = nullptr; + } + for (int i = 0; i < MAX_BULLETS; i++) + { + delete mBullet[i]; + mBullet[i] = nullptr; + } + for (int i = 0; i < MAX_ITEMS; i++) + { + delete mItem[i]; + mItem[i] = nullptr; + } + for (int i = 0; i < MAX_SMART_SPRITES; i++) + { + delete mSmartSprite[i]; + mSmartSprite[i] = nullptr; + } + + mTextureBalloon->unload(); + delete mTextureBalloon; + mTextureBalloon = nullptr; + + mTextureBullet->unload(); + delete mTextureBullet; + mTextureBullet = nullptr; + + mTextureGameBG->unload(); + delete mTextureGameBG; + mTextureGameBG = nullptr; + + mTextureGameText->unload(); + delete mTextureGameText; + mTextureGameText = nullptr; + + mTextureItems->unload(); + delete mTextureItems; + mTextureItems = nullptr; + + mTexturePlayer1Head->unload(); + delete mTexturePlayer1Head; + mTexturePlayer1Head = nullptr; + + mTexturePlayer1Body->unload(); + delete mTexturePlayer1Body; + mTexturePlayer1Body = nullptr; + + mTexturePlayer1Death->unload(); + delete mTexturePlayer1Death; + mTexturePlayer1Death = nullptr; + + mTexturePlayer1Legs->unload(); + delete mTexturePlayer1Legs; + mTexturePlayer1Legs = nullptr; + + mTexturePlayer2Head->unload(); + delete mTexturePlayer2Head; + mTexturePlayer2Head = nullptr; + + mTexturePlayer2Body->unload(); + delete mTexturePlayer2Body; + mTexturePlayer2Body = nullptr; + + mTexturePlayer2Death->unload(); + delete mTexturePlayer2Death; + mTexturePlayer2Death = nullptr; + + mTexturePlayer2Legs->unload(); + delete mTexturePlayer2Legs; + mTexturePlayer2Legs = nullptr; + + mTextureText->unload(); + delete mTextureText; + mTextureText = nullptr; + + mTextureTextScoreBoard->unload(); + delete mTextureTextScoreBoard; + mTextureTextScoreBoard = nullptr; + + mTextureTextBig->unload(); + delete mTextureTextBig; + mTextureTextBig = nullptr; + + mTextureTextNokia2->unload(); + delete mTextureTextNokia2; + mTextureTextNokia2 = nullptr; + + mTextureTextNokiaBig2->unload(); + delete mTextureTextNokiaBig2; + mTextureTextNokiaBig2 = nullptr; + + delete mText; + mText = nullptr; + + delete mTextBig; + mTextBig = nullptr; + + delete mTextScoreBoard; + mTextScoreBoard = nullptr; + + delete mTextNokia2; + mTextNokia2 = nullptr; + + delete mTextNokiaBig2; + mTextNokiaBig2 = nullptr; + + delete mMenuGameOver; + mMenuGameOver = nullptr; + + delete mMenuPause; + mMenuPause = nullptr; + + delete mFade; + mFade = nullptr; + + delete mEventHandler; + mEventHandler = nullptr; + + delete mClouds1a; + mClouds1a = nullptr; + + delete mClouds1b; + mClouds1b = nullptr; + + delete mClouds2a; + mClouds2a = nullptr; + + delete mClouds2b; + mClouds2b = nullptr; + + delete m1000Bitmap; + m1000Bitmap = nullptr; + + delete m2500Bitmap; + m2500Bitmap = nullptr; + + delete m5000Bitmap; + m5000Bitmap = nullptr; + + delete mSpriteBackground; + mSpriteBackground = nullptr; + + delete mSpriteGetReady; + mSpriteGetReady = nullptr; + + delete mSpriteGradient; + mSpriteGradient = nullptr; + + delete mSpriteGrass; + mSpriteGrass = nullptr; + + delete mSpritePowerMeter; + mSpritePowerMeter = nullptr; + + delete mSpriteScoreBoard; + mSpriteScoreBoard = nullptr; + + JA_DeleteSound(mSoundBalloon); + JA_DeleteSound(mSoundBullet); + JA_DeleteSound(mSoundPlayerCollision); + JA_DeleteSound(mSoundHiScore); + JA_DeleteSound(mSoundItemDrop); + JA_DeleteSound(mSoundItemPickup); + JA_DeleteSound(mSoundCoffeeOut); + JA_DeleteSound(mSoundStageChange); + JA_DeleteSound(mSoundBubble1); + JA_DeleteSound(mSoundBubble2); + JA_DeleteSound(mSoundBubble3); + JA_DeleteSound(mSoundBubble4); + JA_DeleteSound(mSoundClock); + JA_DeleteSound(mSoundPowerBall); + JA_DeleteSound(mSoundCollision); + + JA_DeleteMusic(mMusicPlaying); +} + +// Inicializa el vector con los valores del seno +void Game::initSin() +{ + // Vector con los valores del seno para 360 grados + for (int i = 0; i < 360; i++) + mSin[i] = SDL_sinf((float)i * 3.14f / 180.0f); +} + +// Inicializa las variables necesarias para la sección 'Game' +void Game::init() +{ + // Carga los recursos + loadMedia(); + + // Carga ficheros + loadScoreFile(); + loadDemoFile(); + + mTicks = 0; + mTicksSpeed = 15; + + // Inicializa las variables + switch (mDifficulty) + { + case DIFFICULTY_EASY: + mDefaultEnemySpeed = BALLOON_SPEED_1; + mDifficultyScoreMultiplier = 0.5f; + break; + + case DIFFICULTY_NORMAL: + mDefaultEnemySpeed = BALLOON_SPEED_1; + mDifficultyScoreMultiplier = 1.0f; + break; + + case DIFFICULTY_HARD: + mDefaultEnemySpeed = BALLOON_SPEED_5; + mDifficultyScoreMultiplier = 1.5f; + break; + + default: + break; + } + mGameCompleted = false; + mGameCompletedCounter = 0; + mSection.name = PROG_SECTION_GAME; + mSection.subsection = GAME_SECTION_PLAY_1P; + mMenaceCurrent = 0; + mMenaceThreshold = 0; + mHiScoreAchieved = false; + mCurrentStage = 0; + mStageBitmapCounter = STAGE_COUNTER; + mDeathCounter = DEATH_COUNTER; + mExplosionTime = false; + mRemainingExplosions = REMAINING_EXPLOSIONS; + mRemainingExplosionsCounter = REMAINING_EXPLOSIONS_COUNTER; + mTimeStopped = false; + mTimeStoppedCounter = 0; + mCounter = 0; + mBalloonsPopped = 0; + mLastEnemyDeploy = 0; + mEnemyDeployCounter = 0; + mEnemySpeed = mDefaultEnemySpeed; + mEffect.flash = false; + mEffect.shake = false; + mEffect.shakeCounter = SHAKE_COUNTER; + mHelper.needCoffee = false; + mHelper.needCoffeeMachine = false; + mHelper.needPowerBall = false; + mHelper.counter = HELP_COUNTER; + mHelper.itemPoints1Odds = ITEM_POINTS_1_DISK_ODDS; + mHelper.itemPoints2Odds = ITEM_POINTS_2_GAVINA_ODDS; + mHelper.itemPoints3Odds = ITEM_POINTS_3_PACMAR_ODDS; + mHelper.itemClockOdds = ITEM_CLOCK_ODDS; + mHelper.itemCoffeeOdds = ITEM_COFFEE_ODDS; + mHelper.itemCoffeeMachineOdds = ITEM_COFFEE_MACHINE_ODDS; + mPowerBallEnabled = false; + mPowerBallCounter = 0; + mCoffeeMachineEnabled = false; + mPostFade = 0; + + if (mDemo.enabled) + { + int num = rand() % 2; + if (num == 0) + { + mBalloonsPopped = 1000; + mCurrentStage = 3; + } + else + { + mBalloonsPopped = 1800; + mCurrentStage = 6; + } + } + + initSin(); + initPaths(); + initEnemyFormations(); + initEnemyPools(); + initGameStages(); + + // BORRAR + //mStage[mCurrentStage].currentPower = mStage[mCurrentStage].powerToComplete - 10; + + // Modo debug + mDebug.enabled = false; + mDebug.enemySet = 0; + mDebug.gradR = mDebug.gradG = mDebug.gradB = 0; + + // Modo demo + mDemo.recording = false; + mDemo.counter = 0; + + // Iniciualiza el objeto para el fundido + mFade->init(0x27, 0x27, 0x36); + + // Inicializa el objeto con el menu de pausa + mMenuPause->init("PAUSE", 0, 12 * BLOCK, MENU_BACKGROUND_SOLID); + mMenuPause->addItem(mLang->getText(46), 2); + mMenuPause->addItem(mLang->getText(47), 0); + mMenuPause->setDefaultActionWhenCancel(0); + mMenuPause->setBackgroundColor(0x29, 0x39, 0x41, 240); + mMenuPause->setSelectorColor(0xFF, 0x7A, 0x00, 255); + mMenuPause->setSelectorTextColor(0xFF, 0xFF, 0xFF); + mMenuPause->centerMenuOnX(SCREEN_CENTER_X); + mMenuPause->centerMenuElementsOnX(); + + // Inicializa el objeto con el menu de la pantalla de game over + mMenuGameOver->init("GAME OVER", 0, PLAY_AREA_CENTER_Y + BLOCK * 4, MENU_BACKGROUND_TRANSPARENT); + mMenuGameOver->addItem(mLang->getText(48), 2); + mMenuGameOver->addItem(mLang->getText(49)); + mMenuGameOver->setDefaultActionWhenCancel(1); + mMenuGameOver->setBackgroundColor(0, 0, 0, 255); + mMenuGameOver->setSelectorColor(0x54, 0x6e, 0x7a, 255); + mMenuGameOver->setSelectorColor(0x54, 0x6e, 0x7a, 0); + mMenuGameOver->setSelectorTextColor(0xFF, 0xFF, 0xFF); + mMenuGameOver->setSelectorTextColor(0xFF, 0xF1, 0x76); + mMenuGameOver->setSelectorTextColor(0xFF, 0x7A, 0x00); + mMenuGameOver->centerMenuOnX(SCREEN_CENTER_X); + mMenuGameOver->centerMenuElementsOnX(); + + // Sprites + mClouds1a->init(0, 0, 256, 52, -0.4f, 0.0f, 0.0f, 0.0f, mTextureGameBG, mRenderer); + mClouds1a->setSpriteClip(256, 0, 256, 52); + + mClouds1b->init(256, 0, 256, 52, -0.4f, 0.0f, 0.0f, 0.0f, mTextureGameBG, mRenderer); + mClouds1b->setSpriteClip(256, 0, 256, 52); + + mClouds2a->init(0, 52, 256, 32, -0.2f, 0.0f, 0.0f, 0.0f, mTextureGameBG, mRenderer); + mClouds2a->setSpriteClip(256, 52, 256, 32); + + mClouds2b->init(256, 52, 256, 32, -0.2f, 0.0f, 0.0f, 0.0f, mTextureGameBG, mRenderer); + mClouds2b->setSpriteClip(256, 52, 256, 32); + + mSpriteGrass->init(0, 85, SCREEN_WIDTH, 6, mTextureGameBG, mRenderer); + mSpriteGrass->setPosY(154); + + mSpriteScoreBoard->init(0, 160, SCREEN_WIDTH, 32, mTextureGameBG, mRenderer); + mSpriteScoreBoard->setSpriteClip(0, 160, 256, 32); + + mSpritePowerMeter->init(PLAY_AREA_CENTER_X - 20, 170, 40, 8, mTextureGameBG, mRenderer); + mSpritePowerMeter->setSpriteClip(256, 192 - 8, 40, 8); + + // Vector de jugadores + if (mNumPlayers == 1) + mPlayer[0]->init(PLAY_AREA_CENTER_X - 11, PLAY_AREA_BOTTOM - 24, mTexturePlayer1Legs, mTexturePlayer1Body, mTexturePlayer1Head, mTexturePlayer1Death, mRenderer); + if (mNumPlayers == 2) + { + mPlayer[0]->init((PLAY_AREA_CENTER_FIRST_QUARTER_X * ((0 * 2) + 1)) - 11, PLAY_AREA_BOTTOM - 24, mTexturePlayer1Legs, mTexturePlayer1Body, mTexturePlayer1Head, mTexturePlayer1Death, mRenderer); + mPlayer[1]->init((PLAY_AREA_CENTER_FIRST_QUARTER_X * ((1 * 2) + 1)) - 11, PLAY_AREA_BOTTOM - 24, mTexturePlayer2Legs, mTexturePlayer2Body, mTexturePlayer2Head, mTexturePlayer2Death, mRenderer); + } + + // Establece a cero todos los valores del vector de objetos globo + resetBalloons(); + + // Con los globos creados, calcula el nivel de amenaza + evaluateAndSetMenace(); + + // Establece a cero todos los valores del vector de objetos bala + resetBullets(); + + // Establece a cero todos los valores del vector de objetos item + resetItems(); + + // Establece a cero todos los valores del vector de objetos SmafrtSprite + resetSmartSprites(); + + // Inicializa el bitmap de GetReady! + mSpriteGetReady->init(0, PLAY_AREA_CENTER_Y - 10, 109, 20, mTextureGameText, mRenderer); + mSpriteGetReady->setSpriteClip(0, 0, 109, 20); + + // Inicializa el bitmap de 1000 puntos + m1000Bitmap->init(mTextureGameText, mRenderer); + m1000Bitmap->setPosX(0); + m1000Bitmap->setPosY(0); + m1000Bitmap->setWidth(26); + m1000Bitmap->setHeight(9); + m1000Bitmap->setVelX(0.0f); + m1000Bitmap->setVelY(-0.5f); + m1000Bitmap->setAccelX(0.0f); + m1000Bitmap->setAccelY(-0.1f); + m1000Bitmap->setSpriteClip(0, 20, 26, 9); + m1000Bitmap->setEnabled(false); + m1000Bitmap->setEnabledTimer(0); + m1000Bitmap->setDestX(0); + m1000Bitmap->setDestY(0); + + // Inicializa el bitmap de 2500 puntos + m2500Bitmap->init(mTextureGameText, mRenderer); + m2500Bitmap->setPosX(0); + m2500Bitmap->setPosY(0); + m2500Bitmap->setWidth(28); + m2500Bitmap->setHeight(9); + m2500Bitmap->setVelX(0.0f); + m2500Bitmap->setVelY(-0.5f); + m2500Bitmap->setAccelX(0.0f); + m2500Bitmap->setAccelY(-0.1f); + m2500Bitmap->setSpriteClip(26, 20, 28, 9); + m2500Bitmap->setEnabled(false); + m2500Bitmap->setEnabledTimer(0); + m2500Bitmap->setDestX(0); + m2500Bitmap->setDestY(0); + + // Inicializa el bitmap de 5000 puntos + m5000Bitmap->init(mTextureGameText, mRenderer); + m5000Bitmap->setPosX(0); + m5000Bitmap->setPosY(0); + m5000Bitmap->setWidth(28); + m5000Bitmap->setHeight(9); + m5000Bitmap->setVelX(0.0f); + m5000Bitmap->setVelY(-0.5f); + m5000Bitmap->setAccelX(0.0f); + m5000Bitmap->setAccelY(-0.1f); + m5000Bitmap->setSpriteClip(54, 20, 28, 9); + m5000Bitmap->setEnabled(false); + m5000Bitmap->setEnabledTimer(0); + m5000Bitmap->setDestX(0); + m5000Bitmap->setDestY(0); + + // Los fondos + mSpriteBackground->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTextureGameBG, mRenderer); + mSpriteGradient->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTextureGameBG, mRenderer); + mGradientRect[0] = {0, 192, SCREEN_WIDTH, SCREEN_HEIGHT}; + mGradientRect[1] = {256, 192, SCREEN_WIDTH, SCREEN_HEIGHT}; + mGradientRect[2] = {0, 384, SCREEN_WIDTH, SCREEN_HEIGHT}; + mGradientRect[3] = {256, 384, SCREEN_WIDTH, SCREEN_HEIGHT}; +} + +// Carga los recursos necesarios para la sección 'Game' +bool Game::loadMedia() +{ + bool success = true; + + // Texturas + success &= loadTextureFromFile(mTextureText, mFileList[30], mRenderer); + success &= loadTextureFromFile(mTextureTextScoreBoard, mFileList[27], mRenderer); + success &= loadTextureFromFile(mTextureTextBig, mFileList[29], mRenderer); + success &= loadTextureFromFile(mTextureTextNokia2, mFileList[56], mRenderer); + success &= loadTextureFromFile(mTextureTextNokiaBig2, mFileList[54], mRenderer); + + success &= loadTextureFromFile(mTexturePlayer1Legs, mFileList[39], mRenderer); + success &= loadTextureFromFile(mTexturePlayer1Head, mFileList[41], mRenderer); + success &= loadTextureFromFile(mTexturePlayer1Body, mFileList[37], mRenderer); + success &= loadTextureFromFile(mTexturePlayer1Death, mFileList[38], mRenderer); + + success &= loadTextureFromFile(mTexturePlayer2Legs, mFileList[44], mRenderer); + success &= loadTextureFromFile(mTexturePlayer2Head, mFileList[45], mRenderer); + success &= loadTextureFromFile(mTexturePlayer2Body, mFileList[42], mRenderer); + success &= loadTextureFromFile(mTexturePlayer2Death, mFileList[43], mRenderer); + + success &= loadTextureFromFile(mTextureBalloon, mFileList[24], mRenderer); + success &= loadTextureFromFile(mTextureBullet, mFileList[25], mRenderer); + success &= loadTextureFromFile(mTextureGameBG, mFileList[31], mRenderer); + success &= loadTextureFromFile(mTextureItems, mFileList[34], mRenderer); + success &= loadTextureFromFile(mTextureGameText, mFileList[32], mRenderer); + + // Sonidos + mSoundBalloon = JA_LoadSound(mFileList[6].c_str()); + mSoundBubble1 = JA_LoadSound(mFileList[7].c_str()); + mSoundBubble2 = JA_LoadSound(mFileList[8].c_str()); + mSoundBubble3 = JA_LoadSound(mFileList[9].c_str()); + mSoundBubble4 = JA_LoadSound(mFileList[10].c_str()); + mSoundBullet = JA_LoadSound(mFileList[11].c_str()); + mSoundClock = JA_LoadSound(mFileList[22].c_str()); + mSoundCoffeeOut = JA_LoadSound(mFileList[12].c_str()); + mSoundHiScore = JA_LoadSound(mFileList[13].c_str()); + mSoundItemDrop = JA_LoadSound(mFileList[14].c_str()); + mSoundItemPickup = JA_LoadSound(mFileList[15].c_str()); + mSoundPlayerCollision = JA_LoadSound(mFileList[19].c_str()); + mSoundPowerBall = JA_LoadSound(mFileList[23].c_str()); + mSoundStageChange = JA_LoadSound(mFileList[20].c_str()); + mSoundCollision = JA_LoadSound(mFileList[21].c_str()); + + // Musicas + mMusicPlaying = JA_LoadMusic(mFileList[4].c_str()); + + return success; +} + +// Carga el fichero de puntos +bool Game::loadScoreFile() +{ + // Indicador de éxito en la carga + bool success = true; + const std::string p = mFileList[0]; + const std::string filename = p.substr(p.find_last_of("\\/") + 1); + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b"); + + // El fichero no existe + if (file == NULL) + { + printf("Warning: Unable to open %s file\n", filename.c_str()); + + // Creamos el fichero para escritura + file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + printf("New file (%s) created!\n", filename.c_str()); + + // Inicializamos los datos + for (int i = 0; i < TOTAL_SCORE_DATA; ++i) + { + mScoreDataFile[i] = 0; + SDL_RWwrite(file, &mScoreDataFile[i], sizeof(Uint32), 1); + } + + // Cerramos el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to create file %s\n", filename.c_str()); + success = false; + } + } + // El fichero existe + else + { + // Cargamos los datos + printf("Reading file %s\n", filename.c_str()); + for (int i = 0; i < TOTAL_SCORE_DATA; ++i) + SDL_RWread(file, &mScoreDataFile[i], sizeof(Uint32), 1); + + // Cierra el fichero + SDL_RWclose(file); + } + + // Establece el valor de la máxima puntuación a partir del vector con los datos + if (mScoreDataFile[0] == 0) + mHiScore = 10000; + // Comprueba el checksum para ver si se ha modificado el fichero + else if (mScoreDataFile[0] % 43 == mScoreDataFile[1]) + mHiScore = mScoreDataFile[0]; + else + mHiScore = 10000; + + return success; +} + +// Carga el fichero de datos para la demo +bool Game::loadDemoFile() +{ + // Indicador de éxito en la carga + bool success = true; + const std::string p = mFileList[1]; + const std::string filename = p.substr(p.find_last_of("\\/") + 1); + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b"); + + // El fichero no existe + if (file == NULL) + { + printf("Warning: Unable to open %s file\n", filename.c_str()); + + // Creamos el fichero para escritura + file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + printf("New file (%s) created!\n", filename.c_str()); + + // Inicializamos los datos + for (int i = 0; i < TOTAL_DEMO_DATA; ++i) + { + mDemo.keys.left = 0; + mDemo.keys.right = 0; + mDemo.keys.noInput = 0; + mDemo.keys.fire = 0; + mDemo.keys.fireLeft = 0; + mDemo.keys.fireRight = 0; + mDemo.dataFile[i] = mDemo.keys; + SDL_RWwrite(file, &mDemo.dataFile[i], sizeof(demoKeys_t), 1); + } + + // Cerramos el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to create file %s\n", filename.c_str()); + success = false; + } + } + // El fichero existe + else + { + // Cargamos los datos + printf("Reading file %s\n", filename.c_str()); + for (int i = 0; i < TOTAL_DEMO_DATA; ++i) + SDL_RWread(file, &mDemo.dataFile[i], sizeof(demoKeys_t), 1); + + // Cierra el fichero + SDL_RWclose(file); + } + + return success; +} + +// Guarda el fichero de puntos +bool Game::saveScoreFile() +{ + bool success = true; + const std::string p = mFileList[0]; + const std::string filename = p.substr(p.find_last_of("\\/") + 1); + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + // Guardamos los datos + for (int i = 0; i < TOTAL_SCORE_DATA; ++i) + { + SDL_RWwrite(file, &mScoreDataFile[i], sizeof(Uint32), 1); + } + + printf("Writing file %s\n", filename.c_str()); + + // Cerramos el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError()); + } + return success; +} + +// Guarda el fichero de datos para la demo +bool Game::saveDemoFile() +{ + bool success = true; + const std::string p = mFileList[1]; + const std::string filename = p.substr(p.find_last_of("\\/") + 1); + if (mDemo.recording) + { + SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + // Guardamos los datos + for (int i = 0; i < TOTAL_DEMO_DATA; ++i) + { + SDL_RWwrite(file, &mDemo.dataFile[i], sizeof(demoKeys_t), 1); + } + + printf("Writing file %s\n", filename.c_str()); + + // Cerramos el fichero + SDL_RWclose(file); + } + else + { + printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError()); + } + } + return success; +} + +// Inicializa las formaciones enemigas +void Game::initEnemyFormations() +{ + const int y4 = (PLAY_AREA_TOP - BLOCK); + const int x4_0 = PLAY_AREA_LEFT; + const int x4_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_4; + + const int y3 = (PLAY_AREA_TOP - BLOCK); + const int x3_0 = PLAY_AREA_LEFT; + const int x3_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_3; + + const int y2 = (PLAY_AREA_TOP - BLOCK); + const int x2_0 = PLAY_AREA_LEFT; + const int x2_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_2; + + const int y1 = (PLAY_AREA_TOP - BLOCK); + const int x1_0 = PLAY_AREA_LEFT; + const int x1_50 = PLAY_AREA_CENTER_X - (BALLOON_WIDTH_1 / 2); + const int x1_100 = (PLAY_AREA_RIGHT)-BALLOON_WIDTH_1; + + // Inicializa a cero las variables + for (int i = 0; i < NUMBER_OF_ENEMY_FORMATIONS; i++) + { + mEnemyFormation[i].numberOfEnemies = 0; + for (int j = 0; j < MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION; j++) + { + mEnemyFormation[i].init[j].x = 0; + mEnemyFormation[i].init[j].y = 0; + mEnemyFormation[i].init[j].velX = 0; + mEnemyFormation[i].init[j].kind = 0; + mEnemyFormation[i].init[j].creationCounter = 0; + } + } + + const Uint16 creationTime = 300; + int incX = 0; + Uint8 incTime = 0; + Uint8 j = 0; + + // #00 - Dos enemigos BALLOON4 uno a cada extremo + j = 0; + mEnemyFormation[j].numberOfEnemies = 2; + incX = x4_100; + incTime = 0; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x4_0 + (i * incX); + mEnemyFormation[j].init[i].y = y4; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1); + mEnemyFormation[j].init[i].kind = BALLOON_4; + mEnemyFormation[j].init[i].creationCounter = creationTime + (incTime * i); + } + + // #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro + j = 1; + mEnemyFormation[j].numberOfEnemies = 2; + incX = PLAY_AREA_CENTER_X; + incTime = 0; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = PLAY_AREA_CENTER_FIRST_QUARTER_X - (BALLOON_WIDTH_4 / 2) + (i * incX); + mEnemyFormation[j].init[i].y = y4; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE * (((i % 2) * 2) - 1); + mEnemyFormation[j].init[i].kind = BALLOON_4; + mEnemyFormation[j].init[i].creationCounter = creationTime + (incTime * i); + } + + // #02 - Cuatro enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro + j = 2; + mEnemyFormation[j].numberOfEnemies = 4; + incX = BALLOON_WIDTH_2 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x2_0 + (i * incX); + mEnemyFormation[j].init[i].y = y2; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_2; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #03 - Cuatro enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro + j = 3; + mEnemyFormation[j].numberOfEnemies = 4; + incX = BALLOON_WIDTH_2 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x2_100 - (i * incX); + mEnemyFormation[j].init[i].y = y2; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_2; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha + j = 4; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_3 * 2; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda + j = 5; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_3 * 2; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_100 - (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha + j = 6; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_3 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda + j = 7; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_3 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_100 - (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha + j = 8; + mEnemyFormation[j].numberOfEnemies = 6; + incX = BALLOON_WIDTH_1 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x1_0 + (i * incX); + mEnemyFormation[j].init[i].y = 13; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_1; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda + j = 9; + mEnemyFormation[j].numberOfEnemies = 6; + incX = BALLOON_WIDTH_1 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x1_100 - (i * incX); + mEnemyFormation[j].init[i].y = 13; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_1; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #10 - Tres enemigos BALLOON4 seguidos desde la izquierda + j = 10; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_4 + 1; + incTime = 15; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x4_0 + (i * incX); + mEnemyFormation[j].init[i].y = y4; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_4; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #11 - Tres enemigos BALLOON4 seguidos desde la derecha + j = 11; + mEnemyFormation[j].numberOfEnemies = 3; + incX = BALLOON_WIDTH_4 + 1; + incTime = 15; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x4_100 - (i * incX); + mEnemyFormation[j].init[i].y = y4; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_4; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #12 - Seis enemigos BALLOON2 uno detras del otro. A la izquierda y hacia el centro + j = 12; + mEnemyFormation[j].numberOfEnemies = 6; + incX = BALLOON_WIDTH_2 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x2_0 + (i * incX); + mEnemyFormation[j].init[i].y = y2; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_2; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #13 - Seis enemigos BALLOON2 uno detras del otro. A la derecha y hacia el centro + j = 13; + mEnemyFormation[j].numberOfEnemies = 6; + incX = BALLOON_WIDTH_2 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x2_100 - (i * incX); + mEnemyFormation[j].init[i].y = y2; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_2; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados + j = 14; + mEnemyFormation[j].numberOfEnemies = 5; + incX = BALLOON_WIDTH_3 * 2; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados + j = 15; + mEnemyFormation[j].numberOfEnemies = 5; + incX = BALLOON_WIDTH_3 * 2; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_100 - (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos + j = 16; + mEnemyFormation[j].numberOfEnemies = 5; + incX = BALLOON_WIDTH_3 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos + j = 17; + mEnemyFormation[j].numberOfEnemies = 5; + incX = BALLOON_WIDTH_3 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x3_100 - (i * incX); + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_3; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos + j = 18; + mEnemyFormation[j].numberOfEnemies = 12; + incX = BALLOON_WIDTH_1 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x1_0 + (i * incX); + mEnemyFormation[j].init[i].y = y1; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].kind = BALLOON_1; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos + j = 19; + mEnemyFormation[j].numberOfEnemies = 12; + incX = BALLOON_WIDTH_1 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + mEnemyFormation[j].init[i].x = x1_100 - (i * incX); + mEnemyFormation[j].init[i].y = y1; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].kind = BALLOON_1; + mEnemyFormation[j].init[i].creationCounter = creationTime - (incTime * i); + } + + // #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simetricos + j = 20; + mEnemyFormation[j].numberOfEnemies = 4; + incX = BALLOON_WIDTH_4 + 1; + incTime = 0; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x4_0 + (i * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + } + else + { + mEnemyFormation[j].init[i].x = x4_100 - ((i - half) * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + } + mEnemyFormation[j].init[i].y = y4; + mEnemyFormation[j].init[i].kind = BALLOON_4; + mEnemyFormation[j].init[i].creationCounter = creationTime + (incTime * i); + } + + // #21 - Diez enemigos BALLOON2 uno detras del otro. Izquierda/derecha. Simetricos + j = 21; + mEnemyFormation[j].numberOfEnemies = 10; + incX = BALLOON_WIDTH_2 + 1; + incTime = 3; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x2_0 + (i * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i); + } + else + { + mEnemyFormation[j].init[i].x = x2_100 - ((i - half) * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half)); + } + mEnemyFormation[j].init[i].y = y2; + mEnemyFormation[j].init[i].kind = BALLOON_2; + } + + // #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simetricos + j = 22; + mEnemyFormation[j].numberOfEnemies = 10; + incX = BALLOON_WIDTH_3 * 2; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i); + } + else + { + mEnemyFormation[j].init[i].x = x3_100 - ((i - half) * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half)); + } + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].kind = BALLOON_3; + } + + // #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simetricos + j = 23; + mEnemyFormation[j].numberOfEnemies = 10; + incX = BALLOON_WIDTH_3 + 1; + incTime = 10; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x3_0 + (i * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i); + } + else + { + mEnemyFormation[j].init[i].x = x3_100 - ((i - half) * incX); + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half)); + } + mEnemyFormation[j].init[i].y = y3; + mEnemyFormation[j].init[i].kind = BALLOON_3; + } + + // #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simetricos + j = 24; + mEnemyFormation[j].numberOfEnemies = 30; + incX = 0; + incTime = 5; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x1_50; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * i); + } + else + { + mEnemyFormation[j].init[i].x = x1_50; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) + (incTime * (i - half)); + } + mEnemyFormation[j].init[i].y = y1; + mEnemyFormation[j].init[i].kind = BALLOON_1; + } + + // #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simetricos + j = 25; + mEnemyFormation[j].numberOfEnemies = 30; + incX = BALLOON_WIDTH_1 + 1; + incTime = 5; + for (int i = 0; i < mEnemyFormation[j].numberOfEnemies; i++) + { + Uint8 half = mEnemyFormation[j].numberOfEnemies / 2; + if (i < half) + { + mEnemyFormation[j].init[i].x = x1_50 + 20; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_NEGATIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * i); + } + else + { + mEnemyFormation[j].init[i].x = x1_50 - 20; + mEnemyFormation[j].init[i].velX = BALLOON_VELX_POSITIVE; + mEnemyFormation[j].init[i].creationCounter = (creationTime) - (incTime * (i - half)); + } + mEnemyFormation[j].init[i].y = y1; + mEnemyFormation[j].init[i].kind = BALLOON_1; + } + + // Crea las mismas formaciones pero con hexagonos a partir de la posición 50 del vector + for (int k = 0; k < j + 1; k++) + { + mEnemyFormation[k + 50].numberOfEnemies = mEnemyFormation[k].numberOfEnemies; + for (int i = 0; i < mEnemyFormation[k + 50].numberOfEnemies; i++) + { + mEnemyFormation[k + 50].init[i].x = mEnemyFormation[k].init[i].x; + mEnemyFormation[k + 50].init[i].y = mEnemyFormation[k].init[i].y; + mEnemyFormation[k + 50].init[i].velX = mEnemyFormation[k].init[i].velX; + mEnemyFormation[k + 50].init[i].creationCounter = mEnemyFormation[k].init[i].creationCounter; + mEnemyFormation[k + 50].init[i].kind = mEnemyFormation[k].init[i].kind + 4; + } + } + + // TEST + mEnemyFormation[99].numberOfEnemies = 4; + + mEnemyFormation[99].init[0].x = 10; + mEnemyFormation[99].init[0].y = y1; + mEnemyFormation[99].init[0].velX = 0; + mEnemyFormation[99].init[0].kind = BALLOON_1; + mEnemyFormation[99].init[0].creationCounter = 200; + + mEnemyFormation[99].init[1].x = 50; + mEnemyFormation[99].init[1].y = y1; + mEnemyFormation[99].init[1].velX = 0; + mEnemyFormation[99].init[1].kind = BALLOON_2; + mEnemyFormation[99].init[1].creationCounter = 200; + + mEnemyFormation[99].init[2].x = 90; + mEnemyFormation[99].init[2].y = y1; + mEnemyFormation[99].init[2].velX = 0; + mEnemyFormation[99].init[2].kind = BALLOON_3; + mEnemyFormation[99].init[2].creationCounter = 200; + + mEnemyFormation[99].init[3].x = 140; + mEnemyFormation[99].init[3].y = y1; + mEnemyFormation[99].init[3].velX = 0; + mEnemyFormation[99].init[3].kind = BALLOON_4; + mEnemyFormation[99].init[3].creationCounter = 200; +} + +// Inicializa los conjuntos de formaciones +void Game::initEnemyPools() +{ + // EnemyPool #0 + mEnemyPool[0].set[0] = &mEnemyFormation[0]; + mEnemyPool[0].set[1] = &mEnemyFormation[1]; + mEnemyPool[0].set[2] = &mEnemyFormation[2]; + mEnemyPool[0].set[3] = &mEnemyFormation[3]; + mEnemyPool[0].set[4] = &mEnemyFormation[4]; + mEnemyPool[0].set[5] = &mEnemyFormation[5]; + mEnemyPool[0].set[6] = &mEnemyFormation[6]; + mEnemyPool[0].set[7] = &mEnemyFormation[7]; + mEnemyPool[0].set[8] = &mEnemyFormation[8]; + mEnemyPool[0].set[9] = &mEnemyFormation[9]; + + // EnemyPool #1 + mEnemyPool[1].set[0] = &mEnemyFormation[10]; + mEnemyPool[1].set[1] = &mEnemyFormation[11]; + mEnemyPool[1].set[2] = &mEnemyFormation[12]; + mEnemyPool[1].set[3] = &mEnemyFormation[13]; + mEnemyPool[1].set[4] = &mEnemyFormation[14]; + mEnemyPool[1].set[5] = &mEnemyFormation[15]; + mEnemyPool[1].set[6] = &mEnemyFormation[16]; + mEnemyPool[1].set[7] = &mEnemyFormation[17]; + mEnemyPool[1].set[8] = &mEnemyFormation[18]; + mEnemyPool[1].set[9] = &mEnemyFormation[19]; + + // EnemyPool #2 + mEnemyPool[2].set[0] = &mEnemyFormation[0]; + mEnemyPool[2].set[1] = &mEnemyFormation[1]; + mEnemyPool[2].set[2] = &mEnemyFormation[2]; + mEnemyPool[2].set[3] = &mEnemyFormation[3]; + mEnemyPool[2].set[4] = &mEnemyFormation[4]; + mEnemyPool[2].set[5] = &mEnemyFormation[55]; + mEnemyPool[2].set[6] = &mEnemyFormation[56]; + mEnemyPool[2].set[7] = &mEnemyFormation[57]; + mEnemyPool[2].set[8] = &mEnemyFormation[58]; + mEnemyPool[2].set[9] = &mEnemyFormation[59]; + + // EnemyPool #3 + mEnemyPool[3].set[0] = &mEnemyFormation[50]; + mEnemyPool[3].set[1] = &mEnemyFormation[51]; + mEnemyPool[3].set[2] = &mEnemyFormation[52]; + mEnemyPool[3].set[3] = &mEnemyFormation[53]; + mEnemyPool[3].set[4] = &mEnemyFormation[54]; + mEnemyPool[3].set[5] = &mEnemyFormation[5]; + mEnemyPool[3].set[6] = &mEnemyFormation[6]; + mEnemyPool[3].set[7] = &mEnemyFormation[7]; + mEnemyPool[3].set[8] = &mEnemyFormation[8]; + mEnemyPool[3].set[9] = &mEnemyFormation[9]; + + // EnemyPool #4 + mEnemyPool[4].set[0] = &mEnemyFormation[60]; + mEnemyPool[4].set[1] = &mEnemyFormation[61]; + mEnemyPool[4].set[2] = &mEnemyFormation[62]; + mEnemyPool[4].set[3] = &mEnemyFormation[63]; + mEnemyPool[4].set[4] = &mEnemyFormation[64]; + mEnemyPool[4].set[5] = &mEnemyFormation[65]; + mEnemyPool[4].set[6] = &mEnemyFormation[66]; + mEnemyPool[4].set[7] = &mEnemyFormation[67]; + mEnemyPool[4].set[8] = &mEnemyFormation[68]; + mEnemyPool[4].set[9] = &mEnemyFormation[69]; + + // EnemyPool #5 + mEnemyPool[5].set[0] = &mEnemyFormation[10]; + mEnemyPool[5].set[1] = &mEnemyFormation[61]; + mEnemyPool[5].set[2] = &mEnemyFormation[12]; + mEnemyPool[5].set[3] = &mEnemyFormation[63]; + mEnemyPool[5].set[4] = &mEnemyFormation[14]; + mEnemyPool[5].set[5] = &mEnemyFormation[65]; + mEnemyPool[5].set[6] = &mEnemyFormation[16]; + mEnemyPool[5].set[7] = &mEnemyFormation[67]; + mEnemyPool[5].set[8] = &mEnemyFormation[18]; + mEnemyPool[5].set[9] = &mEnemyFormation[69]; + + // EnemyPool #6 + mEnemyPool[6].set[0] = &mEnemyFormation[60]; + mEnemyPool[6].set[1] = &mEnemyFormation[11]; + mEnemyPool[6].set[2] = &mEnemyFormation[62]; + mEnemyPool[6].set[3] = &mEnemyFormation[13]; + mEnemyPool[6].set[4] = &mEnemyFormation[64]; + mEnemyPool[6].set[5] = &mEnemyFormation[15]; + mEnemyPool[6].set[6] = &mEnemyFormation[66]; + mEnemyPool[6].set[7] = &mEnemyFormation[17]; + mEnemyPool[6].set[8] = &mEnemyFormation[68]; + mEnemyPool[6].set[9] = &mEnemyFormation[19]; + + // EnemyPool #7 + mEnemyPool[7].set[0] = &mEnemyFormation[20]; + mEnemyPool[7].set[1] = &mEnemyFormation[21]; + mEnemyPool[7].set[2] = &mEnemyFormation[22]; + mEnemyPool[7].set[3] = &mEnemyFormation[23]; + mEnemyPool[7].set[4] = &mEnemyFormation[24]; + mEnemyPool[7].set[5] = &mEnemyFormation[65]; + mEnemyPool[7].set[6] = &mEnemyFormation[66]; + mEnemyPool[7].set[7] = &mEnemyFormation[67]; + mEnemyPool[7].set[8] = &mEnemyFormation[68]; + mEnemyPool[7].set[9] = &mEnemyFormation[69]; + + // EnemyPool #8 + mEnemyPool[8].set[0] = &mEnemyFormation[70]; + mEnemyPool[8].set[1] = &mEnemyFormation[71]; + mEnemyPool[8].set[2] = &mEnemyFormation[72]; + mEnemyPool[8].set[3] = &mEnemyFormation[73]; + mEnemyPool[8].set[4] = &mEnemyFormation[74]; + mEnemyPool[8].set[5] = &mEnemyFormation[15]; + mEnemyPool[8].set[6] = &mEnemyFormation[16]; + mEnemyPool[8].set[7] = &mEnemyFormation[17]; + mEnemyPool[8].set[8] = &mEnemyFormation[18]; + mEnemyPool[8].set[9] = &mEnemyFormation[19]; + + // EnemyPool #9 + mEnemyPool[9].set[0] = &mEnemyFormation[20]; + mEnemyPool[9].set[1] = &mEnemyFormation[21]; + mEnemyPool[9].set[2] = &mEnemyFormation[22]; + mEnemyPool[9].set[3] = &mEnemyFormation[23]; + mEnemyPool[9].set[4] = &mEnemyFormation[24]; + mEnemyPool[9].set[5] = &mEnemyFormation[70]; + mEnemyPool[9].set[6] = &mEnemyFormation[71]; + mEnemyPool[9].set[7] = &mEnemyFormation[72]; + mEnemyPool[9].set[8] = &mEnemyFormation[73]; + mEnemyPool[9].set[9] = &mEnemyFormation[74]; +} + +// Inicializa las fases del juego +void Game::initGameStages() +{ + // STAGE 1 + mStage[0].number = 1; + mStage[0].currentPower = 0; + mStage[0].powerToComplete = 200; + mStage[0].minMenace = 7 + (4 * 1); + mStage[0].maxMenace = 7 + (4 * 3); + mStage[0].enemyPool = &mEnemyPool[0]; + + // STAGE 2 + mStage[1].number = 2; + mStage[1].currentPower = 0; + mStage[1].powerToComplete = 300; + mStage[1].minMenace = 7 + (4 * 2); + mStage[1].maxMenace = 7 + (4 * 4); + mStage[1].enemyPool = &mEnemyPool[1]; + + // STAGE 3 + mStage[2].number = 3; + mStage[2].currentPower = 0; + mStage[2].powerToComplete = 600; + mStage[2].minMenace = 7 + (4 * 3); + mStage[2].maxMenace = 7 + (4 * 6); + mStage[2].enemyPool = &mEnemyPool[2]; + + // STAGE 4 + mStage[3].number = 4; + mStage[3].currentPower = 0; + mStage[3].powerToComplete = 600; + mStage[3].minMenace = 7 + (4 * 3); + mStage[3].maxMenace = 7 + (4 * 7); + mStage[3].enemyPool = &mEnemyPool[3]; + + // STAGE 5 + mStage[4].number = 5; + mStage[4].currentPower = 0; + mStage[4].powerToComplete = 600; + mStage[4].minMenace = 7 + (4 * 4); + mStage[4].maxMenace = 7 + (4 * 8); + mStage[4].enemyPool = &mEnemyPool[4]; + + // STAGE 6 + mStage[5].number = 6; + mStage[5].currentPower = 0; + mStage[5].powerToComplete = 600; + mStage[5].minMenace = 7 + (4 * 5); + mStage[5].maxMenace = 7 + (4 * 10); + mStage[5].enemyPool = &mEnemyPool[5]; + + // STAGE 7 + mStage[6].number = 7; + mStage[6].currentPower = 0; + mStage[6].powerToComplete = 650; + mStage[6].minMenace = 7 + (4 * 6); + mStage[6].maxMenace = 7 + (4 * 11); + mStage[6].enemyPool = &mEnemyPool[6]; + + // STAGE 8 + mStage[7].number = 8; + mStage[7].currentPower = 0; + mStage[7].powerToComplete = 750; + mStage[7].minMenace = 7 + (4 * 7); + mStage[7].maxMenace = 7 + (4 * 12); + mStage[7].enemyPool = &mEnemyPool[7]; + + // STAGE 9 + mStage[8].number = 9; + mStage[8].currentPower = 0; + mStage[8].powerToComplete = 850; + mStage[8].minMenace = 7 + (4 * 8); + mStage[8].maxMenace = 7 + (4 * 13); + mStage[8].enemyPool = &mEnemyPool[8]; + + // STAGE 10 + mStage[9].number = 10; + mStage[9].currentPower = 0; + mStage[9].powerToComplete = 950; + mStage[9].minMenace = 7 + (4 * 9); + mStage[9].maxMenace = 7 + (4 * 15); + mStage[9].enemyPool = &mEnemyPool[9]; +} + +// Crea una formación de enemigos +void Game::deployEnemyFormation() +{ + // Solo despliega una formación enemiga si ha pasado cierto tiempo desde la última + if (mEnemyDeployCounter == 0) + { + + // En este punto se decide entre crear una powerball o una formación enemiga + if ((rand() % 100 < 15) && (canPowerBallBeCreated())) + { + // Crea una powerball + createPowerBall(); + + // Da un poco de margen para que se creen mas enemigos + mEnemyDeployCounter = 50; + } + else + { + // Decrementa el contador de despliegues enemigos de la PowerBall + mPowerBallCounter > 0 ? mPowerBallCounter-- : mPowerBallCounter = 0; + + // Elige una formación enemiga la azar + Uint8 set = (rand() % 10); + + // Evita repetir la ultima formación enemiga desplegada + if (set == mLastEnemyDeploy) + ++set %= 10; + + mLastEnemyDeploy = set; + + if (mDebug.enabled) + set = mDebug.enemySet; + + Uint8 numEnemies = mStage[mCurrentStage].enemyPool->set[set]->numberOfEnemies; + for (int i = 0; i < numEnemies; i++) + createNewBalloon(mStage[mCurrentStage].enemyPool->set[set]->init[i].x, + mStage[mCurrentStage].enemyPool->set[set]->init[i].y, + mStage[mCurrentStage].enemyPool->set[set]->init[i].kind, + mStage[mCurrentStage].enemyPool->set[set]->init[i].velX, + mEnemySpeed, + mStage[mCurrentStage].enemyPool->set[set]->init[i].creationCounter, + mTextureBalloon); + + mEnemyDeployCounter = 255; + } + } +} + +// Aumenta el poder de la fase +void Game::increaseStageCurrentPower(Uint8 power) +{ + mStage[mCurrentStage].currentPower += power; +} + +// Establece el valor de la variable +/*void Game::setScore(Uint32 score) +{ + mScore = score; +}*/ + +// Establece el valor de la variable +void Game::setHiScore(Uint32 score) +{ + mHiScore = score; +} + +// Actualiza el valor de mHiScore en caso necesario +void Game::updateHiScore() +{ + // Si la puntuación actual es mayor que la máxima puntuación + for (int i = 0; i < mNumPlayers; i++) + if (mPlayer[i]->getScore() > mHiScore) + { + // Actualiza la máxima puntuación + mHiScore = mPlayer[i]->getScore(); + + // Almacena la máxima puntuación en el fichero junto con un checksum + mScoreDataFile[0] = mHiScore; + mScoreDataFile[1] = mHiScore % 43; + + // Si se supera la máxima puntuación emite sonido + if (mHiScoreAchieved == false) + { + mHiScoreAchieved = true; + JA_PlaySound(mSoundHiScore); + } + } +} + +// Transforma un valor numérico en una cadena de 6 cifras +std::string Game::updateScoreText(Uint32 num) +{ + //return (std::to_string(num)); + + if ((num >= 0) && (num <= 9)) + { + return ("000000" + std::to_string(num)); + } + + if ((num >= 10) && (num <= 99)) + { + return ("00000" + std::to_string(num)); + } + + if ((num >= 100) && (num <= 999)) + { + return ("0000" + std::to_string(num)); + } + + if ((num >= 1000) && (num <= 9999)) + { + return ("000" + std::to_string(num)); + } + + if ((num >= 010000) && (num <= 99999)) + { + return ("00" + std::to_string(num)); + } + + if ((num >= 100000) && (num <= 999999)) + { + return ("0" + std::to_string(num)); + } + + if ((num >= 1000000) && (num <= 9999999)) + { + return (std::to_string(num)); + } + + return (std::to_string(num)); +} + +// Pinta el marcador en pantalla usando un objeto texto +void Game::renderScoreBoard() +{ + //color_t color = {0, 0, 0}; + + // Si el jugador esta muerto, no pintes el fondo del marcador, así que pase por encima cuando sale despedido + //if (mPlayer[0]->isAlive()) + mSpriteScoreBoard->render(); + /* + // SCORE + mText->writeCentered(PLAY_AREA_CENTER_FIRST_QUARTER_X, SCORE_WORD_Y - 6, mLang->getText(39), 0); + mText->writeCentered(PLAY_AREA_CENTER_FIRST_QUARTER_X, SCORE_NUMBER_Y - 6, updateScoreText(mPlayer[0]->getScore()), 0); + + // HI-SCORE + mText->writeCentered(PLAY_AREA_CENTER_THIRD_QUARTER_X, HISCORE_WORD_Y - 6, mLang->getText(40), 0); + mText->writeCentered(PLAY_AREA_CENTER_THIRD_QUARTER_X, HISCORE_NUMBER_Y - 6, updateScoreText(mHiScore), 0); + + // MULT + color.g = 255; + mText->writeColored(MULTIPLIER_WORD_X, MULTIPLIER_WORD_Y - 6, mLang->getText(41), color); + + color.g = 192; + mTextX2->writeShadowed(PLAY_AREA_CENTER_X - 16, SCORE_WORD_Y + 5, std::to_string(mPlayer[0]->getScoreMultiplier()).substr(0, 1), color, 1); + mText->writeShadowed(PLAY_AREA_CENTER_X - 2, SCORE_WORD_Y + 12, ".", color); + mText->writeShadowed(PLAY_AREA_CENTER_X + 4, SCORE_WORD_Y + 12, std::to_string(mPlayer[0]->getScoreMultiplier()).substr(2, 1), color); + + // STAGE + mText->writeCentered(PLAY_AREA_CENTER_FIRST_QUARTER_X, SCORE_NUMBER_Y + 4, mLang->getText(42) + std::to_string(mStage[mCurrentStage].number), 0); + + // POWER + mSpritePowerMeter->setSpriteClip(256, 184, 40, 8); + mSpritePowerMeter->render(); + const float percent = (mStage[mCurrentStage].currentPower * 40.0f) / mStage[mCurrentStage].powerToComplete; + mSpritePowerMeter->setSpriteClip(296, 184, (int)percent, 8); + mSpritePowerMeter->render(); + */ + const int offset1 = 162; + const int offset2 = offset1 + 7; + const int offset3 = offset2 + 7; + const int offset4 = offset3 + 7; + + const int offsetLeft = PLAY_AREA_LEFT + 45; + const int offsetRight = PLAY_AREA_RIGHT - 45; + + // PLAYER1 - SCORE + mTextScoreBoard->writeCentered(offsetLeft, offset1, mLang->getText(53)); + mTextScoreBoard->writeCentered(offsetLeft, offset2, updateScoreText(mPlayer[0]->getScore())); + + // PLAYER1 - MULT + mTextScoreBoard->writeCentered(offsetLeft, offset3, mLang->getText(55)); + mTextScoreBoard->writeCentered(offsetLeft, offset4, std::to_string(mPlayer[0]->getScoreMultiplier()).substr(0, 3)); + + if (mNumPlayers == 2) + { + // PLAYER2 - SCORE + mTextScoreBoard->writeCentered(offsetRight, offset1, mLang->getText(54)); + mTextScoreBoard->writeCentered(offsetRight, offset2, updateScoreText(mPlayer[1]->getScore())); + + // PLAYER2 - MULT + mTextScoreBoard->writeCentered(offsetRight, offset3, mLang->getText(55)); + mTextScoreBoard->writeCentered(offsetRight, offset4, std::to_string(mPlayer[1]->getScoreMultiplier()).substr(0, 3)); + } + else + { + // PLAYER2 - SCORE + mTextScoreBoard->writeCentered(offsetRight, offset1, mLang->getText(54)); + mTextScoreBoard->writeCentered(offsetRight, offset2, "0000000"); + + // PLAYER2 - MULT + mTextScoreBoard->writeCentered(offsetRight, offset3, mLang->getText(55)); + mTextScoreBoard->writeCentered(offsetRight, offset4, "1.0"); + } + + // STAGE + mTextScoreBoard->writeCentered(PLAY_AREA_CENTER_X, offset1, mLang->getText(57) + std::to_string(mStage[mCurrentStage].number)); + + // POWER + mSpritePowerMeter->setPosY(offset2); + mSpritePowerMeter->setSpriteClip(256, 184, 40, 8); + mSpritePowerMeter->render(); + const float percent = (mStage[mCurrentStage].currentPower * 40.0f) / mStage[mCurrentStage].powerToComplete; + mSpritePowerMeter->setSpriteClip(296, 184, (int)percent, 8); + mSpritePowerMeter->render(); + + // HI-SCORE + mTextScoreBoard->writeCentered(PLAY_AREA_CENTER_X, offset3, mLang->getText(56)); + mTextScoreBoard->writeCentered(PLAY_AREA_CENTER_X, offset4, updateScoreText(mHiScore)); +} + +// Actualiza las variables del jugador +void Game::updatePlayer() +{ + for (int i = 0; i < mNumPlayers; i++) + { + mPlayer[i]->update(); + + // Comprueba la colisión entre el jugador y los globos + if (checkPlayerBalloonCollision(i)) + { + if (mPlayer[i]->isAlive()) + { + if (mDemo.enabled) + mSection = {PROG_SECTION_TITLE, TITLE_SECTION_INSTRUCTIONS}; + else + killPlayer(i); + } + } + + // Comprueba las colisiones entre el jugador y los items + checkPlayerItemCollision(i); + } +} + +// Actualiza las variables de la fase +void Game::updateStage() +{ + if (mStage[mCurrentStage].currentPower >= mStage[mCurrentStage].powerToComplete) + { + // Cambio de fase + mCurrentStage++; + if (mCurrentStage == 10) // Ha llegado al final el juego + { + mGameCompleted = true; // Marca el juego como completado + mCurrentStage = 9; // Deja el valor dentro de los limites + mStage[mCurrentStage].currentPower = 0; // Deja el poder a cero para que no vuelva a entrar en esta condición + destroyAllBalloons(); // Destruye a todos los enemigos + mStage[mCurrentStage].currentPower = 0; // Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos lo globos + mMenaceCurrent = 255; // Sube el nivel de amenaza para que no cree mas globos + for (int i = 0; i < mNumPlayers; i++) // Añade un millon de puntos a los jugadores que queden vivos + if (mPlayer[i]->isAlive()) + mPlayer[i]->addScore(1000000); + updateHiScore(); + JA_StopMusic(); + } + JA_PlaySound(mSoundStageChange); + mStageBitmapCounter = 0; + mEnemySpeed = mDefaultEnemySpeed; + setBalloonSpeed(mEnemySpeed); + mEffect.flash = true; + mEffect.shake = true; + } + + // Incrementa el contador del bitmap que aparece mostrando el cambio de fase + if (mStageBitmapCounter < STAGE_COUNTER) + mStageBitmapCounter++; + + // Si el juego se ha completado, el bitmap se detiene en el centro de la pantalla + if (mGameCompleted) + if (mStageBitmapCounter > 100) + mStageBitmapCounter = 100; +} + +// Actualiza el estado de muerte +void Game::updateDeath() +{ + // Comprueba si todos los jugadores estan muertos + bool allAreDead = true; + for (int i = 0; i < mNumPlayers; i++) + { + allAreDead &= (!mPlayer[i]->isAlive()); + + if (!mPlayer[i]->isAlive()) + { + // Animación + if ((mPlayer[i]->getDeathCounter() / 5) % 4 == 0) + mSmartSprite[mPlayer[i]->mDeathIndex]->setSpriteClip(24 * 0, 24, 24, 24); + else if ((mPlayer[i]->getDeathCounter() / 5) % 4 == 1) + mSmartSprite[mPlayer[i]->mDeathIndex]->setSpriteClip(24 * 1, 24, 24, 24); + else if ((mPlayer[i]->getDeathCounter() / 5) % 4 == 2) + mSmartSprite[mPlayer[i]->mDeathIndex]->setSpriteClip(24 * 2, 24, 24, 24); + else if ((mPlayer[i]->getDeathCounter() / 5) % 4 == 3) + mSmartSprite[mPlayer[i]->mDeathIndex]->setSpriteClip(24 * 3, 24, 24, 24); + + // Rebote en los laterales + if (mSmartSprite[mPlayer[i]->mDeathIndex]->getVelX() > 0) + { + if (mSmartSprite[mPlayer[i]->mDeathIndex]->getPosX() > (SCREEN_WIDTH - mSmartSprite[mPlayer[i]->mDeathIndex]->getWidth())) + { + mSmartSprite[mPlayer[i]->mDeathIndex]->setPosX(SCREEN_WIDTH - mSmartSprite[mPlayer[i]->mDeathIndex]->getWidth()); + mSmartSprite[mPlayer[i]->mDeathIndex]->setVelX(mSmartSprite[mPlayer[i]->mDeathIndex]->getVelX() * (-1)); + mSmartSprite[mPlayer[i]->mDeathIndex]->setDestX(mSmartSprite[mPlayer[i]->mDeathIndex]->getDestX() * (-1)); + } + } + else + { + if (mSmartSprite[mPlayer[i]->mDeathIndex]->getPosX() < 0) + { + mSmartSprite[mPlayer[i]->mDeathIndex]->setPosX(0); + mSmartSprite[mPlayer[i]->mDeathIndex]->setVelX(mSmartSprite[mPlayer[i]->mDeathIndex]->getVelX() * (-1)); + mSmartSprite[mPlayer[i]->mDeathIndex]->setDestX(mSmartSprite[mPlayer[i]->mDeathIndex]->getDestX() * (-1)); + } + } + } + } + + if (allAreDead) + { + //JA_StopMusic(); + + if (mDeathCounter > 0) + { + mDeathCounter--; + if ((mDeathCounter == 250) || (mDeathCounter == 200) || (mDeathCounter == 180) || (mDeathCounter == 120) || (mDeathCounter == 60)) + { + Uint8 sound = rand() % 4; + switch (sound) + { + case 0: + JA_PlaySound(mSoundBubble1, 0); + break; + case 1: + JA_PlaySound(mSoundBubble2, 0); + break; + case 2: + JA_PlaySound(mSoundBubble3, 0); + break; + case 3: + JA_PlaySound(mSoundBubble4, 0); + break; + + default: + break; + } + } + } + else + { + mSection.subsection = GAME_SECTION_GAMEOVER; + } + } +} + +// Renderiza el fade final cuando se acaba la partida +void Game::renderDeathFade(int counter) +// Counter debe ir de 0 a 150 +{ + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); + + if (counter < 150) + { + // 192 / 6 = 32, 6 cuadrados de 32 pixeles + SDL_Rect rect[12]; + Uint8 h = counter / 3; + for (int i = 0; i < 12; i++) + { + rect[i].x = 0; + rect[i].y = i * 16; + rect[i].w = SCREEN_WIDTH; + if (i == 0) + rect[i].h = h; + else + rect[i].h = std::max(rect[i - 1].h - 3, 0); + SDL_RenderFillRect(mRenderer, &rect[i]); + } + } + else + { + SDL_Rect rect = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + SDL_RenderFillRect(mRenderer, &rect); + } +} + +// Actualiza los globos +void Game::updateBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + mBalloon[i]->update(); +} + +// Pinta en pantalla todos los globos activos +void Game::renderBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + { + mBalloon[i]->render(); + if ((mDebug.enabled) && (mBalloon[i]->isPopping() == false)) + mText->writeCentered(mBalloon[i]->getPosX() + (mBalloon[i]->getWidth() / 2), mBalloon[i]->getPosY() - 8, std::to_string(i)); + } +} + +// Devuelve el primer indice no activo del vector de globos +Uint8 Game::getBalloonFreeIndex() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if (!mBalloon[i]->isEnabled()) + return i; + + return 0; +} + +// Crea un globo nuevo en el vector de globos +Uint8 Game::createNewBalloon(float x, int y, Uint8 kind, float velx, float speed, Uint16 creationtimer, LTexture *texture) +{ + const Uint8 index = getBalloonFreeIndex(); + mBalloon[index]->init(x, y, kind, velx, speed, creationtimer, texture, mRenderer); + return index; +} + +// Crea una PowerBall +void Game::createPowerBall() +{ + const int posY = PLAY_AREA_TOP; + + const int left = PLAY_AREA_LEFT; + const int center = PLAY_AREA_CENTER_X - (BALLOON_WIDTH_4 / 2); + const int right = PLAY_AREA_RIGHT - BALLOON_WIDTH_4; + + const int x[3] = {left, center, right}; + const int posX = x[rand() % 3]; + + mBalloon[getBalloonFreeIndex()]->init(posX, posY, POWER_BALL, BALLOON_VELX_POSITIVE * (((rand() % 2) * 2) - 1), mEnemySpeed, 100, mTextureBalloon, mRenderer); + mPowerBallEnabled = true; + mPowerBallCounter = POWERBALL_COUNTER; +} + +// Establece a cero todos los valores del vector de objetos globo +void Game::resetBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + mBalloon[i]->disable(); +} + +// Establece la velocidad de los globos +void Game::setBalloonSpeed(float speed) +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if (mBalloon[i]->isEnabled()) + mBalloon[i]->setSpeed(speed); +} + +// Incrementa la velocidad de los globos +void Game::incBalloonSpeed() +{ + // La velocidad solo se incrementa en el modo normal + if (mDifficulty == DIFFICULTY_NORMAL) + { + if (mEnemySpeed == BALLOON_SPEED_1) + mEnemySpeed = BALLOON_SPEED_2; + else if (mEnemySpeed == BALLOON_SPEED_2) + mEnemySpeed = BALLOON_SPEED_3; + else if (mEnemySpeed == BALLOON_SPEED_3) + mEnemySpeed = BALLOON_SPEED_4; + else if (mEnemySpeed == BALLOON_SPEED_4) + mEnemySpeed = BALLOON_SPEED_5; + + setBalloonSpeed(mEnemySpeed); + } +} + +// Decrementa la velocidad de los globos +void Game::decBalloonSpeed() +{ + // La velocidad solo se decrementa en el modo normal + if (mDifficulty == DIFFICULTY_NORMAL) + { + if (mEnemySpeed == BALLOON_SPEED_5) + mEnemySpeed = BALLOON_SPEED_4; + else if (mEnemySpeed == BALLOON_SPEED_4) + mEnemySpeed = BALLOON_SPEED_3; + else if (mEnemySpeed == BALLOON_SPEED_3) + mEnemySpeed = BALLOON_SPEED_2; + else if (mEnemySpeed == BALLOON_SPEED_2) + mEnemySpeed = BALLOON_SPEED_1; + + setBalloonSpeed(mEnemySpeed); + } +} + +// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase +void Game::updateBalloonSpeed() +{ + const float percent = (float)mStage[mCurrentStage].currentPower / (float)mStage[mCurrentStage].powerToComplete; + if (mEnemySpeed == BALLOON_SPEED_1) + { + if (percent > 0.2f) + incBalloonSpeed(); + } + else if (mEnemySpeed == BALLOON_SPEED_2) + { + if (percent > 0.4f) + incBalloonSpeed(); + } + else if (mEnemySpeed == BALLOON_SPEED_3) + { + if (percent > 0.6f) + incBalloonSpeed(); + } + else if (mEnemySpeed == BALLOON_SPEED_4) + { + if (percent > 0.8f) + incBalloonSpeed(); + } +} + +// Explosiona un globo. Lo destruye y crea otros dos si es el caso +void Game::popBalloon(Uint8 index) +{ + // Aumenta el poder de la fase + increaseStageCurrentPower(1); + mBalloonsPopped++; + + const Uint8 kind = mBalloon[index]->getKind(); + Uint8 freeIndex = 0; + switch (kind) + { + // Si es del tipo más pequeño, simplemente elimina el globo + case BALLOON_1: + mBalloon[index]->pop(); + break; + + case HEXAGON_1: + mBalloon[index]->pop(); + break; + + // Si es del tipo PowerBall, destruye todos los globos + case POWER_BALL: + destroyAllBalloons(); + mPowerBallEnabled = false; + mEnemyDeployCounter = 20; + break; + + // En cualquier otro caso, crea dos globos de un tipo inferior + default: + freeIndex = getBalloonFreeIndex(); + mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_NEGATIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer); + mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2)); + if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS) + mBalloon[freeIndex]->setVelY(-2.50f); + else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS) + mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE); + + freeIndex = getBalloonFreeIndex(); + mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_POSITIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer); + mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2)); + if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS) + mBalloon[freeIndex]->setVelY(-2.50f); + else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS) + mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE); + + // Elimina el globo + mBalloon[index]->pop(); + break; + } + + // Recalcula el nivel de amenaza + evaluateAndSetMenace(); +} + +// Explosiona un globo. Lo destruye +void Game::destroyBalloon(Uint8 index) +{ + int score = 0; + Uint8 power = 0; + + // Calcula la puntuación y el poder que generaria el globo en caso de romperlo a él y a sus hijos + switch (mBalloon[index]->getSize()) + { + case BALLOON_SIZE_4: + score = BALLOON_SCORE_4 + (2 * BALLOON_SCORE_3) + (4 * BALLOON_SCORE_2) + (8 * BALLOON_SCORE_1); + power = 15; + break; + + case BALLOON_SIZE_3: + score = BALLOON_SCORE_3 + (2 * BALLOON_SCORE_2) + (4 * BALLOON_SCORE_1); + power = 7; + break; + + case BALLOON_SIZE_2: + score = BALLOON_SCORE_2 + (2 * BALLOON_SCORE_1); + power = 3; + break; + + case BALLOON_SIZE_1: + score = BALLOON_SCORE_1; + power = 1; + break; + + default: + score = 0; + power = 0; + break; + } + + // Otorga los puntos correspondientes al globo + for (int i = 0; i < mNumPlayers; i++) + mPlayer[i]->addScore(Uint32(score * mPlayer[i]->getScoreMultiplier() * mDifficultyScoreMultiplier)); + updateHiScore(); + + // Aumenta el poder de la fase + increaseStageCurrentPower(power); + mBalloonsPopped += power; + + // Destruye el globo + mBalloon[index]->pop(); + + // Recalcula el nivel de amenaza + evaluateAndSetMenace(); +} + +// Explosiona todos los globos +void Game::popAllBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()) && (!mBalloon[i]->isBeingCreated())) + popBalloon(i); + + JA_PlaySound(mSoundBalloon); +} + +// Destruye todos los globos +void Game::destroyAllBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + //if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()) && (!mBalloon[i]->isBeingCreated())) + if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping())) + destroyBalloon(i); + + mEnemyDeployCounter = 255; + JA_PlaySound(mSoundPowerBall); + mEffect.flash = true; + mEffect.shake = true; +} + +// Detiene todos los globos +void Game::stopAllBalloons(Uint16 time) +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if (mBalloon[i]->isEnabled()) + { + mBalloon[i]->setStop(true); + mBalloon[i]->setStoppedTimer(time); + } +} + +// Pone en marcha todos los globos +void Game::startAllBalloons() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isBeingCreated())) + { + mBalloon[i]->setStop(false); + mBalloon[i]->setStoppedTimer(0); + } +} + +// Obtiene el numero de globos activos +Uint8 Game::countBalloons() +{ + Uint8 num = 0; + + for (int i = 0; i < MAX_BALLOONS; i++) + if (mBalloon[i]->isEnabled()) + if (!mBalloon[i]->isPopping()) + num++; + + return num; +} + +// Comprueba la colisión entre el jugador y los globos activos +bool Game::checkPlayerBalloonCollision(int index) +{ + for (int i = 0; i < MAX_BALLOONS; i++) + if ((mBalloon[i]->isEnabled()) && !(mBalloon[i]->isStopped()) && !(mBalloon[i]->isInvulnerable())) + if (checkCollision(mPlayer[index]->getCollider(), mBalloon[i]->getCollider())) + return true; + + return false; +} + +// Comprueba la colisión entre el jugador y los items +void Game::checkPlayerItemCollision(int index) +{ + if (mPlayer[index]->isAlive()) + for (int i = 0; i < MAX_ITEMS; i++) + { + if (mItem[i]->isEnabled()) + { + if (checkCollision(mPlayer[index]->getCollider(), mItem[i]->getCollider())) + { + switch (mItem[i]->getClass()) + { + case ITEM_POINTS_1_DISK: + mPlayer[index]->addScore(1000); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m1000Bitmap->getWidth() / 2), mPlayer[index]->getPosY(), m1000Bitmap); + JA_PlaySound(mSoundItemPickup); + break; + case ITEM_POINTS_2_GAVINA: + mPlayer[index]->addScore(2500); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m2500Bitmap->getWidth() / 2), mPlayer[index]->getPosY(), m2500Bitmap); + JA_PlaySound(mSoundItemPickup); + break; + case ITEM_POINTS_3_PACMAR: + mPlayer[index]->addScore(5000); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m5000Bitmap->getWidth() / 2), mPlayer[index]->getPosY(), m5000Bitmap); + JA_PlaySound(mSoundItemPickup); + break; + case ITEM_CLOCK: + enableTimeStopItem(); + JA_PlaySound(mSoundItemPickup); + break; + case ITEM_COFFEE: + if (mPlayer[index]->getCoffees() == 2) + { + mPlayer[index]->addScore(5000); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m5000Bitmap->getWidth() / 2), mPlayer[index]->getPosY(), m5000Bitmap); + } + mPlayer[index]->giveExtraHit(); + JA_PlaySound(mSoundItemPickup); + break; + case ITEM_COFFEE_MACHINE: + mPlayer[index]->setPowerUp(true); + JA_PlaySound(mSoundItemPickup); + mCoffeeMachineEnabled = false; + break; + + default: + break; + } + mItem[i]->erase(); + } + } + } +} + +// Comprueba y procesa la colisión entre las balas y los globos +void Game::checkBulletBalloonCollision() +{ + for (int i = 0; i < MAX_BALLOONS; i++) + for (int j = 0; j < MAX_BULLETS; j++) + if (mBalloon[i]->isEnabled() && (!mBalloon[i]->isInvulnerable()) && mBullet[j]->isActive()) + if (checkCollision(mBalloon[i]->getCollider(), mBullet[j]->getCollider())) + { + // Otorga los puntos correspondientes al globo al jugador que disparó la bala + int index = mBullet[j]->getOwner(); + mPlayer[index]->incScoreMultiplier(); + mPlayer[index]->addScore(Uint32(mBalloon[i]->getScore() * mPlayer[index]->getScoreMultiplier() * mDifficultyScoreMultiplier)); + //setScore(mPlayer[index]->getScore()); + updateHiScore(); + + // Explota el globo + popBalloon(i); + + // Si no es el modo demo, genera un sonido + if (!mDemo.enabled) + JA_PlaySound(mSoundBalloon); + + // Destruye la bala + mBullet[j]->erase(); + + // Suelta el item en caso de que salga uno + const Uint8 droppeditem = dropItem(); + if ((droppeditem != NO_KIND) && !(mDemo.enabled) && !(mDemo.recording)) + { + if (droppeditem != ITEM_COFFEE_MACHINE) + { + createItem(mBalloon[i]->getPosX(), mBalloon[i]->getPosY(), droppeditem); + JA_PlaySound(mSoundItemDrop); + } + else + { + createItem(mPlayer[index]->getPosX(), 0, droppeditem); + mCoffeeMachineEnabled = true; + } + } + break; + } +} + +// Mueve las balas activas +void Game::moveBullets() +{ + for (int i = 0; i < MAX_BULLETS; i++) + if (mBullet[i]->isActive()) + if (mBullet[i]->move() == MSG_BULLET_OUT) + mPlayer[mBullet[i]->getOwner()]->decScoreMultiplier(); +} + +// Pinta las balas activas +void Game::renderBullets() +{ + for (int i = 0; i < MAX_BULLETS; i++) + if (mBullet[i]->isActive()) + mBullet[i]->render(); +} + +// Devuelve el primer indice no activo del vector de balas +Uint8 Game::getBulletFreeIndex() +{ + for (int i = 0; i < MAX_BULLETS; i++) + if (mBullet[i]->isActive() == false) + return i; + + return 0; +} + +// Establece a cero todos los valores del vector de objetos bala +void Game::resetBullets() +{ + for (int i = 0; i < MAX_BULLETS; i++) + mBullet[i]->erase(); +} + +// Crea un objeto bala +void Game::createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner) +{ + mBullet[getBulletFreeIndex()]->init(x, y, kind, poweredUp, owner, mTextureBullet, mRenderer); +} + +// Actualiza los items +void Game::updateItems() +{ + for (int i = 0; i < MAX_ITEMS; i++) + { + mItem[i]->update(); + if (mItem[i]->floorCollision()) + { + JA_PlaySound(mSoundCollision); + mEffect.shake = true; + } + } +} + +// Pinta los items activos +void Game::renderItems() +{ + for (int i = 0; i < MAX_ITEMS; i++) + mItem[i]->render(); +} + +// Devuelve el primer indice no activo del vector de items +Uint8 Game::getItemFreeIndex() +{ + for (int i = 0; i < MAX_ITEMS; i++) + if (mItem[i]->getClass() == NO_KIND) + return i; + + return 0; +} + +// Establece a cero todos los valores del vector de objetos item +void Game::resetItems() +{ + for (int i = 0; i < MAX_ITEMS; i++) + mItem[i]->erase(); +} + +// Devuelve un item en función del azar +Uint8 Game::dropItem() +{ + //if (mPlayer[0]->isPowerUp() || (mCoffeeMachineEnabled)) + // return NO_KIND; + //else + // return ITEM_COFFEE_MACHINE; + + const Uint8 luckyNumber = rand() % 100; + const Uint8 item = rand() % 6; + + switch (item) + { + case 0: + if (luckyNumber < mHelper.itemPoints1Odds) + return ITEM_POINTS_1_DISK; + break; + case 1: + if (luckyNumber < mHelper.itemPoints2Odds) + return ITEM_POINTS_2_GAVINA; + break; + case 2: + if (luckyNumber < mHelper.itemPoints3Odds) + return ITEM_POINTS_3_PACMAR; + break; + case 3: + if (luckyNumber < mHelper.itemClockOdds) + return ITEM_CLOCK; + break; + case 4: + if (luckyNumber < mHelper.itemCoffeeOdds) + { + mHelper.itemCoffeeOdds = ITEM_COFFEE_ODDS; + return ITEM_COFFEE; + } + else + { + if (mHelper.needCoffee) + mHelper.itemCoffeeOdds++; + } + break; + case 5: + if (luckyNumber < mHelper.itemCoffeeMachineOdds) + { + mHelper.itemCoffeeMachineOdds = ITEM_COFFEE_MACHINE_ODDS; + if ((!mCoffeeMachineEnabled) && (mHelper.needCoffeeMachine)) + return ITEM_COFFEE_MACHINE; + } + else + { + if (mHelper.needCoffeeMachine) + mHelper.itemCoffeeMachineOdds++; + } + break; + default: + break; + } + + return NO_KIND; +} + +// Crea un objeto item +void Game::createItem(int x, int y, Uint8 kind) +{ + mItem[getItemFreeIndex()]->init(kind, x, y, mTextureItems, mRenderer); +} + +// Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto +void Game::createItemScoreSprite(int x, int y, SmartSprite *sprite) +{ + const Uint8 index = getSmartSpriteFreeIndex(); + + *mSmartSprite[index] = *sprite; + mSmartSprite[index]->setPosX(x); + mSmartSprite[index]->setPosY(y); + mSmartSprite[index]->setDestX(x); + mSmartSprite[index]->setDestY(y - 15); + mSmartSprite[index]->setEnabled(true); + mSmartSprite[index]->setEnabledTimer(100); +} + +// Dibuja el efecto de flash +void Game::renderFlashEffect() +{ + if (mEffect.flash) + { + // Pantallazo blanco + SDL_SetRenderDrawColor(mRenderer, 0xFF, 0xFF, 0xFF, 0xFF); + SDL_RenderClear(mRenderer); + + mEffect.flash = false; + } +} + +// Actualiza el efecto de agitar la pantalla +void Game::updateShakeEffect() +{ + if (mEffect.shake) + { + if (mEffect.shakeCounter > 0) + mEffect.shakeCounter--; + else + { + mEffect.shake = false; + mEffect.shakeCounter = SHAKE_COUNTER; + } + } +} + +// Crea un SmartSprite para arrojar el item café al recibir un impacto +void Game::throwCoffee(int x, int y) +{ + const Uint8 index = getSmartSpriteFreeIndex(); + + mSmartSprite[index]->init(mTextureItems, mRenderer); + mSmartSprite[index]->setPosX(x - 8); + mSmartSprite[index]->setPosY(y - 8); + mSmartSprite[index]->setWidth(16); + mSmartSprite[index]->setHeight(16); + mSmartSprite[index]->setVelX(-1.0f + ((rand() % 5) * 0.5f)); + mSmartSprite[index]->setVelY(-4.0f); + mSmartSprite[index]->setAccelX(0.0f); + mSmartSprite[index]->setAccelY(0.2f); + mSmartSprite[index]->setDestX(x + (mSmartSprite[index]->getVelX() * 50)); + mSmartSprite[index]->setDestY(SCREEN_HEIGHT + 1); + mSmartSprite[index]->setEnabled(true); + mSmartSprite[index]->setEnabledTimer(1); + mSmartSprite[index]->setSpriteClip(80, 16, 16, 16); + mSmartSprite[index]->setRotate(true); + mSmartSprite[index]->setRotateSpeed(10); + mSmartSprite[index]->setRotateAmount(90.0); +} + +// Crea un SmartSprite para arrojar al jugador al morir +void Game::throwPlayer(int x, int y, int index) +{ + const int sentit = ((rand() % 2) ? 1 : -1); + + mPlayer[index]->mDeathIndex = getSmartSpriteFreeIndex(); + mSmartSprite[mPlayer[index]->mDeathIndex]->init(mPlayer[index]->getDeadTexture(), mRenderer); + mSmartSprite[mPlayer[index]->mDeathIndex]->setPosX(x); + mSmartSprite[mPlayer[index]->mDeathIndex]->setPosY(y); + mSmartSprite[mPlayer[index]->mDeathIndex]->setWidth(24); + mSmartSprite[mPlayer[index]->mDeathIndex]->setHeight(24); + mSmartSprite[mPlayer[index]->mDeathIndex]->setVelX(2.0f * sentit); + mSmartSprite[mPlayer[index]->mDeathIndex]->setVelY(-5.0f); + mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelX(0.0f); + mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelY(0.2f); + mSmartSprite[mPlayer[index]->mDeathIndex]->setDestX(SCREEN_WIDTH * sentit); + mSmartSprite[mPlayer[index]->mDeathIndex]->setDestY(SCREEN_HEIGHT + 1); + mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabled(true); + mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabledTimer(1); + mSmartSprite[mPlayer[index]->mDeathIndex]->setSpriteClip(0, 0, 24, 24); +} + +// Actualiza los SmartSprites +void Game::updateSmartSprites() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + mSmartSprite[i]->update(); +} + +// Pinta los SmartSprites activos +void Game::renderSmartSprites() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + mSmartSprite[i]->render(); +} + +// Devuelve el primer indice no activo del vector de SmartSprites +Uint8 Game::getSmartSpriteFreeIndex() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + if (!mSmartSprite[i]->isEnabled()) + return i; + + return 0; +} + +// Establece a cero todos los valores del vector de objetos SmafrtSprite +void Game::resetSmartSprites() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + mSmartSprite[i]->erase(); +} + +// Acciones a realizar cuando el jugador muere +void Game::killPlayer(int index) +{ + if (!mPlayer[index]->isInvulnerable()) + { + if (mPlayer[index]->hasExtraHit()) + { + mPlayer[index]->removeExtraHit(); + throwCoffee(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2), mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2)); + JA_PlaySound(mSoundCoffeeOut); + } + else + { + JA_PauseMusic(); + stopAllBalloons(10); + JA_PlaySound(mSoundPlayerCollision); + shakeScreen(); + SDL_Delay(500); + JA_PlaySound(mSoundCoffeeOut); + throwPlayer(mPlayer[index]->getPosX(), mPlayer[index]->getPosY(), index); + mPlayer[index]->setAlive(false); + if (allPlayersAreDead()) + JA_StopMusic(); + else + JA_ResumeMusic(); + } + } +} + +// Calcula y establece el valor de amenaza en funcion de los globos activos +void Game::evaluateAndSetMenace() +{ + mMenaceCurrent = 0; + for (int i = 0; i < MAX_BALLOONS; i++) + if (mBalloon[i]->isEnabled()) + mMenaceCurrent += mBalloon[i]->getMenace(); +} + +// Obtiene el valor de la variable +Uint8 Game::getMenace() +{ + return mMenaceCurrent; +} + +// Establece el valor de la variable +void Game::setTimeStopped(bool value) +{ + mTimeStopped = value; +} + +// Obtiene el valor de la variable +bool Game::isTimeStopped() +{ + return mTimeStopped; +} + +// Establece el valor de la variable +void Game::setTimeStoppedCounter(Uint16 value) +{ + mTimeStoppedCounter = value; +} + +// Incrementa el valor de la variable +void Game::incTimeStoppedCounter(Uint16 value) +{ + mTimeStoppedCounter += value; +} + +// Actualiza y comprueba el valor de la variable +void Game::updateTimeStoppedCounter() +{ + if (isTimeStopped()) + { + if (mTimeStoppedCounter > 0) + { + mTimeStoppedCounter--; + stopAllBalloons(TIME_STOPPED_COUNTER); + } + else + { + disableTimeStopItem(); + } + } +} + +// Establece el valor de la variable +void Game::setExplosionTime(bool value) +{ + mExplosionTime = value; +} + +// Obtiene el valor de la variable +bool Game::isExplosionTime() +{ + return mExplosionTime; +} + +// Establece el valor de la variable +void Game::setRemainingExplosions(Uint8 value) +{ + mRemainingExplosions = value; +} + +// Actualiza y comprueba el valor de la variable +void Game::updateRemainingExplosionsCounter() +{ + if (isExplosionTime()) + { + if (mRemainingExplosionsCounter > 0) + { + mRemainingExplosionsCounter--; + } + else if (mRemainingExplosions > 0) + { + popAllBalloons(); + mRemainingExplosions--; + mRemainingExplosionsCounter = REMAINING_EXPLOSIONS_COUNTER; + } + else + { + mExplosionTime = false; + mRemainingExplosions = REMAINING_EXPLOSIONS; + mRemainingExplosionsCounter = REMAINING_EXPLOSIONS_COUNTER; + } + } +} + +// Actualiza la variable mEnemyDeployCounter +void Game::updateEnemyDeployCounter() +{ + if (mEnemyDeployCounter > 0) + mEnemyDeployCounter--; +} + +// Actualiza el campo de juego +void Game::updatePlayField() +{ + // Comprueba el teclado/mando + checkGameInput(); + + // Actualiza las variables del jugador + updatePlayer(); + + // Actualiza el fondo + updateBackground(); + + // Mueve los globos + updateBalloons(); + + // Mueve las balas + moveBullets(); + + // Actualiza los items + updateItems(); + + // Actualiza el valor de mCurrentStage + updateStage(); + + // Actualiza el estado de muerte + updateDeath(); + + // Actualiza los SmartSprites + updateSmartSprites(); + + // Actualiza los contadores de estado y efectos + updateTimeStoppedCounter(); + updateRemainingExplosionsCounter(); + updateEnemyDeployCounter(); + updateShakeEffect(); + + // Actualiza el ayudante + updateHelper(); + + // Comprueba las colisiones entre globos y balas + checkBulletBalloonCollision(); + + // Comprueba el nivel de amenaza para ver si se han de crear nuevos enemigos + if (!mGameCompleted) + updateMenace(); + + // Actualiza la velocidad de los enemigos + updateBalloonSpeed(); + + // Actualiza el tramo final de juego, una vez completado + updateGameCompleted(); +} + +// Actualiza el fondo +void Game::updateBackground() +{ + mClouds1a->move(); + mClouds1b->move(); + mClouds2a->move(); + mClouds2b->move(); + + if (mClouds1a->getPosX() < -mClouds1a->getWidth()) + mClouds1a->setPosX(mClouds1a->getWidth()); + + if (mClouds1b->getPosX() < -mClouds1b->getWidth()) + mClouds1b->setPosX(mClouds1b->getWidth()); + + if (mClouds2a->getPosX() < -mClouds2a->getWidth()) + mClouds2a->setPosX(mClouds2a->getWidth()); + + if (mClouds2b->getPosX() < -mClouds2b->getWidth()) + mClouds2b->setPosX(mClouds2b->getWidth()); + + mSpriteGrass->setSpriteClip(256, 85 + (6 * (mCounter / 20 % 2)), SCREEN_WIDTH, 6); + + if (mEffect.shake) + mSpriteBackground->setPosX(((mEffect.shakeCounter % 2) * 2) - 1); + else + mSpriteBackground->setPosX(0); +} + +// Dibuja el fondo +void Game::renderBackground() +{ + const float gradientNumber = std::min(((float)mBalloonsPopped / 1000.0f), 3.0f); + const float percent = gradientNumber - (int)gradientNumber; + const int alpha = std::max((255 - (int)(255 * percent)), 0); + + // Dibuja el gradiente 2 + mSpriteGradient->setSpriteClip(mGradientRect[((int)gradientNumber + 1) % 4]); + mSpriteGradient->render(); + + // Dibuja el gradiente 1 con una opacidad cada vez menor + mSpriteGradient->setSpriteClip(mGradientRect[(int)gradientNumber]); + mTextureGameBG->setAlpha(alpha); + mSpriteGradient->render(); + mTextureGameBG->setAlpha(255); + + mClouds1a->render(); + mClouds1b->render(); + mClouds2a->render(); + mClouds2b->render(); + + mSpriteBackground->render(); + + mSpriteGrass->render(); +} + +// Dibuja el campo de juego +void Game::renderPlayField() +{ + renderBackground(); + renderBalloons(); + renderBullets(); + renderMessages(); + renderItems(); + renderSmartSprites(); + renderScoreBoard(); + for (int i = 0; i < mNumPlayers; i++) + mPlayer[i]->render(); + if ((mDeathCounter <= 150) && !mPlayer[0]->isAlive()) + renderDeathFade(150 - mDeathCounter); + if ((mGameCompleted) && (mGameCompletedCounter >= 300)) + renderDeathFade(mGameCompletedCounter - 300); + renderFlashEffect(); +} + +// Gestiona el nivel de amenaza +void Game::updateMenace() +{ + const float percent = mStage[mCurrentStage].currentPower / mStage[mCurrentStage].powerToComplete; + const Uint8 difference = mStage[mCurrentStage].maxMenace - mStage[mCurrentStage].minMenace; + + // Aumenta el nivel de amenaza en función de la puntuación + mMenaceThreshold = mStage[mCurrentStage].minMenace + (difference * percent); + + // Si el nivel de amenza es inferior al umbral + if (mMenaceCurrent < mMenaceThreshold) + { + // Crea una formación de enemigos + deployEnemyFormation(); + + // Recalcula el nivel de amenaza con el nuevo globo + evaluateAndSetMenace(); + } +} + +// Gestiona la entrada durante el juego +void Game::checkGameInput() +{ + mDemo.keys.left = 0; + mDemo.keys.right = 0; + mDemo.keys.noInput = 0; + mDemo.keys.fire = 0; + mDemo.keys.fireLeft = 0; + mDemo.keys.fireRight = 0; + + // Modo Demo activo + if (mDemo.enabled) + { + const int index = 0; + if (mDemo.dataFile[mDemo.counter].left == 1) + mPlayer[index]->setInput(INPUT_LEFT); + + if (mDemo.dataFile[mDemo.counter].right == 1) + mPlayer[index]->setInput(INPUT_RIGHT); + + if (mDemo.dataFile[mDemo.counter].noInput == 1) + mPlayer[index]->setInput(NO_INPUT); + + if (mDemo.dataFile[mDemo.counter].fire == 1) + if (mPlayer[index]->canFire()) + { + mPlayer[index]->setInput(INPUT_FIRE_UP); + createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index); + mPlayer[index]->setFireCooldown(10); + } + + if (mDemo.dataFile[mDemo.counter].fireLeft == 1) + if (mPlayer[index]->canFire()) + { + mPlayer[index]->setInput(INPUT_FIRE_LEFT); + createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index); + mPlayer[index]->setFireCooldown(10); + } + + if (mDemo.dataFile[mDemo.counter].fireRight == 1) + if (mPlayer[index]->canFire()) + { + mPlayer[index]->setInput(INPUT_FIRE_RIGHT); + createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index); + mPlayer[index]->setFireCooldown(10); + } + + // Comprueba el input de pausa + if (mInput->checkInput(INPUT_BUTTON_PAUSE, REPEAT_FALSE)) + mSection.name = PROG_SECTION_TITLE; + + // Incrementa el contador de la demo + if (mDemo.counter < TOTAL_DEMO_DATA) + mDemo.counter++; + else + mSection = {PROG_SECTION_TITLE, TITLE_SECTION_INSTRUCTIONS}; + } + // Modo Demo no activo + else + for (int i = 0; i < mNumPlayers; i++) + if (mPlayer[i]->isAlive()) + { + // Input a la izquierda + if (mInput->checkInput(INPUT_LEFT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + mPlayer[i]->setInput(INPUT_LEFT); + mDemo.keys.left = 1; + } + else + { + // Input a la derecha + if (mInput->checkInput(INPUT_RIGHT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + mPlayer[i]->setInput(INPUT_RIGHT); + mDemo.keys.right = 1; + } + else + { + // Ninguno de los dos inputs anteriores + mPlayer[i]->setInput(NO_INPUT); + mDemo.keys.noInput = 1; + } + } + // Comprueba el input de disparar al centro + if (mInput->checkInput(INPUT_BUTTON_2, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + if (mPlayer[i]->canFire()) + { + mPlayer[i]->setInput(INPUT_FIRE_UP); + createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_UP, mPlayer[i]->isPowerUp(), i); + mPlayer[i]->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSoundBullet); + + mDemo.keys.fire = 1; + } + } + + // Comprueba el input de disparar a la izquierda + if (mInput->checkInput(INPUT_BUTTON_1, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + if (mPlayer[i]->canFire()) + { + mPlayer[i]->setInput(INPUT_FIRE_LEFT); + createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_LEFT, mPlayer[i]->isPowerUp(), i); + mPlayer[i]->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSoundBullet); + + mDemo.keys.fireLeft = 1; + } + } + + // Comprueba el input de disparar a la derecha + if (mInput->checkInput(INPUT_BUTTON_3, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + if (mPlayer[i]->canFire()) + { + mPlayer[i]->setInput(INPUT_FIRE_RIGHT); + createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_RIGHT, mPlayer[i]->isPowerUp(), i); + mPlayer[i]->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSoundBullet); + + mDemo.keys.fireRight = 1; + } + } + + // Comprueba el input de pausa + if (mInput->checkInput(INPUT_CANCEL, REPEAT_FALSE, mOptions->input[i].deviceType, mOptions->input[i].id)) + { + mSection.subsection = GAME_SECTION_PAUSE; + + if (JA_GetMusicState() == JA_MUSIC_PLAYING) + JA_PauseMusic(); + } + + if (mDemo.counter < TOTAL_DEMO_DATA) + { + if (mDemo.recording) + mDemo.dataFile[mDemo.counter] = mDemo.keys; + mDemo.counter++; + } + else if (mDemo.recording) + { + mSection.name = PROG_SECTION_QUIT; + } + } +} + +// Pinta diferentes mensajes en la pantalla +void Game::renderMessages() +{ + // GetReady + if ((mCounter < STAGE_COUNTER) && (!mDemo.enabled)) + { + mSpriteGetReady->setPosX((int)mGetReadyBitmapPath[mCounter]); + //mSpriteGetReady->render(); + //const color_t color = {0x17, 0x17, 0x26}; + //mTextBig->writeShadowed((int)mGetReadyBitmapPath[mCounter], PLAY_AREA_CENTER_Y - 8, mLang->getText(75), color, 2); + //mTextBig->writeDX(TXT_STROKE, (int)mGetReadyBitmapPath[mCounter], PLAY_AREA_CENTER_Y - 8, mLang->getText(75), 1, noColor, 1, shdwTxtColor); + mTextNokiaBig2->write((int)mGetReadyBitmapPath[mCounter], PLAY_AREA_CENTER_Y - 8, mLang->getText(75), -2); + } + + // Time Stopped + if (mTimeStopped) + { + if ((mTimeStoppedCounter > 100) || (mTimeStoppedCounter % 10 > 4)) + mTextNokia2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, mLang->getText(36) + std::to_string(mTimeStoppedCounter / 10), -1, noColor, 1, shdwTxtColor); + //{ + // mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, mLang->getText(36), -2); + // mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y + mTextNokiaBig2->getCharacterWidth() + 2, std::to_string(mTimeStoppedCounter / 10), -2); + //} + + if (mTimeStoppedCounter > 100) + { + if (mTimeStoppedCounter % 30 == 0) + JA_PlaySound(mSoundClock, false); + } + else + { + if (mTimeStoppedCounter % 15 == 0) + JA_PlaySound(mSoundClock, false); + } + } + + // D E M O + if (mDemo.enabled) + if (mDemo.counter % 30 > 14) + mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, mLang->getText(37), 0, noColor, 2, shdwTxtColor); + + // STAGE NUMBER + if (mStageBitmapCounter < STAGE_COUNTER) + { + std::string text = mLang->getText(38) + std::to_string(mStage[mCurrentStage].number); + if (!mGameCompleted) + { + mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, mStageBitmapPath[mStageBitmapCounter], text, -2, noColor, 2, shdwTxtColor); + } + else + { // Texto de juego completado + text = mLang->getText(50); + mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, mStageBitmapPath[mStageBitmapCounter], text, -2, noColor, 1, shdwTxtColor); + mTextNokiaBig2->writeDX(TXT_CENTER, PLAY_AREA_CENTER_X, mStageBitmapPath[mStageBitmapCounter] + mTextNokiaBig2->getCharacterWidth() + 2, mLang->getText(76), -1, noColor, 1, shdwTxtColor); + } + } +} + +// Habilita el efecto del item de detener el tiempo +void Game::enableTimeStopItem() +{ + stopAllBalloons(TIME_STOPPED_COUNTER); + setTimeStopped(true); + incTimeStoppedCounter(TIME_STOPPED_COUNTER); + if (JA_GetMusicState() == JA_MUSIC_PLAYING) + JA_PauseMusic(); +} + +// Deshabilita el efecto del item de detener el tiempo +void Game::disableTimeStopItem() +{ + mTimeStopped = false; + setTimeStoppedCounter(0); + startAllBalloons(); + if (JA_GetMusicState() == JA_MUSIC_PAUSED) + JA_ResumeMusic(); +} + +// Agita la pantalla +void Game::shakeScreen() +{ + const int v[] = {-1, 1, -1, 1, -1, 1, -1, 0}; + for (int n = 0; n < 8; n++) + { + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + mSpriteBackground->setPosX(0); + mSpriteBackground->setWidth(1); + mSpriteBackground->setSpriteClip(0, 0, 1, 192); + renderBackground(); + + mSpriteBackground->setPosX(255); + mSpriteBackground->setSpriteClip(255, 0, 1, 192); + mSpriteBackground->render(); + + mSpriteBackground->setPosX(v[n]); + mSpriteBackground->setWidth(256); + mSpriteBackground->setSpriteClip(0, 0, 256, 192); + mSpriteBackground->render(); + + mSpriteGrass->render(); + renderBalloons(); + renderBullets(); + renderItems(); + for (int i = 0; i < mNumPlayers; i++) + mPlayer[i]->render(); + renderScoreBoard(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + SDL_Delay(50); + } +} + +// Bucle para el juego +section_t Game::run() +{ + init(); + + while (mSection.name == PROG_SECTION_GAME) + { + // Sección juego en pausa + if (mSection.subsection == GAME_SECTION_PAUSE) + runPausedGame(); + + // Sección Game Over + if (mSection.subsection == GAME_SECTION_GAMEOVER) + runGameOverScreen(); + + // Sección juego jugando + if ((mSection.subsection == GAME_SECTION_PLAY_1P) || (mSection.subsection == GAME_SECTION_PLAY_2P)) + { + // Si la música no está sonando + if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) + { + // Reproduce la música + if (!mGameCompleted) + if (mPlayer[0]->isAlive()) + JA_PlayMusic(mMusicPlaying); + } + + // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + // Actualiza el contador de juego + mCounter++; + + // Comprueba los eventos que hay en la cola + while (SDL_PollEvent(mEventHandler) != 0) + { + // Evento de salida de la aplicación + if (mEventHandler->type == SDL_QUIT) + { + mSection.name = PROG_SECTION_QUIT; + break; + } + } + + // Actualiza la lógica del juego + updatePlayField(); + } + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + renderPlayField(); + + // Pinta la informacion de debug + renderDebugInfo(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + } + } + + return mSection; +} + +// Bucle para el menu de pausa del juego +void Game::runPausedGame() +{ + // Reinicia el menu + mMenuPause->reset(); + + while ((mSection.subsection == GAME_SECTION_PAUSE) && (mSection.name == PROG_SECTION_GAME)) + { + // Comprueba los eventos que hay en la cola + while (SDL_PollEvent(mEventHandler) != 0) + { + // Evento de salida de la aplicación + if (mEventHandler->type == SDL_QUIT) + { + mSection.name = PROG_SECTION_QUIT; + break; + } + } + + // Calcula la lógica de los objetos + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + // Actualiza la lógica del menu + mMenuPause->update(); + mFade->update(); + if (mFade->hasEnded()) + { + mSection.name = PROG_SECTION_TITLE; + mSection.subsection = TITLE_SECTION_1; + JA_StopMusic(); + break; + } + } + + // Dibuja los objetos + //renderBackground(); + //renderBalloons(); + //renderBullets(); + //for (int i = 0; i < mNumPlayers; i++) + // mPlayer[i]->render(); + //renderScoreBoard(); + renderPlayField(); + mMenuPause->render(); + mFade->render(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba las entradas para el menu + mMenuPause->checkInput(); + + // Comprueba si se ha seleccionado algún item del menú + switch (mMenuPause->getItemSelected()) + { + case 0: + //mMenuPause->reset(); + mSection.name = PROG_SECTION_GAME; + if (mNumPlayers == 1) + mSection.subsection = GAME_SECTION_PLAY_1P; + else + mSection.subsection = GAME_SECTION_PLAY_2P; + if (JA_GetMusicState() == JA_MUSIC_PAUSED) + JA_ResumeMusic(); + break; + + case 1: + //mMenuPause->reset(); + mFade->setFadeType(FADE_CENTER); + mFade->activateFade(); + break; + + default: + break; + } + } +} + +// Bucle para la pantalla de game over +void Game::runGameOverScreen() +{ + // Guarda los puntos + saveScoreFile(); + + // Reinicia el menu + mMenuGameOver->reset(); + + while ((mSection.subsection == GAME_SECTION_GAMEOVER) && (mSection.name == PROG_SECTION_GAME)) + { + // Comprueba los eventos que hay en la cola + while (SDL_PollEvent(mEventHandler) != 0) + { + // Evento de salida de la aplicación + if (mEventHandler->type == SDL_QUIT) + { + mSection.name = PROG_SECTION_QUIT; + break; + } + } + + // Calcula la lógica de los objetos + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + // Actualiza la lógica del menu + mMenuGameOver->update(); + mFade->update(); + if (mFade->hasEnded()) + { + switch (mPostFade) + { + case 0: // YES + mSection.name = PROG_SECTION_GAME; + if (mNumPlayers == 1) + mSection.subsection = GAME_SECTION_PLAY_1P; + else + mSection.subsection = GAME_SECTION_PLAY_2P; + init(); + break; + + case 1: // NO + mSection.name = PROG_SECTION_TITLE; + mSection.subsection = TITLE_SECTION_1; + break; + + default: + break; + } + + break; + } + } + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + if (mNumPlayers == 1) + { + mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 4), mLang->getText(43)); + mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 1), mLang->getText(44) + std::to_string(mPlayer[0]->getScore())); + } + else + { + mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 36, mLang->getText(43)); + mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 12, mLang->getText(77) + std::to_string(mPlayer[0]->getScore())); + mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y, mLang->getText(78) + std::to_string(mPlayer[1]->getScore())); + } + mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y + BLOCK * 2, mLang->getText(45)); + mMenuGameOver->render(); + mFade->render(); + + // Muestra la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba las entradas para el menu + mMenuGameOver->checkInput(); + + // Comprueba si se ha seleccionado algún item del menú + switch (mMenuGameOver->getItemSelected()) + { + case 0: // YES + mPostFade = 0; + mFade->activateFade(); + break; + + case 1: // NO + mPostFade = 1; + mFade->activateFade(); + break; + + default: + break; + } + } +} + +// Dibuja la informacion de debug en pantalla +void Game::renderDebugInfo() +{ + const color_t color = {0xFF, 0x20, 0x20}; + //mText->writeShadowed(2, 2 + 0 * BLOCK, "POW: " + std::to_string(mPlayer[0]->mPowerUpCounter), color); + //if (mHelper.needCoffeeMachine) + // mText->writeShadowed(2, 2 + 1 * BLOCK, "NEED COFFEMACHINE", color); + + if (mDebug.enabled) + { + //SDL_RenderSetLogicalSize(mRenderer, SCREEN_WIDTH * 2, SCREEN_HEIGHT * 2); + mText->writeShadowed(2, 2 + 0 * BLOCK, "menace(umb): " + std::to_string(mMenaceCurrent) + "(" + std::to_string(mMenaceThreshold) + ")", color); + mText->writeShadowed(2, 2 + 1 * BLOCK, "currentPower: " + std::to_string(mStage[mCurrentStage].currentPower), color); + mText->writeShadowed(2, 2 + 2 * BLOCK, "mCurrentStage:" + std::to_string(mCurrentStage), color); + mText->writeShadowed(2, 2 + 3 * BLOCK, "mCounter: " + std::to_string(mCounter), color); + mText->writeShadowed(2, 2 + 4 * BLOCK, "(R)enemyset: " + std::to_string(mDebug.enemySet), color); + mText->writeShadowed(2, 2 + 5 * BLOCK, "RGB: " + std::to_string(mDebug.gradR) + "," + std::to_string(mDebug.gradG) + "," + std::to_string(mDebug.gradB), color); + mText->writeShadowed(2, 2 + 6 * BLOCK, "(I)invuln: " + std::to_string(mPlayer[0]->getInvulnerableCounter()), color); + mText->writeShadowed(2, 2 + 7 * BLOCK, "balloons: " + std::to_string(countBalloons()), color); + mText->writeShadowed(2, 2 + 8 * BLOCK, "balloonsPop: " + std::to_string(mBalloonsPopped), color); + mText->writeShadowed(2, 2 + 9 * BLOCK, "(Z-X)ballSped:" + std::to_string(mEnemySpeed), color); + mText->writeShadowed(2, 2 + 10 * BLOCK, "EGcounter: " + std::to_string(mGameCompletedCounter), color); + } +} + +// Indica si se puede crear una powerball +bool Game::canPowerBallBeCreated() +{ + if ((!mPowerBallEnabled) && (calculateScreenPower() > POWERBALL_SCREENPOWER_MINIMUM) && (mPowerBallCounter == 0)) + return true; + else + return false; +} + +// Calcula el poder actual de los globos en pantalla +int Game::calculateScreenPower() +{ + int power = 0; + + for (int i = 0; i < MAX_BALLOONS; i++) + if (mBalloon[i]->isEnabled()) + power += mBalloon[i]->getPower(); + + return power; +} + +// Inicializa las variables que contienen puntos de ruta para mover objetos +void Game::initPaths() +{ + // Letrero de STAGE # + const int firstPart = STAGE_COUNTER / 4; // 50 + const int secondPart = firstPart * 3; // 150 + const int centerPoint = PLAY_AREA_CENTER_Y - (BLOCK * 2); + const int distance = (PLAY_AREA_BOTTOM) - (PLAY_AREA_CENTER_Y - 16); + + for (int i = 0; i < STAGE_COUNTER; i++) + { + if (i < firstPart) + mStageBitmapPath[i] = (mSin[(int)((i * 1.8f) + 90)] * (distance) + centerPoint); + else if (i < secondPart) + mStageBitmapPath[i] = (int)centerPoint; + else + mStageBitmapPath[i] = (mSin[(int)(((i - 149) * 1.8f) + 90)] * (centerPoint + 17) - 17); + } + + // Letrero de GetReady + const int size = mTextNokiaBig2->lenght(mLang->getText(75), -2); + + const float start1 = PLAY_AREA_LEFT - size; + const float finish1 = PLAY_AREA_CENTER_X - (size / 2); + + const float start2 = finish1; + const float finish2 = PLAY_AREA_RIGHT; + + const float distance1 = finish1 - start1; + const float distance2 = finish2 - start2; + + for (int i = 0; i < STAGE_COUNTER; i++) + { + if (i < firstPart) + { + mGetReadyBitmapPath[i] = mSin[(int)(i * 1.8f)]; + mGetReadyBitmapPath[i] *= distance1; + mGetReadyBitmapPath[i] -= size; + } + else if (i < secondPart) + mGetReadyBitmapPath[i] = (int)finish1; + else + { + mGetReadyBitmapPath[i] = mSin[(int)((i - 150) * 1.8f)]; + mGetReadyBitmapPath[i] *= distance2; + mGetReadyBitmapPath[i] += finish1; + } + } +} + +// Actualiza el tramo final de juego, una vez completado +void Game::updateGameCompleted() +{ + if (mGameCompleted) + mGameCompletedCounter++; + + if (mGameCompletedCounter == 500) + mSection.subsection = GAME_SECTION_GAMEOVER; +} + +// Actualiza las variables de ayuda +void Game::updateHelper() +{ + // El ayudante solo funciona para un jugador + // Solo ofrece ayuda cuando la amenaza o la velocidad es elevada + if (mMenaceCurrent > 15) + { + if (mPlayer[0]->getCoffees() == 0) + mHelper.needCoffee = true; + else + mHelper.needCoffee = false; + + if (!mPlayer[0]->isPowerUp()) + mHelper.needCoffeeMachine = true; + else + mHelper.needCoffeeMachine = false; + } + else + { + mHelper.needCoffee = false; + mHelper.needCoffeeMachine = false; + } +} + +// Comprueba si todos los jugadores han muerto +bool Game::allPlayersAreDead() +{ + bool success = true; + for (int i = 0; i < mNumPlayers; i++) + success &= (!mPlayer[i]->isAlive()); + + return success; +} \ No newline at end of file diff --git a/source/game.h b/source/game.h new file mode 100644 index 0000000..14aac9d --- /dev/null +++ b/source/game.h @@ -0,0 +1,512 @@ +#pragma once +#include "ifdefs.h" +#include "const.h" +#include "utils.h" + +#include "sprite.h" +#include "movingsprite.h" +#include "smartsprite.h" + +#include "player.h" +#include "balloon.h" +#include "bullet.h" +#include "item.h" + +#include "text.h" +#include "writer.h" +#include "menu.h" +#include "input.h" +#include "fade.h" +#include "jail_audio.h" + +#ifndef GAME_H +#define GAME_H + +// Game +class Game +{ +private: + struct enemyInits_t + { + int x; // Posición en el eje X donde crear al enemigo + int y; // Posición en el eje Y donde crear al enemigo + float velX; // Velocidad inicial en el eje X + Uint8 kind; // Tipo de enemigo + Uint16 creationCounter; // Temporizador para la creación del enemigo + }; + + struct enemyFormation_t // Contiene la información de una formación enemiga + { + Uint8 numberOfEnemies; // Cantidad de enemigos que forman la formación + enemyInits_t init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación + }; + enemyFormation_t mEnemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas + + struct enemyPool_t + { + enemyFormation_t *set[10]; // Conjunto de formaciones enemigas + }; + enemyPool_t mEnemyPool[10]; // Variable con los diferentes conjuntos de formaciones enemigas + + struct stage_t // Contiene todas las variables relacionadas con una fase + { + enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase + Uint16 currentPower; // Cantidad actual de poder + Uint16 powerToComplete; // Cantidad de poder que se necesita para completar la fase + Uint8 maxMenace; // Umbral máximo de amenaza de la fase + Uint8 minMenace; // Umbral mínimo de amenaza de la fase + Uint8 number; // Numero de fase + }; + + struct effect_t + { + bool flash; // Indica si se ha de pintar la pantalla de blanco + bool shake; // Indica si se ha de agitar la pantalla + Uint8 shakeCounter; // Contador para medir el tiempo que dura el efecto + }; + + struct helper_t + { + bool needCoffee; // Indica si se necesitan cafes + bool needCoffeeMachine; // Indica si se necesita PowerUp + bool needPowerBall; // Indica si se necesita una PowerBall + int counter; // Contador para no dar ayudas consecutivas + int itemPoints1Odds; // Probabilidad de aparición del objeto + int itemPoints2Odds; // Probabilidad de aparición del objeto + int itemPoints3Odds; // Probabilidad de aparición del objeto + int itemClockOdds; // Probabilidad de aparición del objeto + int itemCoffeeOdds; // Probabilidad de aparición del objeto + int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto + }; + + SDL_Renderer *mRenderer; // El renderizador de la ventana + std::string *mFileList; // Lista de ficheros con los recursos + Lang *mLang; // Objeto para gestionar los textos en diferentes idiomas + + int mNumPlayers; // Numero de jugadores + Player *mPlayer[2]; // Vector con los jugadores jugador + Input *mInput; // Manejador de entrada + + Balloon *mBalloon[MAX_BALLOONS]; // Vector con los objetos globo + Bullet *mBullet[MAX_BULLETS]; // Vector con los objetos bala + Item *mItem[MAX_ITEMS]; // Vector con los objetos item + SmartSprite *mSmartSprite[MAX_SMART_SPRITES]; // Vector para almacenar y gestionar SmartSprites + + LTexture *mTextureBalloon; // Textura para los enemigos + LTexture *mTextureBullet; // Textura para las balas + LTexture *mTextureGameBG; // Textura para el fondo del juego + LTexture *mTextureGameText; // Textura para los sprites con textos + LTexture *mTextureItems; // Textura para los items + LTexture *mTexturePlayer1Head; // Textura para la cabeza del jugador1 + LTexture *mTexturePlayer1Body; // Textura para el cuerpo del jugador1 + LTexture *mTexturePlayer1Death; // Textura para la animación de muerte del jugador1 + LTexture *mTexturePlayer1Legs; // Textura para las piernas del jugador + LTexture *mTexturePlayer2Head; // Textura para la cabeza del jugador2 + LTexture *mTexturePlayer2Body; // Textura para el cuerpo del jugador2 + LTexture *mTexturePlayer2Death; // Textura para la animación de muerte del jugador2 + LTexture *mTexturePlayer2Legs; // Textura para las piernas del jugador + LTexture *mTextureText; // Textura para el texto del juego + LTexture *mTextureTextScoreBoard; // Textura para el texto del marcador + LTexture *mTextureTextBig; // Textura para el texto grande + LTexture *mTextureTextNokia2; // Textura para la fuente de texto Nokia + LTexture *mTextureTextNokiaBig2; // Textura para la fuente de texto Nokia grande + + Text *mText; // Fuente para los textos del juego + Text *mTextBig; // Fuente de texto grande + Text *mTextScoreBoard; // Fuente para el marcador del juego + Text *mTextNokia2; // Otra fuente de texto para mesajes + Text *mTextNokiaBig2; // Y la versión en grande + + Menu *mMenuGameOver; // Menú de la pantalla de game over + Menu *mMenuPause; // Menú de la pantalla de pausa + + Fade *mFade; // Objeto para renderizar fades + SDL_Event *mEventHandler; // Manejador de eventos + + MovingSprite *mClouds1a; // Sprite para las nubes superiores + MovingSprite *mClouds1b; // Sprite para las nubes superiores + MovingSprite *mClouds2a; // Sprite para las nubes inferiores + MovingSprite *mClouds2b; // Sprite para las nubes inferiores + SmartSprite *m1000Bitmap; // Sprite con el texto 1.000 + SmartSprite *m2500Bitmap; // Sprite con el texto 2.500 + SmartSprite *m5000Bitmap; // Sprite con el texto 5.000 + Sprite *mSpriteBackground; // Sprite con los graficos frontales del fondo + Sprite *mSpriteGetReady; // Sprite para el texto de GetReady del principio de la partida + Sprite *mSpriteGradient; // Sprite con los graficos del degradado de color de fondo + Sprite *mSpriteGrass; // Sprite para la hierba + Sprite *mSpritePowerMeter; // Sprite para el medidor de poder de la fase + Sprite *mSpriteScoreBoard; // Sprite para el fondo del marcador + + JA_Sound mSoundBalloon; // Sonido para la explosión del globo + JA_Sound mSoundBullet; // Sonido para los disparos + JA_Sound mSoundPlayerCollision; // Sonido para la colisión del jugador con un enemigo + JA_Sound mSoundHiScore; // Sonido para cuando se alcanza la máxima puntuación + JA_Sound mSoundItemDrop; // Sonido para cuando se genera un item + JA_Sound mSoundItemPickup; // Sonido para cuando se recoge un item + JA_Sound mSoundCoffeeOut; // Sonido para cuando el jugador pierde el café al recibir un impacto + JA_Sound mSoundStageChange; // Sonido para cuando se cambia de fase + JA_Sound mSoundBubble1; // Sonido para cuando el jugador muere + JA_Sound mSoundBubble2; // Sonido para cuando el jugador muere + JA_Sound mSoundBubble3; // Sonido para cuando el jugador muere + JA_Sound mSoundBubble4; // Sonido para cuando el jugador muere + JA_Sound mSoundClock; // Sonido para cuando se detiene el tiempo con el item reloj + JA_Sound mSoundPowerBall; // Sonido para cuando se explota una Power Ball + JA_Sound mSoundCollision; // Sonido para cuando la máquina de café toca el suelo + + JA_Music mMusicPlaying; // Musica de fondo + + Uint32 mTicks; // Contador de ticks para ajustar la velocidad del programa + Uint8 mTicksSpeed; // Velocidad a la que se repiten los bucles del programa + + Uint32 mHiScore; // Puntuación máxima + bool mHiScoreAchieved; // Indica si se ha superado la puntuación máxima + section_t mSection; // Seccion actual dentro del juego + stage_t mStage[10]; // Variable con los datos de cada pantalla + Uint8 mCurrentStage; // Indica la fase actual + Uint8 mStageBitmapCounter; // Contador para el tiempo visible del texto de Stage + float mStageBitmapPath[STAGE_COUNTER]; // Vector con los puntos Y por donde se desplaza el texto + float mGetReadyBitmapPath[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto + Uint16 mDeathCounter; // Contador para la animación de muerte del jugador + Uint8 mDeathIndex; // Indice del vector de smartsprites que contiene el sprite del jugador + Uint8 mMenaceCurrent; // Nivel de amenaza actual + Uint8 mMenaceThreshold; // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el numero de globos + bool mTimeStopped; // Indica si el tiempo está detenido + Uint16 mTimeStoppedCounter; // Temporizador para llevar la cuenta del tiempo detenido + Uint8 mRemainingExplosions; // Cantidad de explosiones restantes + Uint16 mRemainingExplosionsCounter; // Temporizador para la cantidad de explosiones restantes + bool mExplosionTime; // Indica si las explosiones estan en marcha + Uint32 mCounter; // Contador para el juego + Uint32 mScoreDataFile[TOTAL_SCORE_DATA]; // Datos del fichero de puntos + SDL_Rect mGradientRect[4]; // Vector con las coordenadas de los 4 gradientes + Uint16 mBalloonsPopped; // Lleva la cuenta de los globos explotados + Uint8 mLastEnemyDeploy; // Guarda cual ha sido la última formación desplegada para no repetir; + Uint8 mEnemyDeployCounter; // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero + float mEnemySpeed; // Velocidad a la que se mueven los enemigos + float mDefaultEnemySpeed; // Velocidad base de los enemigos, sin incrementar + effect_t mEffect; // Variable para gestionar los efectos visuales + helper_t mHelper; // Variable para gestionar las ayudas + bool mPowerBallEnabled; // Indica si hay una powerball ya activa + Uint8 mPowerBallCounter; // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra + bool mCoffeeMachineEnabled; // Indica si hay una máquina de café en el terreno de juego + Uint8 mPostFade; // Qué hacer al acabar el fade + float mSin[360]; // Vector con los valores del seno para 360 grados + bool mGameCompleted; // Indica si se ha completado la partida, llegando al final de la ultima pantalla + int mGameCompletedCounter; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos + Uint8 mDifficulty; // Dificultad del juego + float mDifficultyScoreMultiplier; // Multiplicador de puntos en función de la dificultad + struct options_t *mOptions; // Variable con todas las variables de las opciones del programa + Uint8 mOnePlayerControl; // Variable para almacenar el valor de las opciones + + struct demo_t + { + bool enabled; // Indica si está activo el modo demo + bool recording; // Indica si está activado el modo para grabar la demo + Uint16 counter; // Contador para el modo demo + demoKeys_t keys; // Variable con las pulsaciones de teclas del modo demo + demoKeys_t dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo + }; + demo_t mDemo; // Variable con todas las variables relacionadas con el modo demo + + struct debug_t + { + bool enabled; // Indica si se va a mostrar la información de debug + Uint8 enemySet; // Escoge el set enemigo a generar + Uint8 gradR, gradG, gradB; // Colores RGB para modificar el color del gradiente de fondo + float hudW, hudH; // Multiplica el tamaño del hud de debug; + }; + debug_t mDebug; + + // Inicializa el vector con los valores del seno + void initSin(); + + // Inicializa las variables necesarias para la sección 'Game' + void init(); + + // Carga los recursos necesarios para la sección 'Game' + bool loadMedia(); + + // Carga el fichero de puntos + bool loadScoreFile(); + + // Carga el fichero de datos para la demo + bool loadDemoFile(); + + // Guarda el fichero de puntos + bool saveScoreFile(); + + // Guarda el fichero de datos para la demo + bool saveDemoFile(); + + // Inicializa las formaciones enemigas + void initEnemyFormations(); + + // Inicializa los conjuntos de formaciones + void initEnemyPools(); + + // Inicializa las fases del juego + void initGameStages(); + + // Crea una formación de enemigos + void deployEnemyFormation(); + + // Aumenta el poder de la fase + void increaseStageCurrentPower(Uint8 power); + + // Establece el valor de la variable + void setHiScore(Uint32 score); + + // Actualiza el valor de HiScore en caso necesario + void updateHiScore(); + + // Transforma un valor numérico en una cadena de 6 cifras + std::string updateScoreText(Uint32 num); + + // Pinta el marcador en pantalla usando un objeto texto + void renderScoreBoard(); + + // Actualiza las variables del jugador + void updatePlayer(); + + // Actualiza las variables de la fase + void updateStage(); + + // Actualiza el estado de muerte + void updateDeath(); + + // Renderiza el fade final cuando se acaba la partida + void renderDeathFade(int counter); + + // Actualiza los globos + void updateBalloons(); + + // Pinta en pantalla todos los globos activos + void renderBalloons(); + + // Devuelve el primer indice no activo del vector de globos + Uint8 getBalloonFreeIndex(); + + // Crea un globo nuevo en el vector de globos + Uint8 createNewBalloon(float x, int y, Uint8 kind, float velx, float speed, Uint16 stoppedcounter, LTexture *texture); + + // Crea una PowerBall + void createPowerBall(); + + // Establece a cero todos los valores del vector de objetos globo + void resetBalloons(); + + // Establece la velocidad de los globos + void setBalloonSpeed(float speed); + + // Incrementa la velocidad de los globos + void incBalloonSpeed(); + + // Decrementa la velocidad de los globos + void decBalloonSpeed(); + + // Actualiza la velocidad de los globos en funcion del poder acumulado de la fase + void updateBalloonSpeed(); + + // Explosiona un globo. Lo destruye y crea otros dos si es el caso + void popBalloon(Uint8 index); + + // Explosiona un globo. Lo destruye + void destroyBalloon(Uint8 index); + + // Explosiona todos los globos + void popAllBalloons(); + + // Destruye todos los globos + void destroyAllBalloons(); + + // Detiene todos los globos + void stopAllBalloons(Uint16 time); + + // Pone en marcha todos los globos + void startAllBalloons(); + + // Obtiene el numero de globos activos + Uint8 countBalloons(); + + // Comprueba la colisión entre el jugador y los globos activos + bool checkPlayerBalloonCollision(int index); + + // Comprueba la colisión entre el jugador y los items + void checkPlayerItemCollision(int index); + + // Comprueba la colisión entre las balas y los globos + void checkBulletBalloonCollision(); + + // Mueve las balas activas + void moveBullets(); + + // Pinta las balas activas + void renderBullets(); + + // Devuelve el primer indice no activo del vector de balas + Uint8 getBulletFreeIndex(); + + // Establece a cero todos los valores del vector de objetos bala + void resetBullets(); + + // Crea un objeto bala + void createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner); + + // Actualiza los items + void updateItems(); + + // Pinta los items activos + void renderItems(); + + // Devuelve el primer indice no activo del vector de items + Uint8 getItemFreeIndex(); + + // Establece a cero todos los valores del vector de objetos item + void resetItems(); + + // Devuelve un item en función del azar + Uint8 dropItem(); + + // Crea un objeto item + void createItem(int x, int y, Uint8 kind); + + // Crea un objeto SmartSprite + void createItemScoreSprite(int x, int y, SmartSprite *sprite); + + // Dibuja el efecto de flash + void renderFlashEffect(); + + // Actualiza el efecto de agitar la pantalla + void updateShakeEffect(); + + // Crea un SmartSprite para arrojar el item café al recibir un impacto + void throwCoffee(int x, int y); + + // Crea un SmartSprite para arrojar al jugador al morir + void throwPlayer(int x, int y, int index); + + // Actualiza los SmartSprites + void updateSmartSprites(); + + // Pinta los SmartSprites activos + void renderSmartSprites(); + + // Devuelve el primer indice no activo del vector de SmartSprites + Uint8 getSmartSpriteFreeIndex(); + + // Establece a cero todos los valores del vector de objetos SmafrtSprite + void resetSmartSprites(); + + // Acciones a realizar cuando el jugador muere + void killPlayer(int index); + + // Obtiene el valor de la variable + Uint8 getSubsection(); + + // Calcula y establece el valor de amenaza en funcion de los globos activos + void evaluateAndSetMenace(); + + // Obtiene el valor de la variable + Uint8 getMenace(); + + // Establece el valor de la variable + void setTimeStopped(bool value); + + // Obtiene el valor de la variable + bool isTimeStopped(); + + // Establece el valor de la variable + void setTimeStoppedCounter(Uint16 value); + + // Incrementa el valor de la variable + void incTimeStoppedCounter(Uint16 value); + + // Actualiza la variable EnemyDeployCounter + void updateEnemyDeployCounter(); + + // Actualiza y comprueba el valor de la variable + void updateTimeStoppedCounter(); + + // Establece el valor de la variable + void setExplosionTime(bool value); + + // Obtiene el valor de la variable + bool isExplosionTime(); + + // Establece el valor de la variable + void setRemainingExplosions(Uint8 value); + + // Actualiza y comprueba el valor de la variable + void updateRemainingExplosionsCounter(); + + // Gestiona el nivel de amenaza + void updateMenace(); + + // Actualiza el campo de juego + void updatePlayField(); + + // Actualiza el fondo + void updateBackground(); + + // Dibuja el fondo + void renderBackground(); + + // Dibuja el campo de juego + void renderPlayField(); + + // Gestiona las entradas desde el mando de juego + bool checkGameController(Uint8 state); + + // Gestiona la entrada durante el juego + void checkGameInput(); + + // Pinta diferentes mensajes en la pantalla + void renderMessages(); + + // Habilita el efecto del item de detener el tiempo + void enableTimeStopItem(); + + // Deshabilita el efecto del item de detener el tiempo + void disableTimeStopItem(); + + // Agita la pantalla + void shakeScreen(); + + // Bucle para el menu de pausa del juego + void runPausedGame(); + + // Bucle para la pantalla de game over + void runGameOverScreen(); + + // Dibuja la informacion de debug en pantalla + void renderDebugInfo(); + + // Indica si se puede crear una powerball + bool canPowerBallBeCreated(); + + // Calcula el poder actual de los globos en pantalla + int calculateScreenPower(); + + // Inicializa las variables que contienen puntos de ruta para mover objetos + void initPaths(); + + // Actualiza el tramo final de juego, una vez completado + void updateGameCompleted(); + + // Actualiza las variables de ayuda + void updateHelper(); + + // Comprueba si todos los jugadores han muerto + bool allPlayersAreDead(); + +public: + // Constructor + Game(int numPlayers, SDL_Renderer *renderer, std::string *filelist, Lang *lang, Input *input, bool demo, options_t *options); + + // Destructor + ~Game(); + + // Bucle para el juego + section_t run(); +}; + +#endif diff --git a/source/ifdefs.h b/source/ifdefs.h new file mode 100644 index 0000000..d5a071e --- /dev/null +++ b/source/ifdefs.h @@ -0,0 +1,22 @@ +#ifdef _WIN64 +#include "C:\Program Files\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\lib\gcc\x86_64-w64-mingw32\8.1.0\include\c++\SDL2\SDL.h" +#endif + +#ifdef _WIN32 +#include "C:\Program Files\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\lib\gcc\x86_64-w64-mingw32\8.1.0\include\c++\SDL2\SDL.h" +#endif + +#ifdef __APPLE__ +//#include "/Library/Frameworks/SDL2.framework/Versions/A/Headers/SDL.h" +#include +#endif + +#ifdef __linux__ +#ifdef __MIPSEL__ +#include "SDL.h" +#else +#include +#endif +#endif + +#define UNUSED \ No newline at end of file diff --git a/source/input.cpp b/source/input.cpp new file mode 100644 index 0000000..dc8b705 --- /dev/null +++ b/source/input.cpp @@ -0,0 +1,209 @@ +#include "input.h" +#include + +// Contestar cuantos joystics ha detectado +// Preguntarlepor los joystics que ha encontrado para ir poniendolos en la variable de opciones + +// Constructor +Input::Input(std::string file) +{ + // Fichero gamecontrollerdb.txt + mDBpath = file; + + // Inicializa las variables + for (int i = 0; i < 17; i++) + { + mKeyBindings[i].scancode = 0; + mKeyBindings[i].active = false; + + mGameControllerBindings[i].button = SDL_CONTROLLER_BUTTON_INVALID; + mGameControllerBindings[i].active = false; + } + + discoverGameController(); +} + +// Destructor +Input::~Input() +{ + for (int i = 0; i < mNumGamepads; i++) + mConnectedControllers[i] = nullptr; +} + +// Asigna uno de los posibles inputs a una tecla del teclado +void Input::bindKey(Uint8 input, SDL_Scancode code) +{ + mKeyBindings[input].scancode = code; +} + +// Asigna uno de los posibles inputs a un botón del mando +void Input::bindGameControllerButton(Uint8 input, SDL_GameControllerButton button) +{ + mGameControllerBindings[input].button = button; +} + +// Comprueba si un input esta activo +bool Input::checkInput(Uint8 input, bool repeat, int device, int index) +{ + bool successKeyboard = false; + bool successGameController = false; + + if (device == INPUT_USE_ANY) + index = 0; + + if ((device == INPUT_USE_KEYBOARD) || (device == INPUT_USE_ANY)) + { + const Uint8 *mKeystates = SDL_GetKeyboardState(NULL); + + if (repeat) + { + if (mKeystates[mKeyBindings[input].scancode] != 0) + successKeyboard = true; + else + successKeyboard = false; + } + else + { + if (!mKeyBindings[input].active) + { + if (mKeystates[mKeyBindings[input].scancode] != 0) + { + mKeyBindings[input].active = true; + successKeyboard = true; + } + else + { + successKeyboard = false; + } + } + else + { + if (mKeystates[mKeyBindings[input].scancode] == 0) + { + mKeyBindings[input].active = false; + successKeyboard = false; + } + else + { + successKeyboard = false; + } + } + } + } + + if (gameControllerFound()) + if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) + { + if (repeat) + { + if (SDL_GameControllerGetButton(mConnectedControllers[index], mGameControllerBindings[input].button) != 0) + successGameController = true; + else + successGameController = false; + } + else + { + if (!mGameControllerBindings[input].active) + { + if (SDL_GameControllerGetButton(mConnectedControllers[index], mGameControllerBindings[input].button) != 0) + { + mGameControllerBindings[input].active = true; + successGameController = true; + } + else + { + successGameController = false; + } + } + else + { + if (SDL_GameControllerGetButton(mConnectedControllers[index], mGameControllerBindings[input].button) == 0) + { + mGameControllerBindings[input].active = false; + successGameController = false; + } + else + { + successGameController = false; + } + } + } + } + + return (successKeyboard || successGameController); +} + +// Comprueba si hay un mando conectado +bool Input::discoverGameController() +{ + bool found = false; + + if (SDL_WasInit(SDL_INIT_GAMECONTROLLER) != 1) + SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER); + + if (SDL_GameControllerAddMappingsFromFile(mDBpath.c_str()) < 0) + printf("Error, could not load %s file: %s\n", mDBpath.c_str(), SDL_GetError()); + + int nJoysticks = SDL_NumJoysticks(); + mNumGamepads = 0; + + // Cuenta el numero de mandos + for (int i = 0; i < nJoysticks; i++) + if (SDL_IsGameController(i)) + mNumGamepads++; + + printf("\nChecking for game controllers...\n"); + printf("%i joysticks found, %i are gamepads\n", nJoysticks, mNumGamepads); + + if (mNumGamepads > 0) + { + found = true; + + for (int i = 0; i < mNumGamepads; i++) + { + // Abre el mando y lo añade a la lista + SDL_GameController *pad = SDL_GameControllerOpen(i); + if (SDL_GameControllerGetAttached(pad) == 1) + { + mConnectedControllers.push_back(pad); + std::string separator(" #"); + std::string name = SDL_GameControllerNameForIndex(i); + name.resize(25); + name = name + separator + std::to_string(i); + std::cout << name << std::endl; + mControllerNames.push_back(name); + } + else + std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl; + } + + //mGameController = mConnectedControllers[0]; + SDL_GameControllerEventState(SDL_ENABLE); + } + + return found; +} + +// Comprueba si hay algun mando conectado +bool Input::gameControllerFound() +{ + if (mNumGamepads > 0) + return true; + else + return false; +} + +// Obten el nombre de un mando de juego +std::string Input::getControllerName(int index) +{ + if (mNumGamepads > 0) + return mControllerNames[index]; + else + return ""; +} + +// Obten el numero de mandos conectados +int Input::getNumControllers() +{ + return mNumGamepads; +} \ No newline at end of file diff --git a/source/input.h b/source/input.h new file mode 100644 index 0000000..bea512b --- /dev/null +++ b/source/input.h @@ -0,0 +1,87 @@ +#pragma once +#include "ifdefs.h" +#include +#include + +#ifndef INPUT_H +#define INPUT_H + +#define INPUT_NULL 0 +#define INPUT_UP 1 +#define INPUT_DOWN 2 +#define INPUT_LEFT 3 +#define INPUT_RIGHT 4 +#define INPUT_ACCEPT 5 +#define INPUT_CANCEL 6 +#define INPUT_BUTTON_1 7 +#define INPUT_BUTTON_2 8 +#define INPUT_BUTTON_3 9 +#define INPUT_BUTTON_4 10 +#define INPUT_BUTTON_5 11 +#define INPUT_BUTTON_6 12 +#define INPUT_BUTTON_7 13 +#define INPUT_BUTTON_8 14 +#define INPUT_BUTTON_PAUSE 15 +#define INPUT_BUTTON_ESCAPE 16 + +#define REPEAT_TRUE true +#define REPEAT_FALSE false + +#define INPUT_USE_KEYBOARD 0 +#define INPUT_USE_GAMECONTROLLER 1 +#define INPUT_USE_ANY 2 + +// Clase Input +class Input +{ +private: + struct keyBindings_t + { + Uint8 scancode; // Scancode asociado + bool active; // Indica si está activo + }; + keyBindings_t mKeyBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos + + struct GameControllerBindings_t + { + SDL_GameControllerButton button; // GameControllerButton asociado + bool active; // Indica si está activo + }; + GameControllerBindings_t mGameControllerBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos + + //SDL_GameController *mGameController; // Manejador para el mando + std::vector mConnectedControllers; + std::vector mControllerNames; + int mNumGamepads; + std::string mDBpath; // Ruta al archivo gamecontrollerdb.txt + + // Comprueba si hay un mando conectado + bool discoverGameController(); + +public: + // Constructor + Input(std::string file); + + // Destructor + ~Input(); + + // Asigna uno de los posibles inputs a una tecla del teclado + void bindKey(Uint8 input, SDL_Scancode code); + + // Asigna uno de los posibles inputs a un botón del mando + void bindGameControllerButton(Uint8 input, SDL_GameControllerButton button); + + // Comprueba si un input esta activo + bool checkInput(Uint8 input, bool repeat, int device=INPUT_USE_ANY, int index=0); + + // Comprueba si hay algun mando conectado + bool gameControllerFound(); + + // Obten el numero de mandos conectados + int getNumControllers(); + + // Obten el nombre de un mando de juego + std::string getControllerName(int index); +}; + +#endif diff --git a/source/jail_audio.cpp b/source/jail_audio.cpp new file mode 100644 index 0000000..e22b355 --- /dev/null +++ b/source/jail_audio.cpp @@ -0,0 +1,213 @@ +#ifndef __MIPSEL__ +#include "jail_audio.h" +#include "stb_vorbis.c" + +#define JA_MAX_SIMULTANEOUS_CHANNELS 5 + +struct JA_Sound_t { + Uint32 length {0}; + Uint8* buffer {NULL}; +}; + +struct JA_Channel_t { + JA_Sound sound; + int pos {0}; + int times {0}; + JA_Channel_state state { JA_CHANNEL_FREE }; +}; + +struct JA_Music_t { + int samples {0}; + int pos {0}; + int times {0}; + short* output {NULL}; + JA_Music_state state {JA_MUSIC_INVALID}; +}; + +JA_Music current_music{NULL}; +JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS]; + +int JA_freq {48000}; +SDL_AudioFormat JA_format {AUDIO_S16}; +Uint8 JA_channels {2}; + +void audioCallback(void * userdata, uint8_t * stream, int len) { + SDL_memset(stream, 0, len); + if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) { + const int size = SDL_min(len, current_music->samples*2-current_music->pos); + SDL_memcpy(stream, current_music->output+current_music->pos, size); + current_music->pos += size/2; + if (size < len) { + if (current_music->times != 0) { + SDL_memcpy(stream+size, current_music->output, len-size); + current_music->pos = (len-size)/2; + if (current_music->times > 0) current_music->times--; + } else { + current_music->pos = 0; + current_music->state = JA_MUSIC_STOPPED; + } + } + } + // Mixar els channels mi amol + for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) { + if (channels[i].state == JA_CHANNEL_PLAYING) { + const int size = SDL_min(len, channels[i].sound->length - channels[i].pos); + SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, 64); + channels[i].pos += size; + if (size < len) { + if (channels[i].times != 0) { + SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, 64); + channels[i].pos = len-size; + if (channels[i].times > 0) channels[i].times--; + } else { + JA_StopChannel(i); + } + } + } + } +} + +void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) { + JA_freq = freq; + JA_format = format; + JA_channels = channels; + SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL}; + SDL_AudioDeviceID sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0); + SDL_PauseAudioDevice(sdlAudioDevice, 0); +} + +JA_Music JA_LoadMusic(const char* filename) { + int chan, samplerate; + JA_Music music = new JA_Music_t(); + music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output); + + SDL_AudioCVT cvt; + SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq); + cvt.len = music->samples * chan * 2; + cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult); + SDL_memcpy(cvt.buf, music->output, cvt.len); + SDL_ConvertAudio(&cvt); + free(music->output); + music->output = (short*)cvt.buf; + + music->pos = 0; + music->state = JA_MUSIC_STOPPED; + + return music; +} + +void JA_PlayMusic(JA_Music music, const int loop) { + if (current_music != NULL) { + current_music->pos = 0; + current_music->state = JA_MUSIC_STOPPED; + } + current_music = music; + current_music->pos = 0; + current_music->state = JA_MUSIC_PLAYING; + current_music->times = loop; +} + +void JA_PauseMusic() { + if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return; + current_music->state = JA_MUSIC_PAUSED; +} + +void JA_ResumeMusic() { + if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return; + current_music->state = JA_MUSIC_PLAYING; +} + +void JA_StopMusic() { + if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return; + current_music->pos = 0; + current_music->state = JA_MUSIC_STOPPED; +} + +JA_Music_state JA_GetMusicState() { + if (current_music == NULL) return JA_MUSIC_INVALID; + return current_music->state; +} + +void JA_DeleteMusic(JA_Music music) { + if (current_music == music) current_music = NULL; + SDL_free(music->output); + delete music; +} + +JA_Sound JA_LoadSound(const char* filename) { + JA_Sound sound = new JA_Sound_t(); + SDL_AudioSpec wavSpec; + SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length); + + SDL_AudioCVT cvt; + SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq); + cvt.len = sound->length; + cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult); + SDL_memcpy(cvt.buf, sound->buffer, sound->length); + SDL_ConvertAudio(&cvt); + SDL_FreeWAV(sound->buffer); + sound->buffer = cvt.buf; + sound->length = cvt.len_cvt; + + return sound; +} + +int JA_PlaySound(JA_Sound sound, const int loop) { + int channel = 0; + while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; } + if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0; + + channels[channel].sound = sound; + channels[channel].times = loop; + channels[channel].pos = 0; + channels[channel].state = JA_CHANNEL_PLAYING; + return channel; +} + +void JA_DeleteSound(JA_Sound sound) { + for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) { + if (channels[i].sound == sound) JA_StopChannel(i); + } + SDL_free(sound->buffer); + delete sound; +} + +void JA_PauseChannel(const int channel) { + if (channel == -1) { + for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) { + if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED; + } + } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) { + if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED; + } +} + +void JA_ResumeChannel(const int channel) { + if (channel == -1) { + for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) { + if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING; + } + } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) { + if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING; + } +} + +void JA_StopChannel(const int channel) { + if (channel == -1) { + for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) { + channels[i].state = JA_CHANNEL_FREE; + channels[i].pos = 0; + channels[i].sound = NULL; + } + } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) { + channels[channel].state = JA_CHANNEL_FREE; + channels[channel].pos = 0; + channels[channel].sound = NULL; + } +} + +JA_Channel_state JA_GetChannelState(const int channel) { + if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID; + return channels[channel].state; +} +#endif diff --git a/source/jail_audio.h b/source/jail_audio.h new file mode 100644 index 0000000..44b1d80 --- /dev/null +++ b/source/jail_audio.h @@ -0,0 +1,26 @@ +#pragma once +#include "ifdefs.h" + +enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED }; +enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED }; + +typedef struct JA_Sound_t *JA_Sound; +typedef struct JA_Music_t *JA_Music; + +void JA_Init(const int freq, const SDL_AudioFormat format, const int channels); + +JA_Music JA_LoadMusic(const char* filename); +void JA_PlayMusic(JA_Music music, const int loop = -1); +void JA_PauseMusic(); +void JA_ResumeMusic(); +void JA_StopMusic(); +JA_Music_state JA_GetMusicState(); +void JA_DeleteMusic(JA_Music music); + +JA_Sound JA_LoadSound(const char* filename); +int JA_PlaySound(JA_Sound sound, const int loop = 0); +void JA_PauseChannel(const int channel); +void JA_ResumeChannel(const int channel); +void JA_StopChannel(const int channel); +JA_Channel_state JA_GetChannelState(const int channel); +void JA_DeleteSound(JA_Sound sound); diff --git a/source/lang.cpp b/source/lang.cpp new file mode 100644 index 0000000..c739dd3 --- /dev/null +++ b/source/lang.cpp @@ -0,0 +1,73 @@ +#include "lang.h" +#include +#include + +// Constructor +Lang::Lang(std::string *fileList) +{ + mFileList = fileList; +} + +// Destructor +Lang::~Lang() +{ +} + +// Inicializa los textos del juego en el idioma seleccionado +bool Lang::setLang(Uint8 lang) +{ + std::string file; + + switch (lang) + { + case es_ES: + file = mFileList[49]; + break; + + case en_UK: + file = mFileList[50]; + break; + + case ba_BA: + file = mFileList[51]; + break; + + default: + file = mFileList[50]; + break; + } + + for (int i = 0; i < MAX_TEXT_STRINGS; i++) + mTextStrings[i] = ""; + + bool success = false; + + std::ifstream rfile(file); + if (rfile.is_open() && rfile.good()) + { + success = true; + std::string buffer; + + // lee el resto de datos del fichero + int index = 0; + int line_read = 0; + while (std::getline(rfile, buffer)) + { + // Almacena solo las lineas impares + if (line_read % 2 == 1) + mTextStrings[index++] = buffer; + + // Limpia el buffer + buffer.clear(); + line_read++; + }; + } + + return success; +} + +// Obtiene la cadena de texto del indice +std::string Lang::getText(int index) +{ + return mTextStrings[index]; +} \ No newline at end of file diff --git a/source/lang.h b/source/lang.h new file mode 100644 index 0000000..228e1c9 --- /dev/null +++ b/source/lang.h @@ -0,0 +1,37 @@ +#pragma once +#include "ifdefs.h" +#include + +#ifndef LANG_H +#define LANG_H + +// Lang codes +#define es_ES 0 +#define ba_BA 1 +#define en_UK 2 +#define MAX_LANGUAGES 3 + +// Textos +#define MAX_TEXT_STRINGS 100 + +// Clase Lang +class Lang +{ +private: + std::string *mFileList; // Lista de ficheros con los recursos + std::string mTextStrings[MAX_TEXT_STRINGS]; + +public: + // Constructor + Lang(std::string *fileList); + + // Destructor + ~Lang(); + + // Inicializa los textos del juego en el idioma seleccionado + bool setLang(Uint8 lang); + + // Obtiene la cadena de texto del indice + std::string getText(int index); +}; +#endif \ No newline at end of file diff --git a/source/ltexture.cpp b/source/ltexture.cpp new file mode 100644 index 0000000..0e6fd17 --- /dev/null +++ b/source/ltexture.cpp @@ -0,0 +1,166 @@ +#include "const.h" +#include "ltexture.h" +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" + +LTexture::LTexture() +{ + // Initialize + mTexture = NULL; + mWidth = 0; + mHeight = 0; +} + +LTexture::~LTexture() +{ + // Deallocate + unload(); +} + +bool LTexture::loadFromFile(std::string path, SDL_Renderer *renderer) +{ + int req_format = STBI_rgb_alpha; + int width, height, orig_format; + unsigned char *data = stbi_load(path.c_str(), &width, &height, &orig_format, req_format); + if (data == NULL) + { + SDL_Log("Loading image failed: %s", stbi_failure_reason()); + exit(1); + } + + int depth, pitch; + Uint32 pixel_format; + if (req_format == STBI_rgb) + { + depth = 24; + pitch = 3 * width; // 3 bytes per pixel * pixels per row + pixel_format = SDL_PIXELFORMAT_RGB24; + } + else + { // STBI_rgb_alpha (RGBA) + depth = 32; + pitch = 4 * width; + pixel_format = SDL_PIXELFORMAT_RGBA32; + } + + // Get rid of preexisting texture + unload(); + + // The final texture + SDL_Texture *newTexture = NULL; + + // Load image at specified path + //SDL_Surface *loadedSurface = IMG_Load(path.c_str()); + SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format); + if (loadedSurface == NULL) + { + printf("Unable to load image %s!\n", path.c_str()); + } + else + { + // Color key image + //SDL_SetColorKey(loadedSurface, SDL_TRUE, SDL_MapRGB(loadedSurface->format, COLOR_KEY_R, COLOR_KEY_G, COLOR_KEY_B)); + + // Create texture from surface pixels + newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); + if (newTexture == NULL) + { + printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError()); + } + else + { + // Get image dimensions + mWidth = loadedSurface->w; + mHeight = loadedSurface->h; + } + + // Get rid of old loaded surface + SDL_FreeSurface(loadedSurface); + } + + // Return success + mTexture = newTexture; + return mTexture != NULL; +} + +bool LTexture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access) +{ + // Create uninitialized texture + mTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height); + if (mTexture == NULL) + { + printf("Unable to create blank texture! SDL Error: %s\n", SDL_GetError()); + } + else + { + mWidth = width; + mHeight = height; + } + + return mTexture != NULL; +} + +void LTexture::unload() +{ + // Free texture if it exists + if (mTexture != NULL) + { + SDL_DestroyTexture(mTexture); + mTexture = NULL; + mWidth = 0; + mHeight = 0; + } +} + +void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue) +{ + // Modulate texture rgb + SDL_SetTextureColorMod(mTexture, red, green, blue); +} + +void LTexture::setBlendMode(SDL_BlendMode blending) +{ + // Set blending function + SDL_SetTextureBlendMode(mTexture, blending); +} + +void LTexture::setAlpha(Uint8 alpha) +{ + // Modulate texture alpha + SDL_SetTextureAlphaMod(mTexture, alpha); +} + +void LTexture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip) +{ + // Set rendering space and render to screen + SDL_Rect renderQuad = {x, y, mWidth, mHeight}; + + // Set clip rendering dimensions + if (clip != NULL) + { + renderQuad.w = clip->w; + renderQuad.h = clip->h; + } + + renderQuad.w = renderQuad.w * zoomW; + renderQuad.h = renderQuad.h * zoomH; + + // Render to screen + SDL_RenderCopyEx(renderer, mTexture, clip, &renderQuad, angle, center, flip); +} + +void LTexture::setAsRenderTarget(SDL_Renderer *renderer) +{ + // Make self render target + SDL_SetRenderTarget(renderer, mTexture); +} + +int LTexture::getWidth() +{ + return mWidth; +} + +int LTexture::getHeight() +{ + return mHeight; +} diff --git a/source/ltexture.h b/source/ltexture.h new file mode 100644 index 0000000..e533620 --- /dev/null +++ b/source/ltexture.h @@ -0,0 +1,66 @@ +#pragma once +#include "ifdefs.h" +#include +#include + +#ifndef LTEXTURE_H +#define LTEXTURE_H + +// Texture wrapper class +class LTexture +{ +public: + // Initializes variables + LTexture(); + + // Deallocates memory + ~LTexture(); + + // Loads image at specified path + bool loadFromFile(std::string path, SDL_Renderer *renderer); + + // Creates blank texture + bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING); + + // Deallocates texture + void unload(); + + // Set color modulation + void setColor(Uint8 red, Uint8 green, Uint8 blue); + + // Set blending + void setBlendMode(SDL_BlendMode blending); + + // Set alpha modulation + void setAlpha(Uint8 alpha); + + // Renders texture at given point + void render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip = NULL, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE); + + // Set self as render target + void setAsRenderTarget(SDL_Renderer *renderer); + + // Gets image dimensions + int getWidth(); + int getHeight(); + + // Pixel manipulators + bool lockTexture(); + bool unlockTexture(); + void *getPixels(); + void copyPixels(void *pixels); + int getPitch(); + Uint32 getPixel32(unsigned int x, unsigned int y); + +private: + // The actual hardware texture + SDL_Texture *mTexture; + void *mPixels; + int mPitch; + + // Image dimensions + int mWidth; + int mHeight; +}; + +#endif diff --git a/source/main.cpp b/source/main.cpp new file mode 100644 index 0000000..da9b9e4 --- /dev/null +++ b/source/main.cpp @@ -0,0 +1,57 @@ +/* +Código fuente creado por JailDesigner (2020) +Empezado en Castalla el 15/07/2020. + +Descripción del enfoque utilizado para crear el juego. + +El programa contine una serie de clases/objetos básicos: la clase sprite +permite dibujar partes de un fichero png en pantalla. La clase AnimatedSprite +contiene funcionalidad adicional para crear animaciones. La clase text permite +dibujar letras de un png en pantalla a partir de una cadena de texto. La clase +menu permite crear una estructura con diferentes elementos, escribirlos en +pantalla y seleccionar uno de ellos. + +A continuación tenemos las clases enfocadas a la lógica del juego, la clase player +contiene la información del jugador, la clase balloon la de los enemigos y la +clase bullet para las balas que dispara el jugador. La clase background es +muy simple y sirve para pintar el fondo de la pantalla. Por ultimo, la clase +mDirector es la que realiza toda la lógica y se encarga de hacer interactuar +al resto de objetos entre si. + +El objeto mDirector tiene tres estados: titulo, juego y pausa. Segun su estado +el bucle que recorre es distinto. En el bucle juego, el objeto mDirector +tiene un objeto jugador, un vector con los objetos globo y un vector con los +objetos bala. Se encarga de comprobar las entradas de teclado o gamepad para +cerrar la aplicacion, saltar al estado de pausa y para mover al jugador. Recorre +el vector de globos y de balas y si tienen algun tipo asignado las gestiona. +Comprueba las colisiones entre los globos y el jugador y entre las balas y los +globos. Tiene ademas un nivel de amenaza que calcula en funcion del numero de globos +en pantalla y que se va incrementando conforme aumenta la puntuación del jugador. + +Los objetos globo tienen varios contadores para alternar de un estado a otro. + +En los vectores que contienen objetos, se considera activos los objetos que tienen +un tipo asociado diferente a NO_KIND +*/ + +#include "director.h" +#include + +int main(int argc, char *args[]) +{ + printf("Starting the game...\n\n"); + + // Crea el objeto Director + Director *mDirector = new Director(args[0]); + + // Bucle principal + mDirector->run(); + + // Destruye el objeto Director + delete mDirector; + mDirector = nullptr; + + printf("\nShutting down the game...\n"); + + return 0; +} diff --git a/source/menu.cpp b/source/menu.cpp new file mode 100644 index 0000000..c8deee5 --- /dev/null +++ b/source/menu.cpp @@ -0,0 +1,599 @@ +#include "const.h" +#include "menu.h" + +// Constructor +Menu::Menu(SDL_Renderer *renderer, Text *text, Input *input, std::string *fileList) +{ + mRenderer = renderer; + mText = text; + mInput = input; + mFileList = fileList; +} + +Menu::~Menu() +{ + mRenderer = nullptr; + mText = nullptr; + mInput = nullptr; + mFileList = nullptr; +} + +// Inicializador +void Menu::init(std::string name, int x, int y, int backgroundType) +{ + loadMedia(); + + // Inicia variables + mName = name; + mSelector.index = 0; + mTotalItems = 0; + mItemSelected = MENU_NO_OPTION; + mPosX = x; + mPosY = y; + mRectBG.rect.x = 0; + mRectBG.rect.y = 0; + mRectBG.rect.w = 0; + mRectBG.rect.h = 0; + mRectBG.r = 0; + mRectBG.g = 0; + mRectBG.b = 0; + mBackgroundType = backgroundType; + mIsCenteredOnX = false; + mIsCenteredOnY = false; + mAreElementsCenteredOnX = false; + mCenterX = 0; + mCenterY = 0; + mWidestItem = 0; + mColorGreyed = {128, 128, 128}; + + // Selector + mSelector.originY = 0; + mSelector.targetY = 0; + mSelector.despY = 0; + mSelector.originH = 0; + mSelector.targetH = 0; + mSelector.incH = 0; + mSelector.y = 0.0f; + mSelector.h = 0.0f; + mSelector.numJumps = 8; + mSelector.moving = false; + mSelector.resizing = false; + mSelector.rect = {0, 0, 0, 0}; + mSelector.r = 0; + mSelector.g = 0; + mSelector.b = 0; + mSelector.a = 255; + + // Elementos del menu + for (int i = 0; i < MENU_MAX_ITEMS; i++) + { + mItem[i].label = ""; + mItem[i].rect = {0, 0, 0, 0}; + mItem[i].hPaddingDown = 0; + mItem[i].selectable = false; + mItem[i].greyed = false; + mItem[i].linkedDown = false; + mItem[i].linkedUp = false; + } +} + +// Carga los recursos necesarios para la sección 'Title' +bool Menu::loadMedia() +{ + // Indicador de éxito en la carga + bool success = true; + + // Sonidos + mSoundMove = JA_LoadSound(mFileList[17].c_str()); + mSoundAccept = JA_LoadSound(mFileList[18].c_str()); + mSoundCancel = JA_LoadSound(mFileList[16].c_str()); + + return success; +} + +// Obtiene el nombre del menu +std::string Menu::getName() +{ + return mName; +} + +// Obtiene el valor de la variable +Uint8 Menu::getItemSelected() +{ + // Al llamar a esta funcion, se obtiene el valor y se borra + const int temp = mItemSelected; + mItemSelected = MENU_NO_OPTION; + return temp; +} + +// Actualiza la posicion y el estado del selector +void Menu::updateSelector() +{ + if (mSelector.moving) + { + // Calcula el desplazamiento en Y + mSelector.y += mSelector.despY; + if (mSelector.despY > 0) // Va hacia abajo + { + if (mSelector.y > mSelector.targetY) // Ha llegado al destino + { + mSelector.originY = mSelector.y = mSelector.targetY; + mSelector.moving = false; + } + } + if (mSelector.despY < 0) // Va hacia arriba + { + if (mSelector.y < mSelector.targetY) // Ha llegado al destino + { + mSelector.originY = mSelector.y = mSelector.targetY; + mSelector.moving = false; + } + } + mSelector.rect.y = int(mSelector.y); + } + else + { + mSelector.rect.y = int(mSelector.y); + } + + if (mSelector.resizing) + { + // Calcula el incremento en H + mSelector.h += mSelector.incH; + if (mSelector.incH > 0) // Crece + { + if (mSelector.h > mSelector.targetH) // Ha llegado al destino + { + //mSelector.originH = mSelector.targetH = mSelector.rect.h = getSelectorHeight(mSelector.index); + mSelector.originH = mSelector.h = mSelector.targetH; + mSelector.resizing = false; + } + } + if (mSelector.incH < 0) // Decrece + { + if (mSelector.h < mSelector.targetH) // Ha llegado al destino + { + //mSelector.originH = mSelector.targetH = mSelector.rect.h = getSelectorHeight(mSelector.index); + mSelector.originH = mSelector.h = mSelector.targetH; + mSelector.resizing = false; + } + } + mSelector.rect.h = int(mSelector.h); + } + else + { + mSelector.rect.h = getSelectorHeight(mSelector.index); + } +} + +// Coloca el selector en una posición específica +void Menu::setSelectorPos(Uint8 index) +{ + if (index < mTotalItems) + { + mSelector.index = index; + mSelector.rect.y = mSelector.y = mSelector.originY = mSelector.targetY = mItem[mSelector.index].rect.y; + mSelector.rect.w = mRectBG.rect.w; + mSelector.rect.x = mRectBG.rect.x; + mSelector.originH = mSelector.targetH = mSelector.rect.h = getSelectorHeight(mSelector.index); + mSelector.moving = false; + mSelector.resizing = false; + } +} + +// Obtiene la anchura del elemento más ancho del menu +Uint16 Menu::getWidestItem() +{ + Uint16 result = 0; + + // Obtenemos la anchura del item mas ancho + for (int i = 0; i < mTotalItems; i++) + if (mItem[i].rect.w > result) + result = mItem[i].rect.w; + + return result; +} + +// Deja el menu apuntando al primer elemento +void Menu::reset() +{ + mItemSelected = MENU_NO_OPTION; + mSelector.index = 0; + mSelector.originY = mSelector.targetY = mSelector.y = mItem[0].rect.y; + mSelector.originH = mSelector.targetH = mItem[0].rect.h; + mSelector.moving = false; + mSelector.resizing = false; +} + +// Actualiza el menu para recolocarlo correctamente y establecer el tamaño +void Menu::reorganize() +{ + setRectSize(); + if (mIsCenteredOnX) + centerMenuOnX(mCenterX); + if (mIsCenteredOnY) + centerMenuOnY(mCenterY); + if (mAreElementsCenteredOnX) + centerMenuElementsOnX(); +} + +// Deja el menu apuntando al siguiente elemento +bool Menu::increaseSelectorIndex() +{ + bool success = false; + + // Obten las coordenadas del elemento actual + mSelector.y = mSelector.originY = mItem[mSelector.index].rect.y; + mSelector.h = mSelector.originH = getSelectorHeight(mSelector.index); + + // Calcula cual es el siguiente elemento + //if (mSelector.index < (mTotalItems - 1)) + //{ + // mSelector.index++; + // while ((!mItem[mSelector.index].selectable) && (mSelector.index < (mTotalItems - 1))) + // mSelector.index++; + // success = true; + //} + + // Calcula cual es el siguiente elemento (versión con loop) + //if (mSelector.index < (mTotalItems - 1)) + { + ++mSelector.index %= mTotalItems; + while (!mItem[mSelector.index].selectable) + //mSelector.index++; + ++mSelector.index %= mTotalItems; + success = true; + } + + if (success) + { // Establece las coordenadas y altura de destino + mSelector.targetY = mItem[mSelector.index].rect.y; + mSelector.despY = (mSelector.targetY - mSelector.originY) / mSelector.numJumps; + + mSelector.targetH = getSelectorHeight(mSelector.index); + mSelector.incH = (mSelector.targetH - mSelector.originH) / mSelector.numJumps; + + mSelector.moving = true; + if (mSelector.incH != 0) + mSelector.resizing = true; + } + + return success; +} + +// Deja el menu apuntando al elemento anterior +bool Menu::decreaseSelectorIndex() +{ + bool success = false; + + // Obten las coordenadas del elemento actual + mSelector.y = mSelector.originY = mItem[mSelector.index].rect.y; + mSelector.h = mSelector.originH = getSelectorHeight(mSelector.index); + + // Calcula cual es el siguiente elemento + //if (mSelector.index > 0) + //{ + // mSelector.index--; + // while ((!mItem[mSelector.index].selectable) && (mSelector.index > 0)) + // mSelector.index--; + // success = true; + //} + + // Calcula cual es el siguiente elemento (versión con loop) + //if (mSelector.index > 0) + { + if (mSelector.index == 0) + mSelector.index = mTotalItems; + else + mSelector.index--; + while (!mItem[mSelector.index].selectable) + { + if (mSelector.index == 0) + mSelector.index = mTotalItems; + else + mSelector.index--; + } + success = true; + } + + if (success) + { // Establece las coordenadas y altura de destino + mSelector.targetY = mItem[mSelector.index].rect.y; + mSelector.despY = (mSelector.targetY - mSelector.originY) / mSelector.numJumps; + + mSelector.targetH = getSelectorHeight(mSelector.index); + mSelector.incH = (mSelector.targetH - mSelector.originH) / mSelector.numJumps; + + mSelector.moving = true; + if (mSelector.incH != 0) + mSelector.resizing = true; + } + + return success; +} + +// Actualiza la logica del menu +void Menu::update() +{ + updateSelector(); +} + +// Pinta el menu en pantalla +void Menu::render() +{ + // Rendereritza el fondo del menu + if (mBackgroundType == MENU_BACKGROUND_SOLID) + { + SDL_SetRenderDrawColor(mRenderer, mRectBG.r, mRectBG.g, mRectBG.b, mRectBG.a); + SDL_RenderFillRect(mRenderer, &mRectBG.rect); + } + + // Renderiza el rectangulo del selector + SDL_Rect temp = mSelector.rect; + temp.y--; + temp.h++; + SDL_SetRenderDrawColor(mRenderer, mSelector.r, mSelector.g, mSelector.b, mSelector.a); + SDL_RenderFillRect(mRenderer, &temp); + + // Renderiza el borde del fondo + if (mBackgroundType == MENU_BACKGROUND_SOLID) + { + SDL_SetRenderDrawColor(mRenderer, mRectBG.r, mRectBG.g, mRectBG.b, 255); + SDL_RenderDrawRect(mRenderer, &mRectBG.rect); + } + + // Renderitza el texto + for (int i = 0; i < mTotalItems; i++) + { + if (i == mSelector.index) + { + const color_t color = {mSelector.itemR, mSelector.itemG, mSelector.itemB}; + mText->writeColored(mItem[i].rect.x, mItem[i].rect.y, mItem[i].label, color); + } + else if (mItem[i].selectable) + { + mText->write(mItem[i].rect.x, mItem[i].rect.y, mItem[i].label); + } + else if (mItem[i].greyed) + { + mText->writeColored(mItem[i].rect.x, mItem[i].rect.y, mItem[i].label, mColorGreyed); + } + else // No seleccionable + { + if ((mItem[i].linkedUp) && (i == mSelector.index + 1)) + { + const color_t color = {mSelector.itemR, mSelector.itemG, mSelector.itemB}; + mText->writeColored(mItem[i].rect.x, mItem[i].rect.y, mItem[i].label, color); + } + else // No enlazado con el de arriba + { + mText->write(mItem[i].rect.x, mItem[i].rect.y, mItem[i].label); + } + } + + //borrar + //mText->write(0, 0, std::to_string(mSelector.h) + " " + std::to_string(mSelector.incH) + " " + std::to_string(mSelector.resizing)); + //mText->write(0, 8, std::to_string(mSelector.y) + " " + std::to_string(mSelector.despY) + " " + std::to_string(mSelector.moving)); + } +} + +// Establece el rectangulo de fondo del menu y el selector +void Menu::setRectSize() +{ + mRectBG.rect.w = findWidth() + mText->getCharacterWidth(); + mRectBG.rect.h = findHeight() + mText->getCharacterWidth(); + + // La posición X es la del menú menos medio caracter + mRectBG.rect.x = mPosX - (mText->getCharacterWidth() / 2); + + // La posición Y es la del menu menos la altura de medio caracter + mRectBG.rect.y = mPosY - (mText->getCharacterWidth() / 2); + + // Establecemos los valores del rectangulo del selector a partir de los valores del rectangulo de fondo + setSelectorPos(mSelector.index); +} + +// Establece el valor de la variable +void Menu::setTotalItems(int num) +{ + mTotalItems = num; + if (mTotalItems > MENU_MAX_ITEMS) + mTotalItems = MENU_MAX_ITEMS; +} + +// Establece el color del rectangulo de fondo +void Menu::setBackgroundColor(int r, int g, int b, int alpha) +{ + mRectBG.r = r; + mRectBG.g = g; + mRectBG.b = b; + mRectBG.a = alpha; +} + +// Establece el color del rectangulo del selector +void Menu::setSelectorColor(int r, int g, int b, int alpha) +{ + mSelector.r = r; + mSelector.g = g; + mSelector.b = b; + mSelector.a = alpha; +} + +// Establece el color del texto del selector +void Menu::setSelectorTextColor(int r, int g, int b) +{ + mSelector.itemR = r; + mSelector.itemG = g; + mSelector.itemB = b; +} + +// Centra el menu respecto un punto en el eje X +void Menu::centerMenuOnX(int value) +{ + mIsCenteredOnX = true; + mCenterX = value; + + // Actualiza el rectangulo de fondo para recalcular las dimensiones + //setRectSize(); + + // Establece la nueva posición centrada en funcion del elemento más ancho + mPosX = (value) - (findWidth() / 2); + + // Reposiciona los elementos del menu + for (int i = 0; i < MENU_MAX_ITEMS; i++) + mItem[i].rect.x = mPosX; + + // Recalcula el rectangulo de fondo + setRectSize(); +} + +// Centra el menu respecto un punto en el eje Y +void Menu::centerMenuOnY(int value) +{ + mIsCenteredOnY = true; + mCenterY = value; + + // Actualiza el rectangulo de fondo para recalcular las dimensiones + //setRectSize(); + + // Establece la nueva posición centrada en funcion del elemento más ancho + mPosY = (value) - (findHeight() / 2); + + // Reposiciona los elementos del menu + replaceElementsOnY(); + + // Recalcula el rectangulo de fondo + setRectSize(); +} + +// Centra los elementos del menu en el eje X +void Menu::centerMenuElementsOnX() +{ + mAreElementsCenteredOnX = true; + + for (int i = 0; i < mTotalItems; i++) + mItem[i].rect.x = (mCenterX - (mItem[i].rect.w / 2)); +} + +// Añade un item al menu +void Menu::addItem(std::string text, Uint8 hPaddingDown, bool selectable, bool greyed, bool linkedDown) +{ + // Si es el primer item coge la posición en el eje Y del propio menu + if (mTotalItems == 0) + mItem[mTotalItems].rect.y = mPosY; + else + // En caso contrario, coge la posición en el eje Y a partir del elemento anterior + mItem[mTotalItems].rect.y = mItem[mTotalItems - 1].rect.y + mItem[mTotalItems - 1].rect.h + mItem[mTotalItems - 1].hPaddingDown; + + setItemCaption(mTotalItems, text); + mItem[mTotalItems].rect.x = mPosX; + mItem[mTotalItems].hPaddingDown = hPaddingDown; + mItem[mTotalItems].selectable = selectable; + mItem[mTotalItems].greyed = greyed; + mItem[mTotalItems].linkedDown = linkedDown; + if (mTotalItems > 0) + if (mItem[mTotalItems - 1].linkedDown) + mItem[mTotalItems].linkedUp = true; + + setTotalItems(mTotalItems + 1); + mCenterX = mPosX + (findWidth() / 2); + //setSelectorPos(0); + reorganize(); +} + +// Cambia el texto de un item +void Menu::setItemCaption(Uint8 index, std::string text) +{ + mItem[index].label = text; + mItem[index].rect.w = mText->lenght(mItem[index].label); + mItem[index].rect.h = mText->getCharacterWidth(); + reorganize(); +} + +// Establece el indice del itemm que se usará por defecto al cancelar el menu +void Menu::setDefaultActionWhenCancel(Uint8 item) +{ + mDefaultActionWhenCancel = item; +} + +// Gestiona la entrada de teclado y mando durante el menu +void Menu::checkInput() +{ + if (mInput->checkInput(INPUT_UP, REPEAT_FALSE)) + { + if (decreaseSelectorIndex()) + JA_PlaySound(mSoundMove); + } + + if (mInput->checkInput(INPUT_DOWN, REPEAT_FALSE)) + { + if (increaseSelectorIndex()) + JA_PlaySound(mSoundMove); + } + + if (mInput->checkInput(INPUT_ACCEPT, REPEAT_FALSE)) + { + mItemSelected = mSelector.index; + JA_PlaySound(mSoundAccept); + } + + if (mInput->checkInput(INPUT_CANCEL, REPEAT_FALSE)) + { + mItemSelected = mDefaultActionWhenCancel; + JA_PlaySound(mSoundCancel); + } +} + +// Calcula el ancho del menu +Uint16 Menu::findWidth() +{ + return getWidestItem(); +} + +// Calcula el alto del menu +Uint16 Menu::findHeight() +{ + Uint16 height = 0; + + // Obtenemos la altura de la suma de alturas de los items + for (int i = 0; i < mTotalItems; i++) + height += mItem[i].rect.h + mItem[i].hPaddingDown; + + return height - mItem[mTotalItems - 1].hPaddingDown; +} + +// Recoloca los elementos del menu en el eje Y +void Menu::replaceElementsOnY() +{ + mItem[0].rect.y = mPosY; + + for (int i = 1; i < mTotalItems; i++) + mItem[i].rect.y = mItem[i - 1].rect.y + mItem[i - 1].rect.h + mItem[i - 1].hPaddingDown; +} + +// Establece el estado seleccionable de un item +void Menu::setSelectable(Uint8 index, bool value) +{ + mItem[index].selectable = value; +} + +// Establece el estado agrisado de un item +void Menu::setGreyed(Uint8 index, bool value) +{ + mItem[index].greyed = value; +} + +// Establece el estado de enlace de un item +void Menu::setLinkedDown(Uint8 index, bool value) +{ + mItem[index].linkedDown = value; +} + +// Calcula la altura del selector +int Menu::getSelectorHeight(int value) +{ + if (mItem[value].linkedDown) + return mItem[value].rect.h + mItem[value].hPaddingDown + mItem[value + 1].rect.h; + else + return mItem[value].rect.h; +} \ No newline at end of file diff --git a/source/menu.h b/source/menu.h new file mode 100644 index 0000000..6843919 --- /dev/null +++ b/source/menu.h @@ -0,0 +1,195 @@ +#pragma once +#include "ifdefs.h" +#include "sprite.h" +#include "text.h" +#include "input.h" +#include "jail_audio.h" + +#ifndef MENU_H +#define MENU_H + +#define MENU_MAX_ITEMS 50 + +// Clase menu +class Menu +{ +private: + std::string mName; // Nombre del menu + int mPosX; // Posición en el eje X de la primera letra del primer elemento + int mPosY; // Posición en el eje Y de la primera letra del primer elemento + Uint16 mHeight; // Altura del menu + Uint16 mWidth; // Anchura del menu + Uint8 mTotalItems; // Numero total de items del menu + int mItemSelected; // Índice del item del menu que ha sido seleccionado + Uint8 mDefaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu + Uint8 mBackgroundType; // Tipo de fondo para el menu + bool mIsCenteredOnX; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje X + bool mIsCenteredOnY; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y + int mCenterX; // Centro del menu en el eje X + int mCenterY; // Centro del menu en el eje Y + bool mAreElementsCenteredOnX; // Variable para saber si los elementos van centrados en el eje X + Uint16 mWidestItem; // Anchura del elemento más ancho + JA_Sound mSoundAccept; // Sonido al aceptar o elegir una opción del menu + JA_Sound mSoundCancel; // Sonido al cancelar el menu + JA_Sound mSoundMove; // Sonido al mover el selector + SDL_Renderer *mRenderer; // Puntero al renderizador de la ventana + std::string *mFileList; // Lista de ficheros + Text *mText; // Texto para poder escribir los items del menu + Input *mInput; // Gestor de eventos de entrada de teclado o gamepad + color_t mColorGreyed; // Color para los elementos agrisados + + struct rectangle + { + SDL_Rect rect; // Rectangulo + Uint8 r; // Rojo + Uint8 g; // Verde + Uint8 b; // Azul + Uint8 a; // Transparencia + }; + rectangle mRectBG; // Rectangulo de fondo del menu + + struct item + { + std::string label; // Texto + SDL_Rect rect; // Rectangulo que delimita el elemento + Uint8 hPaddingDown; // Espaciado bajo el elemento + bool selectable; // Indica si se puede seleccionar + bool greyed; // Indica si ha de aparecer con otro color mas oscuro + bool linkedDown; // Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector + bool linkedUp; // Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector + }; + item mItem[MENU_MAX_ITEMS]; // Estructura para cada elemento del menu + + struct selector + { + float originY; // Coordenada de origen + float targetY; // Coordenada de destino + float despY; // Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps + bool moving; // Indica si el selector está avanzando hacia el destino + float originH; // Altura de origen + float targetH; // Altura de destino + float incH; // Cantidad de pixels que debe incrementar o decrementar el selector en cada salto + bool resizing; // Indica si el selector está cambiando de tamaño + float y; // Coordenada actual, usado para el desplazamiento + float h; // Altura actual, usado para el cambio de tamaño + Uint8 numJumps; // Numero de pasos preestablecido para llegar al destino + Uint8 index; // Elemento del menu que tiene el foco + SDL_Rect rect; // Rectangulo del selector + Uint8 r; // Cantidad de color rojo para el rectangulo del selector + Uint8 g; // Cantidad de color verde para el rectangulo del selector + Uint8 b; // Cantidad de color azul para el rectangulo del selector + Uint8 a; // Cantidad de transparencia para el rectangulo del selector + Uint8 itemR; // Cantidad de color rojo para el texto del elemento seleccionado + Uint8 itemG; // Cantidad de color verde para el texto del elemento seleccionado + Uint8 itemB; // Cantidad de color azul para el texto del elemento seleccionado + }; + selector mSelector; // Variables para pintar el selector del menu + + // Carga los recursos necesarios para la sección 'Title' + bool loadMedia(); + + // Establece el valor de la variable + void setTotalItems(int num); + + // Establece el rectangulo de fondo del menu + void setRectSize(); + + // Actualiza el menu para recolocarlo correctamente y establecer el tamaño + void reorganize(); + + // Deja el menu apuntando al siguiente elemento + bool increaseSelectorIndex(); + + // Deja el menu apuntando al elemento anterior + bool decreaseSelectorIndex(); + + // Actualiza la posicion y el estado del selector + void updateSelector(); + + // Obtiene la anchura del elemento más ancho del menu + Uint16 getWidestItem(); + + // Gestiona la entrada de teclado y mando durante el menu + void checkMenuInput(Menu *menu); + + // Calcula el ancho del menu + Uint16 findWidth(); + + // Calcula el alto del menu + Uint16 findHeight(); + + // Recoloca los elementos del menu en el eje Y + void replaceElementsOnY(); + + // Calcula la altura del selector + int getSelectorHeight(int value); + +public: + // Constructor + Menu(SDL_Renderer *renderer, Text *text, Input *input, std::string *fileList); + + // Destructor + ~Menu(); + + // Inicializador + void init(std::string name, int x, int y, int backgroundType); + + // Obtiene el nombre del menu + std::string getName(); + + // Obtiene el valor de la variable + Uint8 getItemSelected(); + + // Deja el menu apuntando al primer elemento + void reset(); + + // Gestiona la entrada de teclado y mando durante el menu + void checkInput(); + + // Actualiza la logica del menu + void update(); + + // Pinta el menu en pantalla + void render(); + + // Establece el color del rectangulo de fondo + void setBackgroundColor(int r, int g, int b, int alpha); + + // Establece el color del rectangulo del selector + void setSelectorColor(int r, int g, int b, int alpha); + + // Establece el color del texto del selector + void setSelectorTextColor(int r, int g, int b); + + // Centra el menu respecto a un punto en el eje X + void centerMenuOnX(int value); + + // Centra el menu respecto a un punto en el eje Y + void centerMenuOnY(int value); + + // Centra los elementos del menu en el eje X + void centerMenuElementsOnX(); + + // Añade un item al menu + void addItem(std::string text, Uint8 hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false); + + // Cambia el texto de un item + void setItemCaption(Uint8 index, std::string text); + + // Establece el indice del item que se usará por defecto al cancelar el menu + void setDefaultActionWhenCancel(Uint8 item); + + // Coloca el selector en una posición específica + void setSelectorPos(Uint8 index); + + // Establece el estado seleccionable de un item + void setSelectable(Uint8 index, bool value); + + // Establece el estado agrisado de un item + void setGreyed(Uint8 index, bool value); + + // Establece el estado de enlace de un item + void setLinkedDown(Uint8 index, bool value); +}; + +#endif diff --git a/source/movingsprite.cpp b/source/movingsprite.cpp new file mode 100644 index 0000000..e11493b --- /dev/null +++ b/source/movingsprite.cpp @@ -0,0 +1,286 @@ +#include "const.h" +#include "movingsprite.h" + +// Constructor +MovingSprite::MovingSprite() +{ + clear(); +} + +// Destructor +MovingSprite::~MovingSprite() +{ + clear(); +} + +// Reinicia todas las variables +void MovingSprite::clear() +{ + mPosX = 0.0f; // Posición en el eje X + mPosY = 0.0f; // Posición en el eje Y + + mVelX = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse + mVelY = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse + + mAccelX = 0.0f; // Aceleración en el eje X. Variación de la velocidad + mAccelY = 0.0f; // Aceleración en el eje Y. Variación de la velocidad + + mZoomW = 1.0f; // Zoom aplicado a la anchura + mZoomH = 1.0f; // Zoom aplicado a la altura + + mAngle = 0.0; // Angulo para dibujarlo + mRotate = false; // Indica si ha de rotar + mRotateSpeed = 0; // Velocidad de giro + mRotateAmount = 0.0; // Cantidad de grados a girar en cada iteración + mCounter = 0; // Contador interno +} + +// Iniciador +void MovingSprite::init(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, LTexture *texture, SDL_Renderer *renderer) +{ + // Establece el alto y el ancho del sprite + setWidth(w); + setHeight(h); + + // Establece la posición X,Y del sprite + setPosX(x); + setPosY(y); + + // Establece la velocidad X,Y del sprite + setVelX(velx); + setVelY(vely); + + // Establece la aceleración X,Y del sprite + setAccelX(accelx); + setAccelY(accely); + + // Establece el zoom W,H del sprite + setZoomW(1); + setZoomH(1); + + // Establece el angulo con el que se dibujará + setAngle(0.0); + + // Establece los valores de rotacion + setRotate(false); + setRotateSpeed(0); + setRotateAmount(0.0); + + // Contador interno + mCounter = 0; + + // Establece la textura donde están los gráficos para el sprite + setTexture(texture); + + // Establece el renderizador + setRenderer(renderer); + + // Establece el rectangulo de donde coger la imagen + setSpriteClip(0, 0, w, h); +} + +// Mueve el sprite +void MovingSprite::move() +{ + if (mEnabled) + { + mPosX += mVelX; + mPosY += mVelY; + + mVelX += mAccelX; + mVelY += mAccelY; + } +} + +// Muestra el sprite por pantalla +void MovingSprite::render() +{ + if (mEnabled) + mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip, mZoomW, mZoomH, mAngle); +} + +// Obtiene el valor de la variable +float MovingSprite::getPosX() +{ + return mPosX; +} + +// Obtiene el valor de la variable +float MovingSprite::getPosY() +{ + return mPosY; +} + +// Obtiene el valor de la variable +float MovingSprite::getVelX() +{ + return mVelX; +} + +// Obtiene el valor de la variable +float MovingSprite::getVelY() +{ + return mVelY; +} + +// Obtiene el valor de la variable +float MovingSprite::getAccelX() +{ + return mAccelX; +} + +// Obtiene el valor de la variable +float MovingSprite::getAccelY() +{ + return mAccelY; +} + +// Obtiene el valor de la variable +float MovingSprite::getZoomW() +{ + return mZoomW; +} + +// Obtiene el valor de la variable +float MovingSprite::getZoomH() +{ + return mZoomH; +} + +// Obtiene el valor de la variable +double MovingSprite::getAngle() +{ + return mAngle; +} + +// Establece el valor de la variable +void MovingSprite::setPosX(float x) +{ + mPosX = x; +} + +// Establece el valor de la variable +void MovingSprite::setPosY(float y) +{ + mPosY = y; +} + +// Establece el valor de la variable +void MovingSprite::setVelX(float x) +{ + mVelX = x; +} + +// Establece el valor de la variable +void MovingSprite::setVelY(float y) +{ + mVelY = y; +} + +// Establece el valor de la variable +void MovingSprite::setAccelX(float x) +{ + mAccelX = x; +} + +// Establece el valor de la variable +void MovingSprite::setAccelY(float y) +{ + mAccelY = y; +} + +// Establece el valor de la variable +void MovingSprite::setZoomW(float w) +{ + mZoomW = w; +} + +// Establece el valor de la variable +void MovingSprite::setZoomH(float h) +{ + mZoomH = h; +} + +// Establece el valor de la variable +void MovingSprite::setAngle(double a) +{ + mAngle = a; +} + +// Incrementa el valor de la variable +void MovingSprite::incAngle(double inc) +{ + mAngle += inc; +} + +// Decrementa el valor de la variable +void MovingSprite::decAngle(double dec) +{ + mAngle -= dec; +} + +// Obtiene el valor de la variable +bool MovingSprite::getRotate() +{ + return mRotate; +} + +// Obtiene el valor de la variable +Uint16 MovingSprite::getRotateSpeed() +{ + return mRotateSpeed; +} + +// Establece la rotacion +void MovingSprite::rotate() +{ + if (mEnabled) + if (mRotate) + { + if (mCounter % mRotateSpeed == 0) + { + incAngle(mRotateAmount); + } + } +} + +// Establece el valor de la variable +void MovingSprite::setRotate(bool value) +{ + mRotate = value; +} + +// Establece el valor de la variable +void MovingSprite::setRotateSpeed(Uint16 value) +{ + mRotateSpeed = value; +} + +// Establece el valor de la variable +void MovingSprite::setRotateAmount(double value) +{ + mRotateAmount = value; +} + +// Establece el valor de la variable +void MovingSprite::disableRotate() +{ + mRotate = false; + mAngle = 0; +} + +// Actualiza las variables internas del objeto +void MovingSprite::update() +{ + move(); + rotate(); + + if (mEnabled) + ++mCounter %= 60000; +} + +// Cambia el sentido de la rotación +void MovingSprite::switchRotate() +{ + mRotateAmount *= -1; +} \ No newline at end of file diff --git a/source/movingsprite.h b/source/movingsprite.h new file mode 100644 index 0000000..5e47874 --- /dev/null +++ b/source/movingsprite.h @@ -0,0 +1,137 @@ +#pragma once +#include "ifdefs.h" +#include "sprite.h" + +#ifndef MOVINGSPRITE_H +#define MOVINGSPRITE_H + +// Clase MovingSprite. Añade posicion y velocidad en punto flotante +class MovingSprite : public Sprite +{ +protected: + float mPosX; // Posición en el eje X + float mPosY; // Posición en el eje Y + + float mVelX; // Velocidad en el eje X. Cantidad de pixeles a desplazarse + float mVelY; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse + + float mAccelX; // Aceleración en el eje X. Variación de la velocidad + float mAccelY; // Aceleración en el eje Y. Variación de la velocidad + + float mZoomW; // Zoom aplicado a la anchura + float mZoomH; // Zoom aplicado a la altura + + double mAngle; // Angulo para dibujarlo + bool mRotate; // Indica si ha de rotar + Uint16 mRotateSpeed; // Velocidad de giro + double mRotateAmount; // Cantidad de grados a girar en cada iteración + Uint16 mCounter; // Contador interno + +public: + // Constructor + MovingSprite(); + + // Destructor + ~MovingSprite(); + + // Iniciador + void init(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, LTexture *texture, SDL_Renderer *renderer); + + // Mueve el sprite + void move(); + + // Rota el sprite + void rotate(); + + // Actualiza las variables internas del objeto + void update(); + + // Reinicia todas las variables + void clear(); + + // Muestra el sprite por pantalla + void render(); + + // Obten el valor de la variable + float getPosX(); + + // Obten el valor de la variable + float getPosY(); + + // Obten el valor de la variable + float getVelX(); + + // Obten el valor de la variable + float getVelY(); + + // Obten el valor de la variable + float getAccelX(); + + // Obten el valor de la variable + float getAccelY(); + + // Obten el valor de la variable + float getZoomW(); + + // Obten el valor de la variable + float getZoomH(); + + // Obten el valor de la variable + double getAngle(); + + // Obtiene el valor de la variable + bool getRotate(); + + // Obtiene el valor de la variable + Uint16 getRotateSpeed(); + + // Establece el valor de la variable + void setPosX(float x); + + // Establece el valor de la variable + void setPosY(float y); + + // Establece el valor de la variable + void setVelX(float x); + + // Establece el valor de la variable + void setVelY(float y); + + // Establece el valor de la variable + void setAccelX(float x); + + // Establece el valor de la variable + void setAccelY(float y); + + // Establece el valor de la variable + void setZoomW(float w); + + // Establece el valor de la variable + void setZoomH(float h); + + // Establece el valor de la variable + void setAngle(double a); + + // Incrementa el valor de la variable + void incAngle(double inc); + + // Decrementa el valor de la variable + void decAngle(double dec); + + // Establece el valor de la variable + void setRotate(bool value); + + // Establece el valor de la variable + void setRotateSpeed(Uint16 value); + + // Establece el valor de la variable + void setRotateAmount(double value); + + // Quita el efecto de rotación y deja el sprite en su angulo inicial. + void disableRotate(); + + // Cambia el sentido de la rotación + void switchRotate(); +}; + +#endif diff --git a/source/smartsprite.cpp b/source/smartsprite.cpp new file mode 100644 index 0000000..c88f02f --- /dev/null +++ b/source/smartsprite.cpp @@ -0,0 +1,233 @@ +#include "const.h" +#include "smartsprite.h" + +// Constructor +SmartSprite::SmartSprite() +{ + //init(nullptr, nullptr); +} + +// Destructor +SmartSprite::~SmartSprite() +{ + //init(nullptr, nullptr); +} + +// Inicializador +void SmartSprite::init(LTexture *texture, SDL_Renderer *renderer) +{ + setTexture(texture); + setRenderer(renderer); + + setPosX(0); + setPosY(0); + setWidth(0); + setHeight(0); + + setVelX(0); + setVelY(0); + setAccelX(0); + setAccelY(0); + + setSpriteClip(0, 0, 0, 0); + + setEnabled(false); + setEnabledTimer(0); + + mIsOnDestination = false; + mDestX = 0; + mDestY = 0; + + setRotate(false); + setRotateSpeed(0); + setRotateAmount(0.0); + + mCounter = 0; + + // El Id siempre es >=0, por lo tanto si no se le asigna Id se queda en negativo + mId = -1; + + mIntroEvents = nullptr; +} + +// Pone a cero los elementos del objeto +void SmartSprite::erase() +{ + init(nullptr, nullptr); +} + +// Obtiene el valor de la variable +bool SmartSprite::isEnabled() +{ + return mEnabled; +} + +// Establece el valor de la variable +void SmartSprite::setEnabled(bool state) +{ + mEnabled = state; +} + +// Obtiene el valor de la variable +Uint16 SmartSprite::getEnabledTimer() +{ + return mEnabledCounter; +} + +// Establece el valor de la variable +void SmartSprite::setEnabledTimer(Uint16 time) +{ + mEnabledCounter = time; +} + +// Establece el valor de la variable +void SmartSprite::setDestX(int value) +{ + mDestX = value; +} + +// Establece el valor de la variable +void SmartSprite::setDestY(int value) +{ + mDestY = value; +} + +// Obtiene el valor de la variable +int SmartSprite::getDestX() +{ + return mDestX; +} + +// Obtiene el valor de la variable +int SmartSprite::getDestY() +{ + return mDestY; +} + +// Actualiza la posición y comprueba si ha llegado a su destino +bool SmartSprite::update() +{ + if (mEnabled) + { + MovingSprite::update(); + + // Comprueba si se desplaza en el eje X hacia la derecha + if ((getAccelX() > 0) || ((getAccelX() == 0) && (getVelX() > 0))) + { + // Comprueba si hemos llegado al destino + if (getPosX() > mDestX) + { + // Lo coloca en posición + setPosX(mDestX); + + // Lo detiene + setVelX(0.0f); + setAccelX(0.0f); + } + } + // Comprueba si se desplaza en el eje X hacia la izquierda + else if ((getAccelX() < 0) || ((getAccelX() == 0) && (getVelX() < 0))) + { + // Comprueba si hemos llegado al destino + if (getPosX() < mDestX) + { + // Lo coloca en posición + setPosX(mDestX); + + // Lo detiene + setVelX(0.0f); + setAccelX(0.0f); + } + } + + // Comprueba si se desplaza en el eje Y hacia abajo + if ((getAccelY() > 0) || ((getAccelY() == 0) && (getVelY() > 0))) + { + // Comprueba si hemos llegado al destino + if (getPosY() > mDestY) + { + // Lo coloca en posición + setPosY(mDestY); + + // Lo detiene + setVelY(0.0f); + setAccelY(0.0f); + } + } + // Comprueba si se desplaza en el eje Y hacia arriba + else if ((getAccelY() < 0) || ((getAccelY() == 0) && (getVelY() < 0))) + { + // Comprueba si hemos llegado al destino + if (getPosY() < mDestY) + { + // Lo coloca en posición + setPosY(mDestY); + + // Lo detiene + setVelY(0.0f); + setAccelY(0.0f); + } + } + + // Comprueba si ha llegado a su destino + if ((getPosX() == mDestX) && (getPosY() == mDestY)) + { + mIsOnDestination = true; + } + else + { + mIsOnDestination = false; + } + + // Si esta en el destino comprueba su contador + if (mIsOnDestination) + { + // Si el contador es mayor que cero, lo decrementa + if (mEnabledCounter > 0) + { + --mEnabledCounter; + } + // Si ha llegado a cero, deshabilita el objeto o manda el aviso en función de si tiene Id + else if (mEnabledCounter == 0) + { + if (mId < 0) + { + mEnabled = false; + } + else + { + mIntroEvents[mId] = EVENT_COMPLETED; + } + } + } + } + + return mIsOnDestination; +} + +// Obtiene el valor de la variable +bool SmartSprite::isOnDestination() +{ + return mIsOnDestination; +} + +// Pinta el objeto en pantalla +void SmartSprite::render() +{ + if (mEnabled) + { + MovingSprite::render(); + } +} + +// Establece el valor de la variable +void SmartSprite::setId(int id) +{ + mId = id; +} + +// Establece el valor de la variable +void SmartSprite::setIntroEvents(Uint8 *value) +{ + mIntroEvents = value; +} \ No newline at end of file diff --git a/source/smartsprite.h b/source/smartsprite.h new file mode 100644 index 0000000..12463a8 --- /dev/null +++ b/source/smartsprite.h @@ -0,0 +1,73 @@ +#pragma once +#include "utils.h" +#include "animatedsprite.h" + +#ifndef SMARTSPRITE_H +#define SMARTSPRITE_H + +// Clase SmartSprite +class SmartSprite : public AnimatedSprite +{ +private: + bool mEnabled; // Indica si esta habilitado + bool mIsOnDestination; // Indica si está en el destino + int mDestX; // Posicion de destino en el eje X + int mDestY; // Posicion de destino en el eje Y + int mId; // Identificador + Uint16 mEnabledCounter; // Contador para deshabilitarlo + Uint8 *mIntroEvents; // Dirección del array de eventos donde notificar el estado + +public: + // Constructor + SmartSprite(); + + // Destructor + ~SmartSprite(); + + // Inicializador + void init(LTexture *texture, SDL_Renderer *renderer); + + // Pone a cero los elementos del objeto + void erase(); + + // Obtiene el valor de la variable + bool isEnabled(); + + // Establece el valor de la variable + void setEnabled(bool state); + + // Obtiene el valor de la variable + Uint16 getEnabledTimer(); + + // Establece el valor de la variable + void setEnabledTimer(Uint16 time); + + // Establece el valor de la variable + void setDestX(int value); + + // Establece el valor de la variable + void setDestY(int value); + + // Obtiene el valor de la variable + int getDestX(); + + // Obtiene el valor de la variable + int getDestY(); + + // Actualiza la posición y comprueba si ha llegado a su destino + bool update(); + + // Obtiene el valor de la variable + bool isOnDestination(); + + // Pinta el objeto en pantalla + void render(); + + // Establece el valor de la variable + void setId(int id); + + // Establece el valor de la variable + void setIntroEvents(Uint8 *value); +}; + +#endif diff --git a/source/sprite.cpp b/source/sprite.cpp new file mode 100644 index 0000000..a032c51 --- /dev/null +++ b/source/sprite.cpp @@ -0,0 +1,165 @@ +#include "sprite.h" + +// Constructor +Sprite::Sprite() +{ + init(0, 0, 0, 0, nullptr, nullptr); +} + +// Destructor +Sprite::~Sprite() +{ + mTexture = nullptr; + mRenderer = nullptr; +} + +// Inicializador +void Sprite::init(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *renderer) +{ + // Establece la posición X,Y del sprite + setPosX(x); + setPosY(y); + + // Establece el alto y el ancho del sprite + setWidth(w); + setHeight(h); + + // Establece el puntero al renderizador de la ventana + setRenderer(renderer); + + // Establece la textura donde están los gráficos para el sprite + setTexture(texture); + + // Establece el rectangulo de donde coger la imagen + setSpriteClip(0, 0, w, h); + + // Habilita el objeto + setEnabled(true); +} + +// Inicializador +void Sprite::init(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer) +{ + // Establece el alto y el ancho del sprite + mWidth = rect.w; + mHeight = rect.h; + + // Establece la posición X,Y del sprite + mPosX = rect.x; + mPosY = rect.y; + + // Establece el puntero al renderizador de la ventana + setRenderer(renderer); + + // Establece la textura donde están los gráficos para el sprite + setTexture(texture); + + // Establece el rectangulo de donde coger la imagen + setSpriteClip(rect); +} + +// Muestra el sprite por pantalla +void Sprite::render() +{ + if (mEnabled) + mTexture->render(mRenderer, mPosX, mPosY, &mSpriteClip); +} + +// Obten el valor de la variable +int Sprite::getPosX() +{ + return mPosX; +} + +// Obten el valor de la variable +int Sprite::getPosY() +{ + return mPosY; +} + +// Obten el valor de la variable +int Sprite::getWidth() +{ + return mWidth; +} + +// Obten el valor de la variable +int Sprite::getHeight() +{ + return mHeight; +} + +// Establece el valor de la variable +void Sprite::setPosX(int x) +{ + mPosX = x; +} + +// Establece el valor de la variable +void Sprite::setPosY(int y) +{ + mPosY = y; +} + +// Establece el valor de la variable +void Sprite::setWidth(int w) +{ + mWidth = w; +} + +// Establece el valor de la variable +void Sprite::setHeight(int h) +{ + mHeight = h; +} + +// Obten el valor de la variable +SDL_Rect Sprite::getSpriteClip() +{ + return mSpriteClip; +} + +// Establece el valor de la variable +void Sprite::setSpriteClip(SDL_Rect rect) +{ + mSpriteClip = rect; +} + +// Establece el valor de la variable +void Sprite::setSpriteClip(int x, int y, int w, int h) +{ + mSpriteClip.x = x; + mSpriteClip.y = y; + mSpriteClip.w = w; + mSpriteClip.h = h; +} + +// Obten el valor de la variable +LTexture *Sprite::getTexture() +{ + return mTexture; +} + +// Establece el valor de la variable +void Sprite::setTexture(LTexture *texture) +{ + mTexture = texture; +} + +// Establece el valor de la variable +void Sprite::setRenderer(SDL_Renderer *renderer) +{ + mRenderer = renderer; +} + +// Establece el valor de la variable +void Sprite::setEnabled(bool value) +{ + mEnabled = value; +} + +// Comprueba si el objeto está habilitado +bool Sprite::isEnabled() +{ + return mEnabled; +} \ No newline at end of file diff --git a/source/sprite.h b/source/sprite.h new file mode 100644 index 0000000..b0d0b3e --- /dev/null +++ b/source/sprite.h @@ -0,0 +1,86 @@ +#pragma once +#include "ifdefs.h" +#include "ltexture.h" + +#ifndef SPRITE_H +#define SPRITE_H + +// Clase sprite +class Sprite +{ +protected: + int mPosX; // Posición en el eje X donde dibujar el sprite + int mPosY; // Posición en el eje Y donde dibujar el sprite + Uint16 mWidth; // Ancho del sprite + Uint16 mHeight; // Alto del sprite + + SDL_Renderer *mRenderer; // Puntero al renderizador de la ventana + LTexture *mTexture; // Textura donde estan todos los dibujos del sprite + SDL_Rect mSpriteClip; // Rectangulo de origen de la textura que se dibujará en pantalla + + bool mEnabled; // Indica si el sprite esta habilitado + +public: + // Constructor + Sprite(); + + // Destructor + ~Sprite(); + + // Inicializador + void init(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *renderer); + void init(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer); + + // Muestra el sprite por pantalla + void render(); + + // Obten el valor de la variable + int getPosX(); + + // Obten el valor de la variable + int getPosY(); + + // Obten el valor de la variable + int getWidth(); + + // Obten el valor de la variable + int getHeight(); + + // Establece el valor de la variable + void setPosX(int x); + + // Establece el valor de la variable + void setPosY(int y); + + // Establece el valor de la variable + void setWidth(int w); + + // Establece el valor de la variable + void setHeight(int h); + + // Obten el valor de la variable + SDL_Rect getSpriteClip(); + + // Establece el valor de la variable + void setSpriteClip(SDL_Rect rect); + + // Establece el valor de la variable + void setSpriteClip(int x, int y, int w, int h); + + // Obten el valor de la variable + LTexture *getTexture(); + + // Establece el valor de la variable + void setTexture(LTexture *texture); + + // Establece el valor de la variable + void setRenderer(SDL_Renderer *renderer); + + // Establece el valor de la variable + void setEnabled(bool value); + + // Comprueba si el objeto está habilitado + bool isEnabled(); +}; + +#endif diff --git a/source/stb_image.h b/source/stb_image.h new file mode 100644 index 0000000..d60371b --- /dev/null +++ b/source/stb_image.h @@ -0,0 +1,7897 @@ +/* stb_image - v2.27 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#ifdef _MSC_VER +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uc) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!stbi__at_eof(j->s)) { + int x = stbi__get8(j->s); + if (x == 255) { + j->marker = stbi__get8(j->s); + break; + } + } + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + } else { + if (!stbi__process_marker(j, m)) return 0; + } + m = stbi__get_marker(j); + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + return -1; /* report error for unexpected end of data. */ + } + stbi__fill_bits(a); + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + return 1; + } + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static int stbi__paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *prior; + int filter = *raw++; + + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + if (img_width_bytes > x) return stbi__err("invalid width","Corrupt PNG"); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { + switch (filter) { + case STBI__F_none : cur[k] = raw[k]; break; + case STBI__F_sub : cur[k] = raw[k]; break; + case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; + case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; + case STBI__F_avg_first : cur[k] = raw[k]; break; + case STBI__F_paeth_first: cur[k] = raw[k]; break; + } + } + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else if (depth == 16) { + if (img_n != out_n) { + cur[filter_bytes] = 255; // first pixel top byte + cur[filter_bytes+1] = 255; // first pixel bottom byte + } + raw += filter_bytes; + cur += output_bytes; + prior += output_bytes; + } else { + raw += 1; + cur += 1; + prior += 1; + } + + // this is a little gross, so that we don't switch per-pixel or per-component + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*filter_bytes; + #define STBI__CASE(f) \ + case f: \ + for (k=0; k < nk; ++k) + switch (filter) { + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; + } + #undef STBI__CASE + raw += nk; + } else { + STBI_ASSERT(img_n+1 == out_n); + #define STBI__CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ + for (k=0; k < filter_bytes; ++k) + switch (filter) { + STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; + } + #undef STBI__CASE + + // the loop above sets the high byte of the pixels' alpha, but for + // 16 bit png files we also need the low byte set. we'll do that here. + if (depth == 16) { + cur = a->out + stride*j; // start at the beginning of the row again + for (i=0; i < x; ++i,cur+=output_bytes) { + cur[filter_bytes+1] = 255; + } + } + } + } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + int q; + // insert alpha = 255 + cur = a->out + stride*j; + if (img_n == 1) { + for (q=x-1; q >= 0; --q) { + cur[q*2+1] = 255; + cur[q*2+0] = cur[q]; + } + } else { + STBI_ASSERT(img_n == 3); + for (q=x-1; q >= 0; --q) { + cur[q*4+3] = 255; + cur[q*4+2] = cur[q*3+2]; + cur[q*4+1] = cur[q*3+1]; + cur[q*4+0] = cur[q*3+0]; + } + } + } + } + } else if (depth == 16) { + // force the image data from big-endian to platform-native. + // this is done in a separate pass due to the decoding relying + // on the data being untouched, but could probably be done + // per-line during decode if care is taken. + stbi_uc *cur = a->out; + stbi__uint16 *cur16 = (stbi__uint16*)cur; + + for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { + *cur16 = (cur[0] << 8) | cur[1]; + } + } + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi__unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + if (scan == STBI__SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + if (info.offset != s->callback_already_read + (s->img_buffer - s->img_buffer_original)) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8)); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/source/stb_vorbis.c b/source/stb_vorbis.c new file mode 100644 index 0000000..49df433 --- /dev/null +++ b/source/stb_vorbis.c @@ -0,0 +1,5565 @@ +// Ogg Vorbis audio decoder - v1.20 - public domain +// http://nothings.org/stb_vorbis/ +// +// Original version written by Sean Barrett in 2007. +// +// Originally sponsored by RAD Game Tools. Seeking implementation +// sponsored by Phillip Bennefall, Marc Andersen, Aaron Baker, +// Elias Software, Aras Pranckevicius, and Sean Barrett. +// +// LICENSE +// +// See end of file for license information. +// +// Limitations: +// +// - floor 0 not supported (used in old ogg vorbis files pre-2004) +// - lossless sample-truncation at beginning ignored +// - cannot concatenate multiple vorbis streams +// - sample positions are 32-bit, limiting seekable 192Khz +// files to around 6 hours (Ogg supports 64-bit) +// +// Feature contributors: +// Dougall Johnson (sample-exact seeking) +// +// Bugfix/warning contributors: +// Terje Mathisen Niklas Frykholm Andy Hill +// Casey Muratori John Bolton Gargaj +// Laurent Gomila Marc LeBlanc Ronny Chevalier +// Bernhard Wodo Evan Balster github:alxprd +// Tom Beaumont Ingo Leitgeb Nicolas Guillemot +// Phillip Bennefall Rohit Thiago Goulart +// github:manxorist saga musix github:infatum +// Timur Gagiev Maxwell Koo Peter Waller +// github:audinowho Dougall Johnson David Reid +// github:Clownacy Pedro J. Estebanez Remi Verschelde +// +// Partial history: +// 1.20 - 2020-07-11 - several small fixes +// 1.19 - 2020-02-05 - warnings +// 1.18 - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc. +// 1.17 - 2019-07-08 - fix CVE-2019-13217..CVE-2019-13223 (by ForAllSecure) +// 1.16 - 2019-03-04 - fix warnings +// 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found +// 1.14 - 2018-02-11 - delete bogus dealloca usage +// 1.13 - 2018-01-29 - fix truncation of last frame (hopefully) +// 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files +// 1.11 - 2017-07-23 - fix MinGW compilation +// 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory +// 1.09 - 2016-04-04 - back out 'truncation of last frame' fix from previous version +// 1.08 - 2016-04-02 - warnings; setup memory leaks; truncation of last frame +// 1.07 - 2015-01-16 - fixes for crashes on invalid files; warning fixes; const +// 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) +// some crash fixes when out of memory or with corrupt files +// fix some inappropriately signed shifts +// 1.05 - 2015-04-19 - don't define __forceinline if it's redundant +// 1.04 - 2014-08-27 - fix missing const-correct case in API +// 1.03 - 2014-08-07 - warning fixes +// 1.02 - 2014-07-09 - declare qsort comparison as explicitly _cdecl in Windows +// 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float (interleaved was correct) +// 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in >2-channel; +// (API change) report sample rate for decode-full-file funcs +// +// See end of file for full version history. + + +////////////////////////////////////////////////////////////////////////////// +// +// HEADER BEGINS HERE +// + +#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H +#define STB_VORBIS_INCLUDE_STB_VORBIS_H + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) +#define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/////////// THREAD SAFETY + +// Individual stb_vorbis* handles are not thread-safe; you cannot decode from +// them from multiple threads at the same time. However, you can have multiple +// stb_vorbis* handles and decode from them independently in multiple thrads. + + +/////////// MEMORY ALLOCATION + +// normally stb_vorbis uses malloc() to allocate memory at startup, +// and alloca() to allocate temporary memory during a frame on the +// stack. (Memory consumption will depend on the amount of setup +// data in the file and how you set the compile flags for speed +// vs. size. In my test files the maximal-size usage is ~150KB.) +// +// You can modify the wrapper functions in the source (setup_malloc, +// setup_temp_malloc, temp_malloc) to change this behavior, or you +// can use a simpler allocation model: you pass in a buffer from +// which stb_vorbis will allocate _all_ its memory (including the +// temp memory). "open" may fail with a VORBIS_outofmem if you +// do not pass in enough data; there is no way to determine how +// much you do need except to succeed (at which point you can +// query get_info to find the exact amount required. yes I know +// this is lame). +// +// If you pass in a non-NULL buffer of the type below, allocation +// will occur from it as described above. Otherwise just pass NULL +// to use malloc()/alloca() + +typedef struct +{ + char *alloc_buffer; + int alloc_buffer_length_in_bytes; +} stb_vorbis_alloc; + + +/////////// FUNCTIONS USEABLE WITH ALL INPUT MODES + +typedef struct stb_vorbis stb_vorbis; + +typedef struct +{ + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int setup_temp_memory_required; + unsigned int temp_memory_required; + + int max_frame_size; +} stb_vorbis_info; + +typedef struct +{ + char *vendor; + + int comment_list_length; + char **comment_list; +} stb_vorbis_comment; + +// get general information about the file +extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f); + +// get ogg comments +extern stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f); + +// get the last error detected (clears it, too) +extern int stb_vorbis_get_error(stb_vorbis *f); + +// close an ogg vorbis file and free all memory in use +extern void stb_vorbis_close(stb_vorbis *f); + +// this function returns the offset (in samples) from the beginning of the +// file that will be returned by the next decode, if it is known, or -1 +// otherwise. after a flush_pushdata() call, this may take a while before +// it becomes valid again. +// NOT WORKING YET after a seek with PULLDATA API +extern int stb_vorbis_get_sample_offset(stb_vorbis *f); + +// returns the current seek point within the file, or offset from the beginning +// of the memory buffer. In pushdata mode it returns 0. +extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f); + +/////////// PUSHDATA API + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +// this API allows you to get blocks of data from any source and hand +// them to stb_vorbis. you have to buffer them; stb_vorbis will tell +// you how much it used, and you have to give it the rest next time; +// and stb_vorbis may not have enough data to work with and you will +// need to give it the same data again PLUS more. Note that the Vorbis +// specification does not bound the size of an individual frame. + +extern stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char * datablock, int datablock_length_in_bytes, + int *datablock_memory_consumed_in_bytes, + int *error, + const stb_vorbis_alloc *alloc_buffer); +// create a vorbis decoder by passing in the initial data block containing +// the ogg&vorbis headers (you don't need to do parse them, just provide +// the first N bytes of the file--you're told if it's not enough, see below) +// on success, returns an stb_vorbis *, does not set error, returns the amount of +// data parsed/consumed on this call in *datablock_memory_consumed_in_bytes; +// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed +// if returns NULL and *error is VORBIS_need_more_data, then the input block was +// incomplete and you need to pass in a larger block from the start of the file + +extern int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, + const unsigned char *datablock, int datablock_length_in_bytes, + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ); +// decode a frame of audio sample data if possible from the passed-in data block +// +// return value: number of bytes we used from datablock +// +// possible cases: +// 0 bytes used, 0 samples output (need more data) +// N bytes used, 0 samples output (resynching the stream, keep going) +// N bytes used, M samples output (one frame of data) +// note that after opening a file, you will ALWAYS get one N-bytes,0-sample +// frame, because Vorbis always "discards" the first frame. +// +// Note that on resynch, stb_vorbis will rarely consume all of the buffer, +// instead only datablock_length_in_bytes-3 or less. This is because it wants +// to avoid missing parts of a page header if they cross a datablock boundary, +// without writing state-machiney code to record a partial detection. +// +// The number of channels returned are stored in *channels (which can be +// NULL--it is always the same as the number of channels reported by +// get_info). *output will contain an array of float* buffers, one per +// channel. In other words, (*output)[0][0] contains the first sample from +// the first channel, and (*output)[1][0] contains the first sample from +// the second channel. + +extern void stb_vorbis_flush_pushdata(stb_vorbis *f); +// inform stb_vorbis that your next datablock will not be contiguous with +// previous ones (e.g. you've seeked in the data); future attempts to decode +// frames will cause stb_vorbis to resynchronize (as noted above), and +// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it +// will begin decoding the _next_ frame. +// +// if you want to seek using pushdata, you need to seek in your file, then +// call stb_vorbis_flush_pushdata(), then start calling decoding, then once +// decoding is returning you data, call stb_vorbis_get_sample_offset, and +// if you don't like the result, seek your file again and repeat. +#endif + + +////////// PULLING INPUT API + +#ifndef STB_VORBIS_NO_PULLDATA_API +// This API assumes stb_vorbis is allowed to pull data from a source-- +// either a block of memory containing the _entire_ vorbis stream, or a +// FILE * that you or it create, or possibly some other reading mechanism +// if you go modify the source to replace the FILE * case with some kind +// of callback to your code. (But if you don't support seeking, you may +// just want to go ahead and use pushdata.) + +#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output); +#endif +#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION) +extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *channels, int *sample_rate, short **output); +#endif +// decode an entire file and output the data interleaved into a malloc()ed +// buffer stored in *output. The return value is the number of samples +// decoded, or -1 if the file could not be opened or was not an ogg vorbis file. +// When you're done with it, just free() the pointer returned in *output. + +extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an ogg vorbis stream in memory (note +// this must be the entire stream!). on failure, returns NULL and sets *error + +#ifndef STB_VORBIS_NO_STDIO +extern stb_vorbis * stb_vorbis_open_filename(const char *filename, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from a filename via fopen(). on failure, +// returns NULL and sets *error (possibly to VORBIS_file_open_failure). + +extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell). on failure, returns NULL and sets *error. +// note that stb_vorbis must "own" this stream; if you seek it in between +// calls to stb_vorbis, it will become confused. Moreover, if you attempt to +// perform stb_vorbis_seek_*() operations on this file, it will assume it +// owns the _entire_ rest of the file after the start point. Use the next +// function, stb_vorbis_open_file_section(), to limit it. + +extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close, + int *error, const stb_vorbis_alloc *alloc_buffer, unsigned int len); +// create an ogg vorbis decoder from an open FILE *, looking for a stream at +// the _current_ seek point (ftell); the stream will be of length 'len' bytes. +// on failure, returns NULL and sets *error. note that stb_vorbis must "own" +// this stream; if you seek it in between calls to stb_vorbis, it will become +// confused. +#endif + +extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number); +extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number); +// these functions seek in the Vorbis file to (approximately) 'sample_number'. +// after calling seek_frame(), the next call to get_frame_*() will include +// the specified sample. after calling stb_vorbis_seek(), the next call to +// stb_vorbis_get_samples_* will start with the specified sample. If you +// do not need to seek to EXACTLY the target sample when using get_samples_*, +// you can also use seek_frame(). + +extern int stb_vorbis_seek_start(stb_vorbis *f); +// this function is equivalent to stb_vorbis_seek(f,0) + +extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f); +extern float stb_vorbis_stream_length_in_seconds(stb_vorbis *f); +// these functions return the total length of the vorbis stream + +extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output); +// decode the next frame and return the number of samples. the number of +// channels returned are stored in *channels (which can be NULL--it is always +// the same as the number of channels reported by get_info). *output will +// contain an array of float* buffers, one per channel. These outputs will +// be overwritten on the next call to stb_vorbis_get_frame_*. +// +// You generally should not intermix calls to stb_vorbis_get_frame_*() +// and stb_vorbis_get_samples_*(), since the latter calls the former. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts); +extern int stb_vorbis_get_frame_short (stb_vorbis *f, int num_c, short **buffer, int num_samples); +#endif +// decode the next frame and return the number of *samples* per channel. +// Note that for interleaved data, you pass in the number of shorts (the +// size of your array), but the return value is the number of samples per +// channel, not the total number of samples. +// +// The data is coerced to the number of channels you request according to the +// channel coercion rules (see below). You must pass in the size of your +// buffer(s) so that stb_vorbis will not overwrite the end of the buffer. +// The maximum buffer size needed can be gotten from get_info(); however, +// the Vorbis I specification implies an absolute maximum of 4096 samples +// per channel. + +// Channel coercion rules: +// Let M be the number of channels requested, and N the number of channels present, +// and Cn be the nth channel; let stereo L be the sum of all L and center channels, +// and stereo R be the sum of all R and center channels (channel assignment from the +// vorbis spec). +// M N output +// 1 k sum(Ck) for all k +// 2 * stereo L, stereo R +// k l k > l, the first l channels, then 0s +// k l k <= l, the first k channels +// Note that this is not _good_ surround etc. mixing at all! It's just so +// you get something useful. + +extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats); +extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples); +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES. +// Returns the number of samples stored per channel; it may be less than requested +// at the end of the file. If there are no more samples in the file, returns 0. + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts); +extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples); +#endif +// gets num_samples samples, not necessarily on a frame boundary--this requires +// buffering so you have to supply the buffers. Applies the coercion rules above +// to produce 'channels' channels. Returns the number of samples stored per channel; +// it may be less than requested at the end of the file. If there are no more +// samples in the file, returns 0. + +#endif + +//////// ERROR CODES + +enum STBVorbisError +{ + VORBIS__no_error, + + VORBIS_need_more_data=1, // not a real error + + VORBIS_invalid_api_mixing, // can't mix API modes + VORBIS_outofmem, // not enough memory + VORBIS_feature_not_supported, // uses floor 0 + VORBIS_too_many_channels, // STB_VORBIS_MAX_CHANNELS is too small + VORBIS_file_open_failure, // fopen() failed + VORBIS_seek_without_length, // can't seek in unknown-length file + + VORBIS_unexpected_eof=10, // file is truncated? + VORBIS_seek_invalid, // seek past EOF + + // decoding errors (corrupt/invalid stream) -- you probably + // don't care about the exact details of these + + // vorbis errors: + VORBIS_invalid_setup=20, + VORBIS_invalid_stream, + + // ogg errors: + VORBIS_missing_capture_pattern=30, + VORBIS_invalid_stream_structure_version, + VORBIS_continued_packet_flag_invalid, + VORBIS_incorrect_stream_serial_number, + VORBIS_invalid_first_page, + VORBIS_bad_packet_type, + VORBIS_cant_find_last_page, + VORBIS_seek_failed, + VORBIS_ogg_skeleton_not_supported +}; + + +#ifdef __cplusplus +} +#endif + +#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H +// +// HEADER ENDS HERE +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef STB_VORBIS_HEADER_ONLY + +// global configuration settings (e.g. set these in the project/makefile), +// or just set them in this file at the top (although ideally the first few +// should be visible when the header file is compiled too, although it's not +// crucial) + +// STB_VORBIS_NO_PUSHDATA_API +// does not compile the code for the various stb_vorbis_*_pushdata() +// functions +// #define STB_VORBIS_NO_PUSHDATA_API + +// STB_VORBIS_NO_PULLDATA_API +// does not compile the code for the non-pushdata APIs +// #define STB_VORBIS_NO_PULLDATA_API + +// STB_VORBIS_NO_STDIO +// does not compile the code for the APIs that use FILE *s internally +// or externally (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_STDIO + +// STB_VORBIS_NO_INTEGER_CONVERSION +// does not compile the code for converting audio sample data from +// float to integer (implied by STB_VORBIS_NO_PULLDATA_API) +// #define STB_VORBIS_NO_INTEGER_CONVERSION + +// STB_VORBIS_NO_FAST_SCALED_FLOAT +// does not use a fast float-to-int trick to accelerate float-to-int on +// most platforms which requires endianness be defined correctly. +//#define STB_VORBIS_NO_FAST_SCALED_FLOAT + + +// STB_VORBIS_MAX_CHANNELS [number] +// globally define this to the maximum number of channels you need. +// The spec does not put a restriction on channels except that +// the count is stored in a byte, so 255 is the hard limit. +// Reducing this saves about 16 bytes per value, so using 16 saves +// (255-16)*16 or around 4KB. Plus anything other memory usage +// I forgot to account for. Can probably go as low as 8 (7.1 audio), +// 6 (5.1 audio), or 2 (stereo only). +#ifndef STB_VORBIS_MAX_CHANNELS +#define STB_VORBIS_MAX_CHANNELS 16 // enough for anyone? +#endif + +// STB_VORBIS_PUSHDATA_CRC_COUNT [number] +// after a flush_pushdata(), stb_vorbis begins scanning for the +// next valid page, without backtracking. when it finds something +// that looks like a page, it streams through it and verifies its +// CRC32. Should that validation fail, it keeps scanning. But it's +// possible that _while_ streaming through to check the CRC32 of +// one candidate page, it sees another candidate page. This #define +// determines how many "overlapping" candidate pages it can search +// at once. Note that "real" pages are typically ~4KB to ~8KB, whereas +// garbage pages could be as big as 64KB, but probably average ~16KB. +// So don't hose ourselves by scanning an apparent 64KB page and +// missing a ton of real ones in the interim; so minimum of 2 +#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT +#define STB_VORBIS_PUSHDATA_CRC_COUNT 4 +#endif + +// STB_VORBIS_FAST_HUFFMAN_LENGTH [number] +// sets the log size of the huffman-acceleration table. Maximum +// supported value is 24. with larger numbers, more decodings are O(1), +// but the table size is larger so worse cache missing, so you'll have +// to probe (and try multiple ogg vorbis files) to find the sweet spot. +#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH +#define STB_VORBIS_FAST_HUFFMAN_LENGTH 10 +#endif + +// STB_VORBIS_FAST_BINARY_LENGTH [number] +// sets the log size of the binary-search acceleration table. this +// is used in similar fashion to the fast-huffman size to set initial +// parameters for the binary search + +// STB_VORBIS_FAST_HUFFMAN_INT +// The fast huffman tables are much more efficient if they can be +// stored as 16-bit results instead of 32-bit results. This restricts +// the codebooks to having only 65535 possible outcomes, though. +// (At least, accelerated by the huffman table.) +#ifndef STB_VORBIS_FAST_HUFFMAN_INT +#define STB_VORBIS_FAST_HUFFMAN_SHORT +#endif + +// STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH +// If the 'fast huffman' search doesn't succeed, then stb_vorbis falls +// back on binary searching for the correct one. This requires storing +// extra tables with the huffman codes in sorted order. Defining this +// symbol trades off space for speed by forcing a linear search in the +// non-fast case, except for "sparse" codebooks. +// #define STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + +// STB_VORBIS_DIVIDES_IN_RESIDUE +// stb_vorbis precomputes the result of the scalar residue decoding +// that would otherwise require a divide per chunk. you can trade off +// space for time by defining this symbol. +// #define STB_VORBIS_DIVIDES_IN_RESIDUE + +// STB_VORBIS_DIVIDES_IN_CODEBOOK +// vorbis VQ codebooks can be encoded two ways: with every case explicitly +// stored, or with all elements being chosen from a small range of values, +// and all values possible in all elements. By default, stb_vorbis expands +// this latter kind out to look like the former kind for ease of decoding, +// because otherwise an integer divide-per-vector-element is required to +// unpack the index. If you define STB_VORBIS_DIVIDES_IN_CODEBOOK, you can +// trade off storage for speed. +//#define STB_VORBIS_DIVIDES_IN_CODEBOOK + +#ifdef STB_VORBIS_CODEBOOK_SHORTS +#error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats" +#endif + +// STB_VORBIS_DIVIDE_TABLE +// this replaces small integer divides in the floor decode loop with +// table lookups. made less than 1% difference, so disabled by default. + +// STB_VORBIS_NO_INLINE_DECODE +// disables the inlining of the scalar codebook fast-huffman decode. +// might save a little codespace; useful for debugging +// #define STB_VORBIS_NO_INLINE_DECODE + +// STB_VORBIS_NO_DEFER_FLOOR +// Normally we only decode the floor without synthesizing the actual +// full curve. We can instead synthesize the curve immediately. This +// requires more memory and is very likely slower, so I don't think +// you'd ever want to do it except for debugging. +// #define STB_VORBIS_NO_DEFER_FLOOR + + + + +////////////////////////////////////////////////////////////////////////////// + +#ifdef STB_VORBIS_NO_PULLDATA_API + #define STB_VORBIS_NO_INTEGER_CONVERSION + #define STB_VORBIS_NO_STDIO +#endif + +#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO) + #define STB_VORBIS_NO_STDIO 1 +#endif + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + + // only need endianness for fast-float-to-int, which we don't + // use for pushdata + + #ifndef STB_VORBIS_BIG_ENDIAN + #define STB_VORBIS_ENDIAN 0 + #else + #define STB_VORBIS_ENDIAN 1 + #endif + +#endif +#endif + + +#ifndef STB_VORBIS_NO_STDIO +#include +#endif + +#ifndef STB_VORBIS_NO_CRT + #include + #include + #include + #include + + // find definition of alloca if it's not in stdlib.h: + #if defined(_MSC_VER) || defined(__MINGW32__) + #include + #endif + #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__) + #include + #endif +#else // STB_VORBIS_NO_CRT + #define NULL 0 + #define malloc(s) 0 + #define free(s) ((void) 0) + #define realloc(s) 0 +#endif // STB_VORBIS_NO_CRT + +#include + +#ifdef __MINGW32__ + // eff you mingw: + // "fixed": + // http://sourceforge.net/p/mingw-w64/mailman/message/32882927/ + // "no that broke the build, reverted, who cares about C": + // http://sourceforge.net/p/mingw-w64/mailman/message/32890381/ + #ifdef __forceinline + #undef __forceinline + #endif + #define __forceinline + #ifndef alloca + #define alloca __builtin_alloca + #endif +#elif !defined(_MSC_VER) + #if __GNUC__ + #define __forceinline inline + #else + #define __forceinline + #endif +#endif + +#if STB_VORBIS_MAX_CHANNELS > 256 +#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range" +#endif + +#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24 +#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range" +#endif + + +#if 0 +#include +#define CHECK(f) _CrtIsValidHeapPointer(f->channel_buffers[1]) +#else +#define CHECK(f) ((void) 0) +#endif + +#define MAX_BLOCKSIZE_LOG 13 // from specification +#define MAX_BLOCKSIZE (1 << MAX_BLOCKSIZE_LOG) + + +typedef unsigned char uint8; +typedef signed char int8; +typedef unsigned short uint16; +typedef signed short int16; +typedef unsigned int uint32; +typedef signed int int32; + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +typedef float codetype; + +// @NOTE +// +// Some arrays below are tagged "//varies", which means it's actually +// a variable-sized piece of data, but rather than malloc I assume it's +// small enough it's better to just allocate it all together with the +// main thing +// +// Most of the variables are specified with the smallest size I could pack +// them into. It might give better performance to make them all full-sized +// integers. It should be safe to freely rearrange the structures or change +// the sizes larger--nothing relies on silently truncating etc., nor the +// order of variables. + +#define FAST_HUFFMAN_TABLE_SIZE (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH) +#define FAST_HUFFMAN_TABLE_MASK (FAST_HUFFMAN_TABLE_SIZE - 1) + +typedef struct +{ + int dimensions, entries; + uint8 *codeword_lengths; + float minimum_value; + float delta_value; + uint8 value_bits; + uint8 lookup_type; + uint8 sequence_p; + uint8 sparse; + uint32 lookup_values; + codetype *multiplicands; + uint32 *codewords; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + int16 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #else + int32 fast_huffman[FAST_HUFFMAN_TABLE_SIZE]; + #endif + uint32 *sorted_codewords; + int *sorted_values; + int sorted_entries; +} Codebook; + +typedef struct +{ + uint8 order; + uint16 rate; + uint16 bark_map_size; + uint8 amplitude_bits; + uint8 amplitude_offset; + uint8 number_of_books; + uint8 book_list[16]; // varies +} Floor0; + +typedef struct +{ + uint8 partitions; + uint8 partition_class_list[32]; // varies + uint8 class_dimensions[16]; // varies + uint8 class_subclasses[16]; // varies + uint8 class_masterbooks[16]; // varies + int16 subclass_books[16][8]; // varies + uint16 Xlist[31*8+2]; // varies + uint8 sorted_order[31*8+2]; + uint8 neighbors[31*8+2][2]; + uint8 floor1_multiplier; + uint8 rangebits; + int values; +} Floor1; + +typedef union +{ + Floor0 floor0; + Floor1 floor1; +} Floor; + +typedef struct +{ + uint32 begin, end; + uint32 part_size; + uint8 classifications; + uint8 classbook; + uint8 **classdata; + int16 (*residue_books)[8]; +} Residue; + +typedef struct +{ + uint8 magnitude; + uint8 angle; + uint8 mux; +} MappingChannel; + +typedef struct +{ + uint16 coupling_steps; + MappingChannel *chan; + uint8 submaps; + uint8 submap_floor[15]; // varies + uint8 submap_residue[15]; // varies +} Mapping; + +typedef struct +{ + uint8 blockflag; + uint8 mapping; + uint16 windowtype; + uint16 transformtype; +} Mode; + +typedef struct +{ + uint32 goal_crc; // expected crc if match + int bytes_left; // bytes left in packet + uint32 crc_so_far; // running crc + int bytes_done; // bytes processed in _current_ chunk + uint32 sample_loc; // granule pos encoded in page +} CRCscan; + +typedef struct +{ + uint32 page_start, page_end; + uint32 last_decoded_sample; +} ProbedPage; + +struct stb_vorbis +{ + // user-accessible info + unsigned int sample_rate; + int channels; + + unsigned int setup_memory_required; + unsigned int temp_memory_required; + unsigned int setup_temp_memory_required; + + char *vendor; + int comment_list_length; + char **comment_list; + + // input config +#ifndef STB_VORBIS_NO_STDIO + FILE *f; + uint32 f_start; + int close_on_free; +#endif + + uint8 *stream; + uint8 *stream_start; + uint8 *stream_end; + + uint32 stream_len; + + uint8 push_mode; + + // the page to seek to when seeking to start, may be zero + uint32 first_audio_page_offset; + + // p_first is the page on which the first audio packet ends + // (but not necessarily the page on which it starts) + ProbedPage p_first, p_last; + + // memory management + stb_vorbis_alloc alloc; + int setup_offset; + int temp_offset; + + // run-time results + int eof; + enum STBVorbisError error; + + // user-useful data + + // header info + int blocksize[2]; + int blocksize_0, blocksize_1; + int codebook_count; + Codebook *codebooks; + int floor_count; + uint16 floor_types[64]; // varies + Floor *floor_config; + int residue_count; + uint16 residue_types[64]; // varies + Residue *residue_config; + int mapping_count; + Mapping *mapping; + int mode_count; + Mode mode_config[64]; // varies + + uint32 total_samples; + + // decode buffer + float *channel_buffers[STB_VORBIS_MAX_CHANNELS]; + float *outputs [STB_VORBIS_MAX_CHANNELS]; + + float *previous_window[STB_VORBIS_MAX_CHANNELS]; + int previous_length; + + #ifndef STB_VORBIS_NO_DEFER_FLOOR + int16 *finalY[STB_VORBIS_MAX_CHANNELS]; + #else + float *floor_buffers[STB_VORBIS_MAX_CHANNELS]; + #endif + + uint32 current_loc; // sample location of next frame to decode + int current_loc_valid; + + // per-blocksize precomputed data + + // twiddle factors + float *A[2],*B[2],*C[2]; + float *window[2]; + uint16 *bit_reverse[2]; + + // current page/packet/segment streaming info + uint32 serial; // stream serial number for verification + int last_page; + int segment_count; + uint8 segments[255]; + uint8 page_flag; + uint8 bytes_in_seg; + uint8 first_decode; + int next_seg; + int last_seg; // flag that we're on the last segment + int last_seg_which; // what was the segment number of the last seg? + uint32 acc; + int valid_bits; + int packet_bytes; + int end_seg_with_known_loc; + uint32 known_loc_for_packet; + int discard_samples_deferred; + uint32 samples_output; + + // push mode scanning + int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching +#ifndef STB_VORBIS_NO_PUSHDATA_API + CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT]; +#endif + + // sample-access + int channel_buffer_start; + int channel_buffer_end; +}; + +#if defined(STB_VORBIS_NO_PUSHDATA_API) + #define IS_PUSH_MODE(f) FALSE +#elif defined(STB_VORBIS_NO_PULLDATA_API) + #define IS_PUSH_MODE(f) TRUE +#else + #define IS_PUSH_MODE(f) ((f)->push_mode) +#endif + +typedef struct stb_vorbis vorb; + +static int error(vorb *f, enum STBVorbisError e) +{ + f->error = e; + if (!f->eof && e != VORBIS_need_more_data) { + f->error=e; // breakpoint for debugging + } + return 0; +} + + +// these functions are used for allocating temporary memory +// while decoding. if you can afford the stack space, use +// alloca(); otherwise, provide a temp buffer and it will +// allocate out of those. + +#define array_size_required(count,size) (count*(sizeof(void *)+(size))) + +#define temp_alloc(f,size) (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size)) +#define temp_free(f,p) (void)0 +#define temp_alloc_save(f) ((f)->temp_offset) +#define temp_alloc_restore(f,p) ((f)->temp_offset = (p)) + +#define temp_block_array(f,count,size) make_block_array(temp_alloc(f,array_size_required(count,size)), count, size) + +// given a sufficiently large block of memory, make an array of pointers to subblocks of it +static void *make_block_array(void *mem, int count, int size) +{ + int i; + void ** p = (void **) mem; + char *q = (char *) (p + count); + for (i=0; i < count; ++i) { + p[i] = q; + q += size; + } + return p; +} + +static void *setup_malloc(vorb *f, int sz) +{ + sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs. + f->setup_memory_required += sz; + if (f->alloc.alloc_buffer) { + void *p = (char *) f->alloc.alloc_buffer + f->setup_offset; + if (f->setup_offset + sz > f->temp_offset) return NULL; + f->setup_offset += sz; + return p; + } + return sz ? malloc(sz) : NULL; +} + +static void setup_free(vorb *f, void *p) +{ + if (f->alloc.alloc_buffer) return; // do nothing; setup mem is a stack + free(p); +} + +static void *setup_temp_malloc(vorb *f, int sz) +{ + sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs. + if (f->alloc.alloc_buffer) { + if (f->temp_offset - sz < f->setup_offset) return NULL; + f->temp_offset -= sz; + return (char *) f->alloc.alloc_buffer + f->temp_offset; + } + return malloc(sz); +} + +static void setup_temp_free(vorb *f, void *p, int sz) +{ + if (f->alloc.alloc_buffer) { + f->temp_offset += (sz+7)&~7; + return; + } + free(p); +} + +#define CRC32_POLY 0x04c11db7 // from spec + +static uint32 crc_table[256]; +static void crc32_init(void) +{ + int i,j; + uint32 s; + for(i=0; i < 256; i++) { + for (s=(uint32) i << 24, j=0; j < 8; ++j) + s = (s << 1) ^ (s >= (1U<<31) ? CRC32_POLY : 0); + crc_table[i] = s; + } +} + +static __forceinline uint32 crc32_update(uint32 crc, uint8 byte) +{ + return (crc << 8) ^ crc_table[byte ^ (crc >> 24)]; +} + + +// used in setup, and for huffman that doesn't go fast path +static unsigned int bit_reverse(unsigned int n) +{ + n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1); + n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2); + n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4); + n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8); + return (n >> 16) | (n << 16); +} + +static float square(float x) +{ + return x*x; +} + +// this is a weird definition of log2() for which log2(1) = 1, log2(2) = 2, log2(4) = 3 +// as required by the specification. fast(?) implementation from stb.h +// @OPTIMIZE: called multiple times per-packet with "constants"; move to setup +static int ilog(int32 n) +{ + static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 }; + + if (n < 0) return 0; // signed n returns 0 + + // 2 compares if n < 16, 3 compares otherwise (4 if signed or n > 1<<29) + if (n < (1 << 14)) + if (n < (1 << 4)) return 0 + log2_4[n ]; + else if (n < (1 << 9)) return 5 + log2_4[n >> 5]; + else return 10 + log2_4[n >> 10]; + else if (n < (1 << 24)) + if (n < (1 << 19)) return 15 + log2_4[n >> 15]; + else return 20 + log2_4[n >> 20]; + else if (n < (1 << 29)) return 25 + log2_4[n >> 25]; + else return 30 + log2_4[n >> 30]; +} + +#ifndef M_PI + #define M_PI 3.14159265358979323846264f // from CRC +#endif + +// code length assigned to a value with no huffman encoding +#define NO_CODE 255 + +/////////////////////// LEAF SETUP FUNCTIONS ////////////////////////// +// +// these functions are only called at setup, and only a few times +// per file + +static float float32_unpack(uint32 x) +{ + // from the specification + uint32 mantissa = x & 0x1fffff; + uint32 sign = x & 0x80000000; + uint32 exp = (x & 0x7fe00000) >> 21; + double res = sign ? -(double)mantissa : (double)mantissa; + return (float) ldexp((float)res, exp-788); +} + + +// zlib & jpeg huffman tables assume that the output symbols +// can either be arbitrarily arranged, or have monotonically +// increasing frequencies--they rely on the lengths being sorted; +// this makes for a very simple generation algorithm. +// vorbis allows a huffman table with non-sorted lengths. This +// requires a more sophisticated construction, since symbols in +// order do not map to huffman codes "in order". +static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values) +{ + if (!c->sparse) { + c->codewords [symbol] = huff_code; + } else { + c->codewords [count] = huff_code; + c->codeword_lengths[count] = len; + values [count] = symbol; + } +} + +static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values) +{ + int i,k,m=0; + uint32 available[32]; + + memset(available, 0, sizeof(available)); + // find the first entry + for (k=0; k < n; ++k) if (len[k] < NO_CODE) break; + if (k == n) { assert(c->sorted_entries == 0); return TRUE; } + // add to the list + add_entry(c, 0, k, m++, len[k], values); + // add all available leaves + for (i=1; i <= len[k]; ++i) + available[i] = 1U << (32-i); + // note that the above code treats the first case specially, + // but it's really the same as the following code, so they + // could probably be combined (except the initial code is 0, + // and I use 0 in available[] to mean 'empty') + for (i=k+1; i < n; ++i) { + uint32 res; + int z = len[i], y; + if (z == NO_CODE) continue; + // find lowest available leaf (should always be earliest, + // which is what the specification calls for) + // note that this property, and the fact we can never have + // more than one free leaf at a given level, isn't totally + // trivial to prove, but it seems true and the assert never + // fires, so! + while (z > 0 && !available[z]) --z; + if (z == 0) { return FALSE; } + res = available[z]; + assert(z >= 0 && z < 32); + available[z] = 0; + add_entry(c, bit_reverse(res), i, m++, len[i], values); + // propagate availability up the tree + if (z != len[i]) { + assert(len[i] >= 0 && len[i] < 32); + for (y=len[i]; y > z; --y) { + assert(available[y] == 0); + available[y] = res + (1 << (32-y)); + } + } + } + return TRUE; +} + +// accelerated huffman table allows fast O(1) match of all symbols +// of length <= STB_VORBIS_FAST_HUFFMAN_LENGTH +static void compute_accelerated_huffman(Codebook *c) +{ + int i, len; + for (i=0; i < FAST_HUFFMAN_TABLE_SIZE; ++i) + c->fast_huffman[i] = -1; + + len = c->sparse ? c->sorted_entries : c->entries; + #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT + if (len > 32767) len = 32767; // largest possible value we can encode! + #endif + for (i=0; i < len; ++i) { + if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) { + uint32 z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i]; + // set table entries for all bit combinations in the higher bits + while (z < FAST_HUFFMAN_TABLE_SIZE) { + c->fast_huffman[z] = i; + z += 1 << c->codeword_lengths[i]; + } + } + } +} + +#ifdef _MSC_VER +#define STBV_CDECL __cdecl +#else +#define STBV_CDECL +#endif + +static int STBV_CDECL uint32_compare(const void *p, const void *q) +{ + uint32 x = * (uint32 *) p; + uint32 y = * (uint32 *) q; + return x < y ? -1 : x > y; +} + +static int include_in_sort(Codebook *c, uint8 len) +{ + if (c->sparse) { assert(len != NO_CODE); return TRUE; } + if (len == NO_CODE) return FALSE; + if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE; + return FALSE; +} + +// if the fast table above doesn't work, we want to binary +// search them... need to reverse the bits +static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values) +{ + int i, len; + // build a list of all the entries + // OPTIMIZATION: don't include the short ones, since they'll be caught by FAST_HUFFMAN. + // this is kind of a frivolous optimization--I don't see any performance improvement, + // but it's like 4 extra lines of code, so. + if (!c->sparse) { + int k = 0; + for (i=0; i < c->entries; ++i) + if (include_in_sort(c, lengths[i])) + c->sorted_codewords[k++] = bit_reverse(c->codewords[i]); + assert(k == c->sorted_entries); + } else { + for (i=0; i < c->sorted_entries; ++i) + c->sorted_codewords[i] = bit_reverse(c->codewords[i]); + } + + qsort(c->sorted_codewords, c->sorted_entries, sizeof(c->sorted_codewords[0]), uint32_compare); + c->sorted_codewords[c->sorted_entries] = 0xffffffff; + + len = c->sparse ? c->sorted_entries : c->entries; + // now we need to indicate how they correspond; we could either + // #1: sort a different data structure that says who they correspond to + // #2: for each sorted entry, search the original list to find who corresponds + // #3: for each original entry, find the sorted entry + // #1 requires extra storage, #2 is slow, #3 can use binary search! + for (i=0; i < len; ++i) { + int huff_len = c->sparse ? lengths[values[i]] : lengths[i]; + if (include_in_sort(c,huff_len)) { + uint32 code = bit_reverse(c->codewords[i]); + int x=0, n=c->sorted_entries; + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + assert(c->sorted_codewords[x] == code); + if (c->sparse) { + c->sorted_values[x] = values[i]; + c->codeword_lengths[x] = huff_len; + } else { + c->sorted_values[x] = i; + } + } + } +} + +// only run while parsing the header (3 times) +static int vorbis_validate(uint8 *data) +{ + static uint8 vorbis[6] = { 'v', 'o', 'r', 'b', 'i', 's' }; + return memcmp(data, vorbis, 6) == 0; +} + +// called from setup only, once per code book +// (formula implied by specification) +static int lookup1_values(int entries, int dim) +{ + int r = (int) floor(exp((float) log((float) entries) / dim)); + if ((int) floor(pow((float) r+1, dim)) <= entries) // (int) cast for MinGW warning; + ++r; // floor() to avoid _ftol() when non-CRT + if (pow((float) r+1, dim) <= entries) + return -1; + if ((int) floor(pow((float) r, dim)) > entries) + return -1; + return r; +} + +// called twice per file +static void compute_twiddle_factors(int n, float *A, float *B, float *C) +{ + int n4 = n >> 2, n8 = n >> 3; + int k,k2; + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2) * 0.5f; + B[k2+1] = (float) sin((k2+1)*M_PI/n/2) * 0.5f; + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } +} + +static void compute_window(int n, float *window) +{ + int n2 = n >> 1, i; + for (i=0; i < n2; ++i) + window[i] = (float) sin(0.5 * M_PI * square((float) sin((i - 0 + 0.5) / n2 * 0.5 * M_PI))); +} + +static void compute_bitreverse(int n, uint16 *rev) +{ + int ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + int i, n8 = n >> 3; + for (i=0; i < n8; ++i) + rev[i] = (bit_reverse(i) >> (32-ld+3)) << 2; +} + +static int init_blocksize(vorb *f, int b, int n) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3; + f->A[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->B[b] = (float *) setup_malloc(f, sizeof(float) * n2); + f->C[b] = (float *) setup_malloc(f, sizeof(float) * n4); + if (!f->A[b] || !f->B[b] || !f->C[b]) return error(f, VORBIS_outofmem); + compute_twiddle_factors(n, f->A[b], f->B[b], f->C[b]); + f->window[b] = (float *) setup_malloc(f, sizeof(float) * n2); + if (!f->window[b]) return error(f, VORBIS_outofmem); + compute_window(n, f->window[b]); + f->bit_reverse[b] = (uint16 *) setup_malloc(f, sizeof(uint16) * n8); + if (!f->bit_reverse[b]) return error(f, VORBIS_outofmem); + compute_bitreverse(n, f->bit_reverse[b]); + return TRUE; +} + +static void neighbors(uint16 *x, int n, int *plow, int *phigh) +{ + int low = -1; + int high = 65536; + int i; + for (i=0; i < n; ++i) { + if (x[i] > low && x[i] < x[n]) { *plow = i; low = x[i]; } + if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; } + } +} + +// this has been repurposed so y is now the original index instead of y +typedef struct +{ + uint16 x,id; +} stbv__floor_ordering; + +static int STBV_CDECL point_compare(const void *p, const void *q) +{ + stbv__floor_ordering *a = (stbv__floor_ordering *) p; + stbv__floor_ordering *b = (stbv__floor_ordering *) q; + return a->x < b->x ? -1 : a->x > b->x; +} + +// +/////////////////////// END LEAF SETUP FUNCTIONS ////////////////////////// + + +#if defined(STB_VORBIS_NO_STDIO) + #define USE_MEMORY(z) TRUE +#else + #define USE_MEMORY(z) ((z)->stream) +#endif + +static uint8 get8(vorb *z) +{ + if (USE_MEMORY(z)) { + if (z->stream >= z->stream_end) { z->eof = TRUE; return 0; } + return *z->stream++; + } + + #ifndef STB_VORBIS_NO_STDIO + { + int c = fgetc(z->f); + if (c == EOF) { z->eof = TRUE; return 0; } + return c; + } + #endif +} + +static uint32 get32(vorb *f) +{ + uint32 x; + x = get8(f); + x += get8(f) << 8; + x += get8(f) << 16; + x += (uint32) get8(f) << 24; + return x; +} + +static int getn(vorb *z, uint8 *data, int n) +{ + if (USE_MEMORY(z)) { + if (z->stream+n > z->stream_end) { z->eof = 1; return 0; } + memcpy(data, z->stream, n); + z->stream += n; + return 1; + } + + #ifndef STB_VORBIS_NO_STDIO + if (fread(data, n, 1, z->f) == 1) + return 1; + else { + z->eof = 1; + return 0; + } + #endif +} + +static void skip(vorb *z, int n) +{ + if (USE_MEMORY(z)) { + z->stream += n; + if (z->stream >= z->stream_end) z->eof = 1; + return; + } + #ifndef STB_VORBIS_NO_STDIO + { + long x = ftell(z->f); + fseek(z->f, x+n, SEEK_SET); + } + #endif +} + +static int set_file_offset(stb_vorbis *f, unsigned int loc) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + f->eof = 0; + if (USE_MEMORY(f)) { + if (f->stream_start + loc >= f->stream_end || f->stream_start + loc < f->stream_start) { + f->stream = f->stream_end; + f->eof = 1; + return 0; + } else { + f->stream = f->stream_start + loc; + return 1; + } + } + #ifndef STB_VORBIS_NO_STDIO + if (loc + f->f_start < loc || loc >= 0x80000000) { + loc = 0x7fffffff; + f->eof = 1; + } else { + loc += f->f_start; + } + if (!fseek(f->f, loc, SEEK_SET)) + return 1; + f->eof = 1; + fseek(f->f, f->f_start, SEEK_END); + return 0; + #endif +} + + +static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 }; + +static int capture_pattern(vorb *f) +{ + if (0x4f != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x67 != get8(f)) return FALSE; + if (0x53 != get8(f)) return FALSE; + return TRUE; +} + +#define PAGEFLAG_continued_packet 1 +#define PAGEFLAG_first_page 2 +#define PAGEFLAG_last_page 4 + +static int start_page_no_capturepattern(vorb *f) +{ + uint32 loc0,loc1,n; + if (f->first_decode && !IS_PUSH_MODE(f)) { + f->p_first.page_start = stb_vorbis_get_file_offset(f) - 4; + } + // stream structure version + if (0 != get8(f)) return error(f, VORBIS_invalid_stream_structure_version); + // header flag + f->page_flag = get8(f); + // absolute granule position + loc0 = get32(f); + loc1 = get32(f); + // @TODO: validate loc0,loc1 as valid positions? + // stream serial number -- vorbis doesn't interleave, so discard + get32(f); + //if (f->serial != get32(f)) return error(f, VORBIS_incorrect_stream_serial_number); + // page sequence number + n = get32(f); + f->last_page = n; + // CRC32 + get32(f); + // page_segments + f->segment_count = get8(f); + if (!getn(f, f->segments, f->segment_count)) + return error(f, VORBIS_unexpected_eof); + // assume we _don't_ know any the sample position of any segments + f->end_seg_with_known_loc = -2; + if (loc0 != ~0U || loc1 != ~0U) { + int i; + // determine which packet is the last one that will complete + for (i=f->segment_count-1; i >= 0; --i) + if (f->segments[i] < 255) + break; + // 'i' is now the index of the _last_ segment of a packet that ends + if (i >= 0) { + f->end_seg_with_known_loc = i; + f->known_loc_for_packet = loc0; + } + } + if (f->first_decode) { + int i,len; + len = 0; + for (i=0; i < f->segment_count; ++i) + len += f->segments[i]; + len += 27 + f->segment_count; + f->p_first.page_end = f->p_first.page_start + len; + f->p_first.last_decoded_sample = loc0; + } + f->next_seg = 0; + return TRUE; +} + +static int start_page(vorb *f) +{ + if (!capture_pattern(f)) return error(f, VORBIS_missing_capture_pattern); + return start_page_no_capturepattern(f); +} + +static int start_packet(vorb *f) +{ + while (f->next_seg == -1) { + if (!start_page(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) + return error(f, VORBIS_continued_packet_flag_invalid); + } + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + // f->next_seg is now valid + return TRUE; +} + +static int maybe_start_packet(vorb *f) +{ + if (f->next_seg == -1) { + int x = get8(f); + if (f->eof) return FALSE; // EOF at page boundary is not an error! + if (0x4f != x ) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (0x53 != get8(f)) return error(f, VORBIS_missing_capture_pattern); + if (!start_page_no_capturepattern(f)) return FALSE; + if (f->page_flag & PAGEFLAG_continued_packet) { + // set up enough state that we can read this packet if we want, + // e.g. during recovery + f->last_seg = FALSE; + f->bytes_in_seg = 0; + return error(f, VORBIS_continued_packet_flag_invalid); + } + } + return start_packet(f); +} + +static int next_segment(vorb *f) +{ + int len; + if (f->last_seg) return 0; + if (f->next_seg == -1) { + f->last_seg_which = f->segment_count-1; // in case start_page fails + if (!start_page(f)) { f->last_seg = 1; return 0; } + if (!(f->page_flag & PAGEFLAG_continued_packet)) return error(f, VORBIS_continued_packet_flag_invalid); + } + len = f->segments[f->next_seg++]; + if (len < 255) { + f->last_seg = TRUE; + f->last_seg_which = f->next_seg-1; + } + if (f->next_seg >= f->segment_count) + f->next_seg = -1; + assert(f->bytes_in_seg == 0); + f->bytes_in_seg = len; + return len; +} + +#define EOP (-1) +#define INVALID_BITS (-1) + +static int get8_packet_raw(vorb *f) +{ + if (!f->bytes_in_seg) { // CLANG! + if (f->last_seg) return EOP; + else if (!next_segment(f)) return EOP; + } + assert(f->bytes_in_seg > 0); + --f->bytes_in_seg; + ++f->packet_bytes; + return get8(f); +} + +static int get8_packet(vorb *f) +{ + int x = get8_packet_raw(f); + f->valid_bits = 0; + return x; +} + +static int get32_packet(vorb *f) +{ + uint32 x; + x = get8_packet(f); + x += get8_packet(f) << 8; + x += get8_packet(f) << 16; + x += (uint32) get8_packet(f) << 24; + return x; +} + +static void flush_packet(vorb *f) +{ + while (get8_packet_raw(f) != EOP); +} + +// @OPTIMIZE: this is the secondary bit decoder, so it's probably not as important +// as the huffman decoder? +static uint32 get_bits(vorb *f, int n) +{ + uint32 z; + + if (f->valid_bits < 0) return 0; + if (f->valid_bits < n) { + if (n > 24) { + // the accumulator technique below would not work correctly in this case + z = get_bits(f, 24); + z += get_bits(f, n-24) << 24; + return z; + } + if (f->valid_bits == 0) f->acc = 0; + while (f->valid_bits < n) { + int z = get8_packet_raw(f); + if (z == EOP) { + f->valid_bits = INVALID_BITS; + return 0; + } + f->acc += z << f->valid_bits; + f->valid_bits += 8; + } + } + + assert(f->valid_bits >= n); + z = f->acc & ((1 << n)-1); + f->acc >>= n; + f->valid_bits -= n; + return z; +} + +// @OPTIMIZE: primary accumulator for huffman +// expand the buffer to as many bits as possible without reading off end of packet +// it might be nice to allow f->valid_bits and f->acc to be stored in registers, +// e.g. cache them locally and decode locally +static __forceinline void prep_huffman(vorb *f) +{ + if (f->valid_bits <= 24) { + if (f->valid_bits == 0) f->acc = 0; + do { + int z; + if (f->last_seg && !f->bytes_in_seg) return; + z = get8_packet_raw(f); + if (z == EOP) return; + f->acc += (unsigned) z << f->valid_bits; + f->valid_bits += 8; + } while (f->valid_bits <= 24); + } +} + +enum +{ + VORBIS_packet_id = 1, + VORBIS_packet_comment = 3, + VORBIS_packet_setup = 5 +}; + +static int codebook_decode_scalar_raw(vorb *f, Codebook *c) +{ + int i; + prep_huffman(f); + + if (c->codewords == NULL && c->sorted_codewords == NULL) + return -1; + + // cases to use binary search: sorted_codewords && !c->codewords + // sorted_codewords && c->entries > 8 + if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) { + // binary search + uint32 code = bit_reverse(f->acc); + int x=0, n=c->sorted_entries, len; + + while (n > 1) { + // invariant: sc[x] <= code < sc[x+n] + int m = x + (n >> 1); + if (c->sorted_codewords[m] <= code) { + x = m; + n -= (n>>1); + } else { + n >>= 1; + } + } + // x is now the sorted index + if (!c->sparse) x = c->sorted_values[x]; + // x is now sorted index if sparse, or symbol otherwise + len = c->codeword_lengths[x]; + if (f->valid_bits >= len) { + f->acc >>= len; + f->valid_bits -= len; + return x; + } + + f->valid_bits = 0; + return -1; + } + + // if small, linear search + assert(!c->sparse); + for (i=0; i < c->entries; ++i) { + if (c->codeword_lengths[i] == NO_CODE) continue; + if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) { + if (f->valid_bits >= c->codeword_lengths[i]) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + return i; + } + f->valid_bits = 0; + return -1; + } + } + + error(f, VORBIS_invalid_stream); + f->valid_bits = 0; + return -1; +} + +#ifndef STB_VORBIS_NO_INLINE_DECODE + +#define DECODE_RAW(var, f,c) \ + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) \ + prep_huffman(f); \ + var = f->acc & FAST_HUFFMAN_TABLE_MASK; \ + var = c->fast_huffman[var]; \ + if (var >= 0) { \ + int n = c->codeword_lengths[var]; \ + f->acc >>= n; \ + f->valid_bits -= n; \ + if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \ + } else { \ + var = codebook_decode_scalar_raw(f,c); \ + } + +#else + +static int codebook_decode_scalar(vorb *f, Codebook *c) +{ + int i; + if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH) + prep_huffman(f); + // fast huffman table lookup + i = f->acc & FAST_HUFFMAN_TABLE_MASK; + i = c->fast_huffman[i]; + if (i >= 0) { + f->acc >>= c->codeword_lengths[i]; + f->valid_bits -= c->codeword_lengths[i]; + if (f->valid_bits < 0) { f->valid_bits = 0; return -1; } + return i; + } + return codebook_decode_scalar_raw(f,c); +} + +#define DECODE_RAW(var,f,c) var = codebook_decode_scalar(f,c); + +#endif + +#define DECODE(var,f,c) \ + DECODE_RAW(var,f,c) \ + if (c->sparse) var = c->sorted_values[var]; + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + #define DECODE_VQ(var,f,c) DECODE_RAW(var,f,c) +#else + #define DECODE_VQ(var,f,c) DECODE(var,f,c) +#endif + + + + + + +// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case +// where we avoid one addition +#define CODEBOOK_ELEMENT(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_FAST(c,off) (c->multiplicands[off]) +#define CODEBOOK_ELEMENT_BASE(c) (0) + +static int codebook_decode_start(vorb *f, Codebook *c) +{ + int z = -1; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) + error(f, VORBIS_invalid_stream); + else { + DECODE_VQ(z,f,c); + if (c->sparse) assert(z < c->sorted_entries); + if (z < 0) { // check for EOP + if (!f->bytes_in_seg) + if (f->last_seg) + return z; + error(f, VORBIS_invalid_stream); + } + } + return z; +} + +static int codebook_decode(vorb *f, Codebook *c, float *output, int len) +{ + int i,z = codebook_decode_start(f,c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + float last = CODEBOOK_ELEMENT_BASE(c); + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i] += val; + if (c->sequence_p) last = val + c->minimum_value; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + if (c->sequence_p) { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i] += val; + last = val + c->minimum_value; + } + } else { + float last = CODEBOOK_ELEMENT_BASE(c); + for (i=0; i < len; ++i) { + output[i] += CODEBOOK_ELEMENT_FAST(c,z+i) + last; + } + } + + return TRUE; +} + +static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step) +{ + int i,z = codebook_decode_start(f,c); + float last = CODEBOOK_ELEMENT_BASE(c); + if (z < 0) return FALSE; + if (len > c->dimensions) len = c->dimensions; + +#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < len; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + return TRUE; + } +#endif + + z *= c->dimensions; + for (i=0; i < len; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + output[i*step] += val; + if (c->sequence_p) last = val; + } + + return TRUE; +} + +static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode) +{ + int c_inter = *c_inter_p; + int p_inter = *p_inter_p; + int i,z, effective = c->dimensions; + + // type 0 is only legal in a scalar context + if (c->lookup_type == 0) return error(f, VORBIS_invalid_stream); + + while (total_decode > 0) { + float last = CODEBOOK_ELEMENT_BASE(c); + DECODE_VQ(z,f,c); + #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + assert(!c->sparse || z < c->sorted_entries); + #endif + if (z < 0) { + if (!f->bytes_in_seg) + if (f->last_seg) return FALSE; + return error(f, VORBIS_invalid_stream); + } + + // if this will take us off the end of the buffers, stop short! + // we check by computing the length of the virtual interleaved + // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter), + // and the length we'll be using (effective) + if (c_inter + p_inter*ch + effective > len * ch) { + effective = len*ch - (p_inter*ch - c_inter); + } + + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int div = 1; + for (i=0; i < effective; ++i) { + int off = (z / div) % c->lookup_values; + float val = CODEBOOK_ELEMENT_FAST(c,off) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + if (c->sequence_p) last = val; + div *= c->lookup_values; + } + } else + #endif + { + z *= c->dimensions; + if (c->sequence_p) { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + last = val; + } + } else { + for (i=0; i < effective; ++i) { + float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last; + if (outputs[c_inter]) + outputs[c_inter][p_inter] += val; + if (++c_inter == ch) { c_inter = 0; ++p_inter; } + } + } + } + + total_decode -= effective; + } + *c_inter_p = c_inter; + *p_inter_p = p_inter; + return TRUE; +} + +static int predict_point(int x, int x0, int x1, int y0, int y1) +{ + int dy = y1 - y0; + int adx = x1 - x0; + // @OPTIMIZE: force int division to round in the right direction... is this necessary on x86? + int err = abs(dy) * (x - x0); + int off = err / adx; + return dy < 0 ? y0 - off : y0 + off; +} + +// the following table is block-copied from the specification +static float inverse_db_table[256] = +{ + 1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f, + 1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f, + 1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.1287530e-07f, + 2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f, + 2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f, + 3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f, + 4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f, + 6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f, + 7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f, + 1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f, + 1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f, + 1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f, + 2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f, + 2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f, + 3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f, + 4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f, + 5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f, + 7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f, + 9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f, + 1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f, + 1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f, + 2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f, + 2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f, + 3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f, + 4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f, + 5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f, + 7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f, + 9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f, + 0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f, + 0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f, + 0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f, + 0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f, + 0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f, + 0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f, + 0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f, + 0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f, + 0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f, + 0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f, + 0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f, + 0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f, + 0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f, + 0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f, + 0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f, + 0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f, + 0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f, + 0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f, + 0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f, + 0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f, + 0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f, + 0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f, + 0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f, + 0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f, + 0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f, + 0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f, + 0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f, + 0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f, + 0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f, + 0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f, + 0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f, + 0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f, + 0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f, + 0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f, + 0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f, + 0.82788260f, 0.88168307f, 0.9389798f, 1.0f +}; + + +// @OPTIMIZE: if you want to replace this bresenham line-drawing routine, +// note that you must produce bit-identical output to decode correctly; +// this specific sequence of operations is specified in the spec (it's +// drawing integer-quantized frequency-space lines that the encoder +// expects to be exactly the same) +// ... also, isn't the whole point of Bresenham's algorithm to NOT +// have to divide in the setup? sigh. +#ifndef STB_VORBIS_NO_DEFER_FLOOR +#define LINE_OP(a,b) a *= b +#else +#define LINE_OP(a,b) a = b +#endif + +#ifdef STB_VORBIS_DIVIDE_TABLE +#define DIVTAB_NUMER 32 +#define DIVTAB_DENOM 64 +int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB +#endif + +static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n) +{ + int dy = y1 - y0; + int adx = x1 - x0; + int ady = abs(dy); + int base; + int x=x0,y=y0; + int err = 0; + int sy; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) { + if (dy < 0) { + base = -integer_divide_table[ady][adx]; + sy = base-1; + } else { + base = integer_divide_table[ady][adx]; + sy = base+1; + } + } else { + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; + } +#else + base = dy / adx; + if (dy < 0) + sy = base - 1; + else + sy = base+1; +#endif + ady -= abs(base) * adx; + if (x1 > n) x1 = n; + if (x < x1) { + LINE_OP(output[x], inverse_db_table[y&255]); + for (++x; x < x1; ++x) { + err += ady; + if (err >= adx) { + err -= adx; + y += sy; + } else + y += base; + LINE_OP(output[x], inverse_db_table[y&255]); + } + } +} + +static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype) +{ + int k; + if (rtype == 0) { + int step = n / book->dimensions; + for (k=0; k < step; ++k) + if (!codebook_decode_step(f, book, target+offset+k, n-offset-k, step)) + return FALSE; + } else { + for (k=0; k < n; ) { + if (!codebook_decode(f, book, target+offset, n-k)) + return FALSE; + k += book->dimensions; + offset += book->dimensions; + } + } + return TRUE; +} + +// n is 1/2 of the blocksize -- +// specification: "Correct per-vector decode length is [n]/2" +static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode) +{ + int i,j,pass; + Residue *r = f->residue_config + rn; + int rtype = f->residue_types[rn]; + int c = r->classbook; + int classwords = f->codebooks[c].dimensions; + unsigned int actual_size = rtype == 2 ? n*2 : n; + unsigned int limit_r_begin = (r->begin < actual_size ? r->begin : actual_size); + unsigned int limit_r_end = (r->end < actual_size ? r->end : actual_size); + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + int temp_alloc_point = temp_alloc_save(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + uint8 ***part_classdata = (uint8 ***) temp_block_array(f,f->channels, part_read * sizeof(**part_classdata)); + #else + int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications)); + #endif + + CHECK(f); + + for (i=0; i < ch; ++i) + if (!do_not_decode[i]) + memset(residue_buffers[i], 0, sizeof(float) * n); + + if (rtype == 2 && ch != 1) { + for (j=0; j < ch; ++j) + if (!do_not_decode[j]) + break; + if (j == ch) + goto done; + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set = 0; + if (ch == 2) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = (z & 1), p_inter = z>>1; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #else + // saves 1% + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + #endif + } else { + z += r->part_size; + c_inter = z & 1; + p_inter = z >> 1; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } else if (ch > 2) { + while (pcount < part_read) { + int z = r->begin + pcount*r->part_size; + int c_inter = z % ch, p_inter = z/ch; + if (pass == 0) { + Codebook *c = f->codebooks+r->classbook; + int q; + DECODE(q,f,c); + if (q == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[0][class_set] = r->classdata[q]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[0][i+pcount] = q % r->classifications; + q /= r->classifications; + } + #endif + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + int z = r->begin + pcount*r->part_size; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[0][class_set][i]; + #else + int c = classifications[0][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + Codebook *book = f->codebooks + b; + if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size)) + goto done; + } else { + z += r->part_size; + c_inter = z % ch; + p_inter = z / ch; + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + } + goto done; + } + CHECK(f); + + for (pass=0; pass < 8; ++pass) { + int pcount = 0, class_set=0; + while (pcount < part_read) { + if (pass == 0) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + Codebook *c = f->codebooks+r->classbook; + int temp; + DECODE(temp,f,c); + if (temp == EOP) goto done; + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + part_classdata[j][class_set] = r->classdata[temp]; + #else + for (i=classwords-1; i >= 0; --i) { + classifications[j][i+pcount] = temp % r->classifications; + temp /= r->classifications; + } + #endif + } + } + } + for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) { + for (j=0; j < ch; ++j) { + if (!do_not_decode[j]) { + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + int c = part_classdata[j][class_set][i]; + #else + int c = classifications[j][pcount]; + #endif + int b = r->residue_books[c][pass]; + if (b >= 0) { + float *target = residue_buffers[j]; + int offset = r->begin + pcount * r->part_size; + int n = r->part_size; + Codebook *book = f->codebooks + b; + if (!residue_decode(f, book, target, offset, n, rtype)) + goto done; + } + } + } + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + ++class_set; + #endif + } + } + done: + CHECK(f); + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + temp_free(f,part_classdata); + #else + temp_free(f,classifications); + #endif + temp_alloc_restore(f,temp_alloc_point); +} + + +#if 0 +// slow way for debugging +void inverse_mdct_slow(float *buffer, int n) +{ + int i,j; + int n2 = n >> 1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + // formula from paper: + //acc += n/4.0f * x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + // formula from wikipedia + //acc += 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + // these are equivalent, except the formula from the paper inverts the multiplier! + // however, what actually works is NO MULTIPLIER!?! + //acc += 64 * 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5)); + acc += x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1)); + buffer[i] = acc; + } + free(x); +} +#elif 0 +// same as above, but just barely able to run in real time on modern machines +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + float mcos[16384]; + int i,j; + int n2 = n >> 1, nmask = (n << 2) -1; + float *x = (float *) malloc(sizeof(*x) * n2); + memcpy(x, buffer, sizeof(*x) * n2); + for (i=0; i < 4*n; ++i) + mcos[i] = (float) cos(M_PI / 2 * i / n); + + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n2; ++j) + acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask]; + buffer[i] = acc; + } + free(x); +} +#elif 0 +// transform to use a slow dct-iv; this is STILL basically trivial, +// but only requires half as many ops +void dct_iv_slow(float *buffer, int n) +{ + float mcos[16384]; + float x[2048]; + int i,j; + int n2 = n >> 1, nmask = (n << 3) - 1; + memcpy(x, buffer, sizeof(*x) * n); + for (i=0; i < 8*n; ++i) + mcos[i] = (float) cos(M_PI / 4 * i / n); + for (i=0; i < n; ++i) { + float acc = 0; + for (j=0; j < n; ++j) + acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask]; + buffer[i] = acc; + } +} + +void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype) +{ + int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4; + float temp[4096]; + + memcpy(temp, buffer, n2 * sizeof(float)); + dct_iv_slow(temp, n2); // returns -c'-d, a-b' + + for (i=0; i < n4 ; ++i) buffer[i] = temp[i+n4]; // a-b' + for ( ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1]; // b-a', c+d' + for ( ; i < n ; ++i) buffer[i] = -temp[i - n3_4]; // c'+d +} +#endif + +#ifndef LIBVORBIS_MDCT +#define LIBVORBIS_MDCT 0 +#endif + +#if LIBVORBIS_MDCT +// directly call the vorbis MDCT using an interface documented +// by Jeff Roberts... useful for performance comparison +typedef struct +{ + int n; + int log2n; + + float *trig; + int *bitrev; + + float scale; +} mdct_lookup; + +extern void mdct_init(mdct_lookup *lookup, int n); +extern void mdct_clear(mdct_lookup *l); +extern void mdct_backward(mdct_lookup *init, float *in, float *out); + +mdct_lookup M1,M2; + +void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + mdct_lookup *M; + if (M1.n == n) M = &M1; + else if (M2.n == n) M = &M2; + else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; } + else { + if (M2.n) __asm int 3; + mdct_init(&M2, n); + M = &M2; + } + + mdct_backward(M, buffer, buffer); +} +#endif + + +// the following were split out into separate functions while optimizing; +// they could be pushed back up but eh. __forceinline showed no change; +// they're probably already being inlined. +static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A) +{ + float *ee0 = e + i_off; + float *ee2 = ee0 + k_off; + int i; + + assert((n & 3) == 0); + for (i=(n>>2); i > 0; --i) { + float k00_20, k01_21; + k00_20 = ee0[ 0] - ee2[ 0]; + k01_21 = ee0[-1] - ee2[-1]; + ee0[ 0] += ee2[ 0];//ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] += ee2[-1];//ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-1] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-2] - ee2[-2]; + k01_21 = ee0[-3] - ee2[-3]; + ee0[-2] += ee2[-2];//ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] += ee2[-3];//ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-3] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-4] - ee2[-4]; + k01_21 = ee0[-5] - ee2[-5]; + ee0[-4] += ee2[-4];//ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] += ee2[-5];//ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-5] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + + k00_20 = ee0[-6] - ee2[-6]; + k01_21 = ee0[-7] - ee2[-7]; + ee0[-6] += ee2[-6];//ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] += ee2[-7];//ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = k00_20 * A[0] - k01_21 * A[1]; + ee2[-7] = k01_21 * A[0] + k00_20 * A[1]; + A += 8; + ee0 -= 8; + ee2 -= 8; + } +} + +static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1) +{ + int i; + float k00_20, k01_21; + + float *e0 = e + d0; + float *e2 = e0 + k_off; + + for (i=lim >> 2; i > 0; --i) { + k00_20 = e0[-0] - e2[-0]; + k01_21 = e0[-1] - e2[-1]; + e0[-0] += e2[-0];//e0[-0] = e0[-0] + e2[-0]; + e0[-1] += e2[-1];//e0[-1] = e0[-1] + e2[-1]; + e2[-0] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-1] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-2] - e2[-2]; + k01_21 = e0[-3] - e2[-3]; + e0[-2] += e2[-2];//e0[-2] = e0[-2] + e2[-2]; + e0[-3] += e2[-3];//e0[-3] = e0[-3] + e2[-3]; + e2[-2] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-3] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-4] - e2[-4]; + k01_21 = e0[-5] - e2[-5]; + e0[-4] += e2[-4];//e0[-4] = e0[-4] + e2[-4]; + e0[-5] += e2[-5];//e0[-5] = e0[-5] + e2[-5]; + e2[-4] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-5] = (k01_21)*A[0] + (k00_20) * A[1]; + + A += k1; + + k00_20 = e0[-6] - e2[-6]; + k01_21 = e0[-7] - e2[-7]; + e0[-6] += e2[-6];//e0[-6] = e0[-6] + e2[-6]; + e0[-7] += e2[-7];//e0[-7] = e0[-7] + e2[-7]; + e2[-6] = (k00_20)*A[0] - (k01_21) * A[1]; + e2[-7] = (k01_21)*A[0] + (k00_20) * A[1]; + + e0 -= 8; + e2 -= 8; + + A += k1; + } +} + +static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0) +{ + int i; + float A0 = A[0]; + float A1 = A[0+1]; + float A2 = A[0+a_off]; + float A3 = A[0+a_off+1]; + float A4 = A[0+a_off*2+0]; + float A5 = A[0+a_off*2+1]; + float A6 = A[0+a_off*3+0]; + float A7 = A[0+a_off*3+1]; + + float k00,k11; + + float *ee0 = e +i_off; + float *ee2 = ee0+k_off; + + for (i=n; i > 0; --i) { + k00 = ee0[ 0] - ee2[ 0]; + k11 = ee0[-1] - ee2[-1]; + ee0[ 0] = ee0[ 0] + ee2[ 0]; + ee0[-1] = ee0[-1] + ee2[-1]; + ee2[ 0] = (k00) * A0 - (k11) * A1; + ee2[-1] = (k11) * A0 + (k00) * A1; + + k00 = ee0[-2] - ee2[-2]; + k11 = ee0[-3] - ee2[-3]; + ee0[-2] = ee0[-2] + ee2[-2]; + ee0[-3] = ee0[-3] + ee2[-3]; + ee2[-2] = (k00) * A2 - (k11) * A3; + ee2[-3] = (k11) * A2 + (k00) * A3; + + k00 = ee0[-4] - ee2[-4]; + k11 = ee0[-5] - ee2[-5]; + ee0[-4] = ee0[-4] + ee2[-4]; + ee0[-5] = ee0[-5] + ee2[-5]; + ee2[-4] = (k00) * A4 - (k11) * A5; + ee2[-5] = (k11) * A4 + (k00) * A5; + + k00 = ee0[-6] - ee2[-6]; + k11 = ee0[-7] - ee2[-7]; + ee0[-6] = ee0[-6] + ee2[-6]; + ee0[-7] = ee0[-7] + ee2[-7]; + ee2[-6] = (k00) * A6 - (k11) * A7; + ee2[-7] = (k11) * A6 + (k00) * A7; + + ee0 -= k0; + ee2 -= k0; + } +} + +static __forceinline void iter_54(float *z) +{ + float k00,k11,k22,k33; + float y0,y1,y2,y3; + + k00 = z[ 0] - z[-4]; + y0 = z[ 0] + z[-4]; + y2 = z[-2] + z[-6]; + k22 = z[-2] - z[-6]; + + z[-0] = y0 + y2; // z0 + z4 + z2 + z6 + z[-2] = y0 - y2; // z0 + z4 - z2 - z6 + + // done with y0,y2 + + k33 = z[-3] - z[-7]; + + z[-4] = k00 + k33; // z0 - z4 + z3 - z7 + z[-6] = k00 - k33; // z0 - z4 - z3 + z7 + + // done with k33 + + k11 = z[-1] - z[-5]; + y1 = z[-1] + z[-5]; + y3 = z[-3] + z[-7]; + + z[-1] = y1 + y3; // z1 + z5 + z3 + z7 + z[-3] = y1 - y3; // z1 + z5 - z3 - z7 + z[-5] = k11 - k22; // z1 - z5 + z2 - z6 + z[-7] = k11 + k22; // z1 - z5 - z2 + z6 +} + +static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n) +{ + int a_off = base_n >> 3; + float A2 = A[0+a_off]; + float *z = e + i_off; + float *base = z - 16 * n; + + while (z > base) { + float k00,k11; + + k00 = z[-0] - z[-8]; + k11 = z[-1] - z[-9]; + z[-0] = z[-0] + z[-8]; + z[-1] = z[-1] + z[-9]; + z[-8] = k00; + z[-9] = k11 ; + + k00 = z[ -2] - z[-10]; + k11 = z[ -3] - z[-11]; + z[ -2] = z[ -2] + z[-10]; + z[ -3] = z[ -3] + z[-11]; + z[-10] = (k00+k11) * A2; + z[-11] = (k11-k00) * A2; + + k00 = z[-12] - z[ -4]; // reverse to avoid a unary negation + k11 = z[ -5] - z[-13]; + z[ -4] = z[ -4] + z[-12]; + z[ -5] = z[ -5] + z[-13]; + z[-12] = k11; + z[-13] = k00; + + k00 = z[-14] - z[ -6]; // reverse to avoid a unary negation + k11 = z[ -7] - z[-15]; + z[ -6] = z[ -6] + z[-14]; + z[ -7] = z[ -7] + z[-15]; + z[-14] = (k00+k11) * A2; + z[-15] = (k00-k11) * A2; + + iter_54(z); + iter_54(z-8); + z -= 16; + } +} + +static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype) +{ + int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int ld; + // @OPTIMIZE: reduce register pressure by using fewer variables? + int save_point = temp_alloc_save(f); + float *buf2 = (float *) temp_alloc(f, n2 * sizeof(*buf2)); + float *u=NULL,*v=NULL; + // twiddle factors + float *A = f->A[blocktype]; + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // See notes about bugs in that paper in less-optimal implementation 'inverse_mdct_old' after this function. + + // kernel from paper + + + // merged: + // copy and reflect spectral data + // step 0 + + // note that it turns out that the items added together during + // this step are, in fact, being added to themselves (as reflected + // by step 0). inexplicable inefficiency! this became obvious + // once I combined the passes. + + // so there's a missing 'times 2' here (for adding X to itself). + // this propagates through linearly to the end, where the numbers + // are 1/2 too small, and need to be compensated for. + + { + float *d,*e, *AA, *e_stop; + d = &buf2[n2-2]; + AA = A; + e = &buffer[0]; + e_stop = &buffer[n2]; + while (e != e_stop) { + d[1] = (e[0] * AA[0] - e[2]*AA[1]); + d[0] = (e[0] * AA[1] + e[2]*AA[0]); + d -= 2; + AA += 2; + e += 4; + } + + e = &buffer[n2-3]; + while (d >= buf2) { + d[1] = (-e[2] * AA[0] - -e[0]*AA[1]); + d[0] = (-e[2] * AA[1] + -e[0]*AA[0]); + d -= 2; + AA += 2; + e -= 4; + } + } + + // now we use symbolic names for these, so that we can + // possibly swap their meaning as we change which operations + // are in place + + u = buffer; + v = buf2; + + // step 2 (paper output is w, now u) + // this could be in place, but the data ends up in the wrong + // place... _somebody_'s got to swap it, so this is nominated + { + float *AA = &A[n2-8]; + float *d0,*d1, *e0, *e1; + + e0 = &v[n4]; + e1 = &v[0]; + + d0 = &u[n4]; + d1 = &u[0]; + + while (AA >= A) { + float v40_20, v41_21; + + v41_21 = e0[1] - e1[1]; + v40_20 = e0[0] - e1[0]; + d0[1] = e0[1] + e1[1]; + d0[0] = e0[0] + e1[0]; + d1[1] = v41_21*AA[4] - v40_20*AA[5]; + d1[0] = v40_20*AA[4] + v41_21*AA[5]; + + v41_21 = e0[3] - e1[3]; + v40_20 = e0[2] - e1[2]; + d0[3] = e0[3] + e1[3]; + d0[2] = e0[2] + e1[2]; + d1[3] = v41_21*AA[0] - v40_20*AA[1]; + d1[2] = v40_20*AA[0] + v41_21*AA[1]; + + AA -= 8; + + d0 += 4; + d1 += 4; + e0 += 4; + e1 += 4; + } + } + + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + + // optimized step 3: + + // the original step3 loop can be nested r inside s or s inside r; + // it's written originally as s inside r, but this is dumb when r + // iterates many times, and s few. So I have two copies of it and + // switch between them halfway. + + // this is iteration 0 of step 3 + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*0, -(n >> 3), A); + imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*1, -(n >> 3), A); + + // this is iteration 1 of step 3 + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*0, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*1, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*2, -(n >> 4), A, 16); + imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*3, -(n >> 4), A, 16); + + l=2; + for (; l < (ld-3)>>1; ++l) { + int k0 = n >> (l+2), k0_2 = k0>>1; + int lim = 1 << (l+1); + int i; + for (i=0; i < lim; ++i) + imdct_step3_inner_r_loop(n >> (l+4), u, n2-1 - k0*i, -k0_2, A, 1 << (l+3)); + } + + for (; l < ld-6; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1; + int rlim = n >> (l+6), r; + int lim = 1 << (l+1); + int i_off; + float *A0 = A; + i_off = n2-1; + for (r=rlim; r > 0; --r) { + imdct_step3_inner_s_loop(lim, u, i_off, -k0_2, A0, k1, k0); + A0 += k1*4; + i_off -= 8; + } + } + + // iterations with count: + // ld-6,-5,-4 all interleaved together + // the big win comes from getting rid of needless flops + // due to the constants on pass 5 & 4 being all 1 and 0; + // combining them to be simultaneous to improve cache made little difference + imdct_step3_inner_s_loop_ld654(n >> 5, u, n2-1, A, n); + + // output is u + + // step 4, 5, and 6 + // cannot be in-place because of step 5 + { + uint16 *bitrev = f->bit_reverse[blocktype]; + // weirdly, I'd have thought reading sequentially and writing + // erratically would have been better than vice-versa, but in + // fact that's not what my testing showed. (That is, with + // j = bitreverse(i), do you read i and write j, or read j and write i.) + + float *d0 = &v[n4-4]; + float *d1 = &v[n2-4]; + while (d0 >= v) { + int k4; + + k4 = bitrev[0]; + d1[3] = u[k4+0]; + d1[2] = u[k4+1]; + d0[3] = u[k4+2]; + d0[2] = u[k4+3]; + + k4 = bitrev[1]; + d1[1] = u[k4+0]; + d1[0] = u[k4+1]; + d0[1] = u[k4+2]; + d0[0] = u[k4+3]; + + d0 -= 4; + d1 -= 4; + bitrev += 2; + } + } + // (paper output is u, now v) + + + // data must be in buf2 + assert(v == buf2); + + // step 7 (paper output is v, now v) + // this is now in place + { + float *C = f->C[blocktype]; + float *d, *e; + + d = v; + e = v + n2 - 4; + + while (d < e) { + float a02,a11,b0,b1,b2,b3; + + a02 = d[0] - e[2]; + a11 = d[1] + e[3]; + + b0 = C[1]*a02 + C[0]*a11; + b1 = C[1]*a11 - C[0]*a02; + + b2 = d[0] + e[ 2]; + b3 = d[1] - e[ 3]; + + d[0] = b2 + b0; + d[1] = b3 + b1; + e[2] = b2 - b0; + e[3] = b1 - b3; + + a02 = d[2] - e[0]; + a11 = d[3] + e[1]; + + b0 = C[3]*a02 + C[2]*a11; + b1 = C[3]*a11 - C[2]*a02; + + b2 = d[2] + e[ 0]; + b3 = d[3] - e[ 1]; + + d[2] = b2 + b0; + d[3] = b3 + b1; + e[0] = b2 - b0; + e[1] = b1 - b3; + + C += 4; + d += 4; + e -= 4; + } + } + + // data must be in buf2 + + + // step 8+decode (paper output is X, now buffer) + // this generates pairs of data a la 8 and pushes them directly through + // the decode kernel (pushing rather than pulling) to avoid having + // to make another pass later + + // this cannot POSSIBLY be in place, so we refer to the buffers directly + + { + float *d0,*d1,*d2,*d3; + + float *B = f->B[blocktype] + n2 - 8; + float *e = buf2 + n2 - 8; + d0 = &buffer[0]; + d1 = &buffer[n2-4]; + d2 = &buffer[n2]; + d3 = &buffer[n-4]; + while (e >= v) { + float p0,p1,p2,p3; + + p3 = e[6]*B[7] - e[7]*B[6]; + p2 = -e[6]*B[6] - e[7]*B[7]; + + d0[0] = p3; + d1[3] = - p3; + d2[0] = p2; + d3[3] = p2; + + p1 = e[4]*B[5] - e[5]*B[4]; + p0 = -e[4]*B[4] - e[5]*B[5]; + + d0[1] = p1; + d1[2] = - p1; + d2[1] = p0; + d3[2] = p0; + + p3 = e[2]*B[3] - e[3]*B[2]; + p2 = -e[2]*B[2] - e[3]*B[3]; + + d0[2] = p3; + d1[1] = - p3; + d2[2] = p2; + d3[1] = p2; + + p1 = e[0]*B[1] - e[1]*B[0]; + p0 = -e[0]*B[0] - e[1]*B[1]; + + d0[3] = p1; + d1[0] = - p1; + d2[3] = p0; + d3[0] = p0; + + B -= 8; + e -= 8; + d0 += 4; + d2 += 4; + d1 -= 4; + d3 -= 4; + } + } + + temp_free(f,buf2); + temp_alloc_restore(f,save_point); +} + +#if 0 +// this is the original version of the above code, if you want to optimize it from scratch +void inverse_mdct_naive(float *buffer, int n) +{ + float s; + float A[1 << 12], B[1 << 12], C[1 << 11]; + int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l; + int n3_4 = n - n4, ld; + // how can they claim this only uses N words?! + // oh, because they're only used sparsely, whoops + float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13]; + // set up twiddle factors + + for (k=k2=0; k < n4; ++k,k2+=2) { + A[k2 ] = (float) cos(4*k*M_PI/n); + A[k2+1] = (float) -sin(4*k*M_PI/n); + B[k2 ] = (float) cos((k2+1)*M_PI/n/2); + B[k2+1] = (float) sin((k2+1)*M_PI/n/2); + } + for (k=k2=0; k < n8; ++k,k2+=2) { + C[k2 ] = (float) cos(2*(k2+1)*M_PI/n); + C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n); + } + + // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio" + // Note there are bugs in that pseudocode, presumably due to them attempting + // to rename the arrays nicely rather than representing the way their actual + // implementation bounces buffers back and forth. As a result, even in the + // "some formulars corrected" version, a direct implementation fails. These + // are noted below as "paper bug". + + // copy and reflect spectral data + for (k=0; k < n2; ++k) u[k] = buffer[k]; + for ( ; k < n ; ++k) u[k] = -buffer[n - k - 1]; + // kernel from paper + // step 1 + for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) { + v[n-k4-1] = (u[k4] - u[n-k4-1]) * A[k2] - (u[k4+2] - u[n-k4-3])*A[k2+1]; + v[n-k4-3] = (u[k4] - u[n-k4-1]) * A[k2+1] + (u[k4+2] - u[n-k4-3])*A[k2]; + } + // step 2 + for (k=k4=0; k < n8; k+=1, k4+=4) { + w[n2+3+k4] = v[n2+3+k4] + v[k4+3]; + w[n2+1+k4] = v[n2+1+k4] + v[k4+1]; + w[k4+3] = (v[n2+3+k4] - v[k4+3])*A[n2-4-k4] - (v[n2+1+k4]-v[k4+1])*A[n2-3-k4]; + w[k4+1] = (v[n2+1+k4] - v[k4+1])*A[n2-4-k4] + (v[n2+3+k4]-v[k4+3])*A[n2-3-k4]; + } + // step 3 + ld = ilog(n) - 1; // ilog is off-by-one from normal definitions + for (l=0; l < ld-3; ++l) { + int k0 = n >> (l+2), k1 = 1 << (l+3); + int rlim = n >> (l+4), r4, r; + int s2lim = 1 << (l+2), s2; + for (r=r4=0; r < rlim; r4+=4,++r) { + for (s2=0; s2 < s2lim; s2+=2) { + u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4]; + u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4]; + u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1] + - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1+1]; + u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1] + + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1+1]; + } + } + if (l+1 < ld-3) { + // paper bug: ping-ponging of u&w here is omitted + memcpy(w, u, sizeof(u)); + } + } + + // step 4 + for (i=0; i < n8; ++i) { + int j = bit_reverse(i) >> (32-ld+3); + assert(j < n8); + if (i == j) { + // paper bug: original code probably swapped in place; if copying, + // need to directly copy in this case + int i8 = i << 3; + v[i8+1] = u[i8+1]; + v[i8+3] = u[i8+3]; + v[i8+5] = u[i8+5]; + v[i8+7] = u[i8+7]; + } else if (i < j) { + int i8 = i << 3, j8 = j << 3; + v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1]; + v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3]; + v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5]; + v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7]; + } + } + // step 5 + for (k=0; k < n2; ++k) { + w[k] = v[k*2+1]; + } + // step 6 + for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) { + u[n-1-k2] = w[k4]; + u[n-2-k2] = w[k4+1]; + u[n3_4 - 1 - k2] = w[k4+2]; + u[n3_4 - 2 - k2] = w[k4+3]; + } + // step 7 + for (k=k2=0; k < n8; ++k, k2 += 2) { + v[n2 + k2 ] = ( u[n2 + k2] + u[n-2-k2] + C[k2+1]*(u[n2+k2]-u[n-2-k2]) + C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n-2 - k2] = ( u[n2 + k2] + u[n-2-k2] - C[k2+1]*(u[n2+k2]-u[n-2-k2]) - C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2; + v[n2+1+ k2] = ( u[n2+1+k2] - u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + v[n-1 - k2] = (-u[n2+1+k2] + u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2; + } + // step 8 + for (k=k2=0; k < n4; ++k,k2 += 2) { + X[k] = v[k2+n2]*B[k2 ] + v[k2+1+n2]*B[k2+1]; + X[n2-1-k] = v[k2+n2]*B[k2+1] - v[k2+1+n2]*B[k2 ]; + } + + // decode kernel to output + // determined the following value experimentally + // (by first figuring out what made inverse_mdct_slow work); then matching that here + // (probably vorbis encoder premultiplies by n or n/2, to save it on the decoder?) + s = 0.5; // theoretically would be n4 + + // [[[ note! the s value of 0.5 is compensated for by the B[] in the current code, + // so it needs to use the "old" B values to behave correctly, or else + // set s to 1.0 ]]] + for (i=0; i < n4 ; ++i) buffer[i] = s * X[i+n4]; + for ( ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1]; + for ( ; i < n ; ++i) buffer[i] = -s * X[i - n3_4]; +} +#endif + +static float *get_window(vorb *f, int len) +{ + len <<= 1; + if (len == f->blocksize_0) return f->window[0]; + if (len == f->blocksize_1) return f->window[1]; + return NULL; +} + +#ifndef STB_VORBIS_NO_DEFER_FLOOR +typedef int16 YTYPE; +#else +typedef int YTYPE; +#endif +static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag) +{ + int n2 = n >> 1; + int s = map->chan[i].mux, floor; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + int j,q; + int lx = 0, ly = finalY[0] * g->floor1_multiplier; + for (q=1; q < g->values; ++q) { + j = g->sorted_order[q]; + #ifndef STB_VORBIS_NO_DEFER_FLOOR + if (finalY[j] >= 0) + #else + if (step2_flag[j]) + #endif + { + int hy = finalY[j] * g->floor1_multiplier; + int hx = g->Xlist[j]; + if (lx != hx) + draw_line(target, lx,ly, hx,hy, n2); + CHECK(f); + lx = hx, ly = hy; + } + } + if (lx < n2) { + // optimization of: draw_line(target, lx,ly, n,ly, n2); + for (j=lx; j < n2; ++j) + LINE_OP(target[j], inverse_db_table[ly]); + CHECK(f); + } + } + return TRUE; +} + +// The meaning of "left" and "right" +// +// For a given frame: +// we compute samples from 0..n +// window_center is n/2 +// we'll window and mix the samples from left_start to left_end with data from the previous frame +// all of the samples from left_end to right_start can be output without mixing; however, +// this interval is 0-length except when transitioning between short and long frames +// all of the samples from right_start to right_end need to be mixed with the next frame, +// which we don't have, so those get saved in a buffer +// frame N's right_end-right_start, the number of samples to mix with the next frame, +// has to be the same as frame N+1's left_end-left_start (which they are by +// construction) + +static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + Mode *m; + int i, n, prev, next, window_center; + f->channel_buffer_start = f->channel_buffer_end = 0; + + retry: + if (f->eof) return FALSE; + if (!maybe_start_packet(f)) + return FALSE; + // check packet type + if (get_bits(f,1) != 0) { + if (IS_PUSH_MODE(f)) + return error(f,VORBIS_bad_packet_type); + while (EOP != get8_packet(f)); + goto retry; + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + i = get_bits(f, ilog(f->mode_count-1)); + if (i == EOP) return FALSE; + if (i >= f->mode_count) return FALSE; + *mode = i; + m = f->mode_config + i; + if (m->blockflag) { + n = f->blocksize_1; + prev = get_bits(f,1); + next = get_bits(f,1); + } else { + prev = next = 0; + n = f->blocksize_0; + } + +// WINDOWING + + window_center = n >> 1; + if (m->blockflag && !prev) { + *p_left_start = (n - f->blocksize_0) >> 2; + *p_left_end = (n + f->blocksize_0) >> 2; + } else { + *p_left_start = 0; + *p_left_end = window_center; + } + if (m->blockflag && !next) { + *p_right_start = (n*3 - f->blocksize_0) >> 2; + *p_right_end = (n*3 + f->blocksize_0) >> 2; + } else { + *p_right_start = window_center; + *p_right_end = n; + } + + return TRUE; +} + +static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left) +{ + Mapping *map; + int i,j,k,n,n2; + int zero_channel[256]; + int really_zero_channel[256]; + +// WINDOWING + + n = f->blocksize[m->blockflag]; + map = &f->mapping[m->mapping]; + +// FLOORS + n2 = n >> 1; + + CHECK(f); + + for (i=0; i < f->channels; ++i) { + int s = map->chan[i].mux, floor; + zero_channel[i] = FALSE; + floor = map->submap_floor[s]; + if (f->floor_types[floor] == 0) { + return error(f, VORBIS_invalid_stream); + } else { + Floor1 *g = &f->floor_config[floor].floor1; + if (get_bits(f, 1)) { + short *finalY; + uint8 step2_flag[256]; + static int range_list[4] = { 256, 128, 86, 64 }; + int range = range_list[g->floor1_multiplier-1]; + int offset = 2; + finalY = f->finalY[i]; + finalY[0] = get_bits(f, ilog(range)-1); + finalY[1] = get_bits(f, ilog(range)-1); + for (j=0; j < g->partitions; ++j) { + int pclass = g->partition_class_list[j]; + int cdim = g->class_dimensions[pclass]; + int cbits = g->class_subclasses[pclass]; + int csub = (1 << cbits)-1; + int cval = 0; + if (cbits) { + Codebook *c = f->codebooks + g->class_masterbooks[pclass]; + DECODE(cval,f,c); + } + for (k=0; k < cdim; ++k) { + int book = g->subclass_books[pclass][cval & csub]; + cval = cval >> cbits; + if (book >= 0) { + int temp; + Codebook *c = f->codebooks + book; + DECODE(temp,f,c); + finalY[offset++] = temp; + } else + finalY[offset++] = 0; + } + } + if (f->valid_bits == INVALID_BITS) goto error; // behavior according to spec + step2_flag[0] = step2_flag[1] = 1; + for (j=2; j < g->values; ++j) { + int low, high, pred, highroom, lowroom, room, val; + low = g->neighbors[j][0]; + high = g->neighbors[j][1]; + //neighbors(g->Xlist, j, &low, &high); + pred = predict_point(g->Xlist[j], g->Xlist[low], g->Xlist[high], finalY[low], finalY[high]); + val = finalY[j]; + highroom = range - pred; + lowroom = pred; + if (highroom < lowroom) + room = highroom * 2; + else + room = lowroom * 2; + if (val) { + step2_flag[low] = step2_flag[high] = 1; + step2_flag[j] = 1; + if (val >= room) + if (highroom > lowroom) + finalY[j] = val - lowroom + pred; + else + finalY[j] = pred - val + highroom - 1; + else + if (val & 1) + finalY[j] = pred - ((val+1)>>1); + else + finalY[j] = pred + (val>>1); + } else { + step2_flag[j] = 0; + finalY[j] = pred; + } + } + +#ifdef STB_VORBIS_NO_DEFER_FLOOR + do_floor(f, map, i, n, f->floor_buffers[i], finalY, step2_flag); +#else + // defer final floor computation until _after_ residue + for (j=0; j < g->values; ++j) { + if (!step2_flag[j]) + finalY[j] = -1; + } +#endif + } else { + error: + zero_channel[i] = TRUE; + } + // So we just defer everything else to later + + // at this point we've decoded the floor into buffer + } + } + CHECK(f); + // at this point we've decoded all floors + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + + // re-enable coupled channels if necessary + memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels); + for (i=0; i < map->coupling_steps; ++i) + if (!zero_channel[map->chan[i].magnitude] || !zero_channel[map->chan[i].angle]) { + zero_channel[map->chan[i].magnitude] = zero_channel[map->chan[i].angle] = FALSE; + } + + CHECK(f); +// RESIDUE DECODE + for (i=0; i < map->submaps; ++i) { + float *residue_buffers[STB_VORBIS_MAX_CHANNELS]; + int r; + uint8 do_not_decode[256]; + int ch = 0; + for (j=0; j < f->channels; ++j) { + if (map->chan[j].mux == i) { + if (zero_channel[j]) { + do_not_decode[ch] = TRUE; + residue_buffers[ch] = NULL; + } else { + do_not_decode[ch] = FALSE; + residue_buffers[ch] = f->channel_buffers[j]; + } + ++ch; + } + } + r = map->submap_residue[i]; + decode_residue(f, residue_buffers, ch, n2, r, do_not_decode); + } + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + CHECK(f); + +// INVERSE COUPLING + for (i = map->coupling_steps-1; i >= 0; --i) { + int n2 = n >> 1; + float *m = f->channel_buffers[map->chan[i].magnitude]; + float *a = f->channel_buffers[map->chan[i].angle ]; + for (j=0; j < n2; ++j) { + float a2,m2; + if (m[j] > 0) + if (a[j] > 0) + m2 = m[j], a2 = m[j] - a[j]; + else + a2 = m[j], m2 = m[j] + a[j]; + else + if (a[j] > 0) + m2 = m[j], a2 = m[j] + a[j]; + else + a2 = m[j], m2 = m[j] - a[j]; + m[j] = m2; + a[j] = a2; + } + } + CHECK(f); + + // finish decoding the floors +#ifndef STB_VORBIS_NO_DEFER_FLOOR + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + do_floor(f, map, i, n, f->channel_buffers[i], f->finalY[i], NULL); + } + } +#else + for (i=0; i < f->channels; ++i) { + if (really_zero_channel[i]) { + memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2); + } else { + for (j=0; j < n2; ++j) + f->channel_buffers[i][j] *= f->floor_buffers[i][j]; + } + } +#endif + +// INVERSE MDCT + CHECK(f); + for (i=0; i < f->channels; ++i) + inverse_mdct(f->channel_buffers[i], n, f, m->blockflag); + CHECK(f); + + // this shouldn't be necessary, unless we exited on an error + // and want to flush to get to the next packet + flush_packet(f); + + if (f->first_decode) { + // assume we start so first non-discarded sample is sample 0 + // this isn't to spec, but spec would require us to read ahead + // and decode the size of all current frames--could be done, + // but presumably it's not a commonly used feature + f->current_loc = -n2; // start of first frame is positioned for discard + // we might have to discard samples "from" the next frame too, + // if we're lapping a large block then a small at the start? + f->discard_samples_deferred = n - right_end; + f->current_loc_valid = TRUE; + f->first_decode = FALSE; + } else if (f->discard_samples_deferred) { + if (f->discard_samples_deferred >= right_start - left_start) { + f->discard_samples_deferred -= (right_start - left_start); + left_start = right_start; + *p_left = left_start; + } else { + left_start += f->discard_samples_deferred; + *p_left = left_start; + f->discard_samples_deferred = 0; + } + } else if (f->previous_length == 0 && f->current_loc_valid) { + // we're recovering from a seek... that means we're going to discard + // the samples from this packet even though we know our position from + // the last page header, so we need to update the position based on + // the discarded samples here + // but wait, the code below is going to add this in itself even + // on a discard, so we don't need to do it here... + } + + // check if we have ogg information about the sample # for this packet + if (f->last_seg_which == f->end_seg_with_known_loc) { + // if we have a valid current loc, and this is final: + if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) { + uint32 current_end = f->known_loc_for_packet; + // then let's infer the size of the (probably) short final frame + if (current_end < f->current_loc + (right_end-left_start)) { + if (current_end < f->current_loc) { + // negative truncation, that's impossible! + *len = 0; + } else { + *len = current_end - f->current_loc; + } + *len += left_start; // this doesn't seem right, but has no ill effect on my test files + if (*len > right_end) *len = right_end; // this should never happen + f->current_loc += *len; + return TRUE; + } + } + // otherwise, just set our sample loc + // guess that the ogg granule pos refers to the _middle_ of the + // last frame? + // set f->current_loc to the position of left_start + f->current_loc = f->known_loc_for_packet - (n2-left_start); + f->current_loc_valid = TRUE; + } + if (f->current_loc_valid) + f->current_loc += (right_start - left_start); + + if (f->alloc.alloc_buffer) + assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset); + *len = right_end; // ignore samples after the window goes to 0 + CHECK(f); + + return TRUE; +} + +static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right) +{ + int mode, left_end, right_end; + if (!vorbis_decode_initial(f, p_left, &left_end, p_right, &right_end, &mode)) return 0; + return vorbis_decode_packet_rest(f, len, f->mode_config + mode, *p_left, left_end, *p_right, right_end, p_left); +} + +static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right) +{ + int prev,i,j; + // we use right&left (the start of the right- and left-window sin()-regions) + // to determine how much to return, rather than inferring from the rules + // (same result, clearer code); 'left' indicates where our sin() window + // starts, therefore where the previous window's right edge starts, and + // therefore where to start mixing from the previous buffer. 'right' + // indicates where our sin() ending-window starts, therefore that's where + // we start saving, and where our returned-data ends. + + // mixin from previous window + if (f->previous_length) { + int i,j, n = f->previous_length; + float *w = get_window(f, n); + if (w == NULL) return 0; + for (i=0; i < f->channels; ++i) { + for (j=0; j < n; ++j) + f->channel_buffers[i][left+j] = + f->channel_buffers[i][left+j]*w[ j] + + f->previous_window[i][ j]*w[n-1-j]; + } + } + + prev = f->previous_length; + + // last half of this data becomes previous window + f->previous_length = len - right; + + // @OPTIMIZE: could avoid this copy by double-buffering the + // output (flipping previous_window with channel_buffers), but + // then previous_window would have to be 2x as large, and + // channel_buffers couldn't be temp mem (although they're NOT + // currently temp mem, they could be (unless we want to level + // performance by spreading out the computation)) + for (i=0; i < f->channels; ++i) + for (j=0; right+j < len; ++j) + f->previous_window[i][j] = f->channel_buffers[i][right+j]; + + if (!prev) + // there was no previous packet, so this data isn't valid... + // this isn't entirely true, only the would-have-overlapped data + // isn't valid, but this seems to be what the spec requires + return 0; + + // truncate a short frame + if (len < right) right = len; + + f->samples_output += right-left; + + return right - left; +} + +static int vorbis_pump_first_frame(stb_vorbis *f) +{ + int len, right, left, res; + res = vorbis_decode_packet(f, &len, &left, &right); + if (res) + vorbis_finish_frame(f, len, left, right); + return res; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API +static int is_whole_packet_present(stb_vorbis *f) +{ + // make sure that we have the packet available before continuing... + // this requires a full ogg parse, but we know we can fetch from f->stream + + // instead of coding this out explicitly, we could save the current read state, + // read the next packet with get8() until end-of-packet, check f->eof, then + // reset the state? but that would be slower, esp. since we'd have over 256 bytes + // of state to restore (primarily the page segment table) + + int s = f->next_seg, first = TRUE; + uint8 *p = f->stream; + + if (s != -1) { // if we're not starting the packet with a 'continue on next page' flag + for (; s < f->segment_count; ++s) { + p += f->segments[s]; + if (f->segments[s] < 255) // stop at first short segment + break; + } + // either this continues, or it ends it... + if (s == f->segment_count) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + for (; s == -1;) { + uint8 *q; + int n; + + // check that we have the page header ready + if (p + 26 >= f->stream_end) return error(f, VORBIS_need_more_data); + // validate the page + if (memcmp(p, ogg_page_header, 4)) return error(f, VORBIS_invalid_stream); + if (p[4] != 0) return error(f, VORBIS_invalid_stream); + if (first) { // the first segment must NOT have 'continued_packet', later ones MUST + if (f->previous_length) + if ((p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + // if no previous length, we're resynching, so we can come in on a continued-packet, + // which we'll just drop + } else { + if (!(p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream); + } + n = p[26]; // segment counts + q = p+27; // q points to segment table + p = q + n; // advance past header + // make sure we've read the segment table + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + for (s=0; s < n; ++s) { + p += q[s]; + if (q[s] < 255) + break; + } + if (s == n) + s = -1; // set 'crosses page' flag + if (p > f->stream_end) return error(f, VORBIS_need_more_data); + first = FALSE; + } + return TRUE; +} +#endif // !STB_VORBIS_NO_PUSHDATA_API + +static int start_decoder(vorb *f) +{ + uint8 header[6], x,y; + int len,i,j,k, max_submaps = 0; + int longest_floorlist=0; + + // first page, first packet + f->first_decode = TRUE; + + if (!start_page(f)) return FALSE; + // validate page flag + if (!(f->page_flag & PAGEFLAG_first_page)) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_last_page) return error(f, VORBIS_invalid_first_page); + if (f->page_flag & PAGEFLAG_continued_packet) return error(f, VORBIS_invalid_first_page); + // check for expected packet length + if (f->segment_count != 1) return error(f, VORBIS_invalid_first_page); + if (f->segments[0] != 30) { + // check for the Ogg skeleton fishead identifying header to refine our error + if (f->segments[0] == 64 && + getn(f, header, 6) && + header[0] == 'f' && + header[1] == 'i' && + header[2] == 's' && + header[3] == 'h' && + header[4] == 'e' && + header[5] == 'a' && + get8(f) == 'd' && + get8(f) == '\0') return error(f, VORBIS_ogg_skeleton_not_supported); + else + return error(f, VORBIS_invalid_first_page); + } + + // read packet + // check packet header + if (get8(f) != VORBIS_packet_id) return error(f, VORBIS_invalid_first_page); + if (!getn(f, header, 6)) return error(f, VORBIS_unexpected_eof); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_first_page); + // vorbis_version + if (get32(f) != 0) return error(f, VORBIS_invalid_first_page); + f->channels = get8(f); if (!f->channels) return error(f, VORBIS_invalid_first_page); + if (f->channels > STB_VORBIS_MAX_CHANNELS) return error(f, VORBIS_too_many_channels); + f->sample_rate = get32(f); if (!f->sample_rate) return error(f, VORBIS_invalid_first_page); + get32(f); // bitrate_maximum + get32(f); // bitrate_nominal + get32(f); // bitrate_minimum + x = get8(f); + { + int log0,log1; + log0 = x & 15; + log1 = x >> 4; + f->blocksize_0 = 1 << log0; + f->blocksize_1 = 1 << log1; + if (log0 < 6 || log0 > 13) return error(f, VORBIS_invalid_setup); + if (log1 < 6 || log1 > 13) return error(f, VORBIS_invalid_setup); + if (log0 > log1) return error(f, VORBIS_invalid_setup); + } + + // framing_flag + x = get8(f); + if (!(x & 1)) return error(f, VORBIS_invalid_first_page); + + // second packet! + if (!start_page(f)) return FALSE; + + if (!start_packet(f)) return FALSE; + + if (!next_segment(f)) return FALSE; + + if (get8_packet(f) != VORBIS_packet_comment) return error(f, VORBIS_invalid_setup); + for (i=0; i < 6; ++i) header[i] = get8_packet(f); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_setup); + //file vendor + len = get32_packet(f); + f->vendor = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->vendor == NULL) return error(f, VORBIS_outofmem); + for(i=0; i < len; ++i) { + f->vendor[i] = get8_packet(f); + } + f->vendor[len] = (char)'\0'; + //user comments + f->comment_list_length = get32_packet(f); + if (f->comment_list_length > 0) { + f->comment_list = (char**)setup_malloc(f, sizeof(char*) * (f->comment_list_length)); + if (f->comment_list == NULL) return error(f, VORBIS_outofmem); + } + + for(i=0; i < f->comment_list_length; ++i) { + len = get32_packet(f); + f->comment_list[i] = (char*)setup_malloc(f, sizeof(char) * (len+1)); + if (f->comment_list[i] == NULL) return error(f, VORBIS_outofmem); + + for(j=0; j < len; ++j) { + f->comment_list[i][j] = get8_packet(f); + } + f->comment_list[i][len] = (char)'\0'; + } + + // framing_flag + x = get8_packet(f); + if (!(x & 1)) return error(f, VORBIS_invalid_setup); + + + skip(f, f->bytes_in_seg); + f->bytes_in_seg = 0; + + do { + len = next_segment(f); + skip(f, len); + f->bytes_in_seg = 0; + } while (len); + + // third packet! + if (!start_packet(f)) return FALSE; + + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (IS_PUSH_MODE(f)) { + if (!is_whole_packet_present(f)) { + // convert error in ogg header to write type + if (f->error == VORBIS_invalid_stream) + f->error = VORBIS_invalid_setup; + return FALSE; + } + } + #endif + + crc32_init(); // always init it, to avoid multithread race conditions + + if (get8_packet(f) != VORBIS_packet_setup) return error(f, VORBIS_invalid_setup); + for (i=0; i < 6; ++i) header[i] = get8_packet(f); + if (!vorbis_validate(header)) return error(f, VORBIS_invalid_setup); + + // codebooks + + f->codebook_count = get_bits(f,8) + 1; + f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count); + if (f->codebooks == NULL) return error(f, VORBIS_outofmem); + memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count); + for (i=0; i < f->codebook_count; ++i) { + uint32 *values; + int ordered, sorted_count; + int total=0; + uint8 *lengths; + Codebook *c = f->codebooks+i; + CHECK(f); + x = get_bits(f, 8); if (x != 0x42) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x43) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); if (x != 0x56) return error(f, VORBIS_invalid_setup); + x = get_bits(f, 8); + c->dimensions = (get_bits(f, 8)<<8) + x; + x = get_bits(f, 8); + y = get_bits(f, 8); + c->entries = (get_bits(f, 8)<<16) + (y<<8) + x; + ordered = get_bits(f,1); + c->sparse = ordered ? 0 : get_bits(f,1); + + if (c->dimensions == 0 && c->entries != 0) return error(f, VORBIS_invalid_setup); + + if (c->sparse) + lengths = (uint8 *) setup_temp_malloc(f, c->entries); + else + lengths = c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + + if (!lengths) return error(f, VORBIS_outofmem); + + if (ordered) { + int current_entry = 0; + int current_length = get_bits(f,5) + 1; + while (current_entry < c->entries) { + int limit = c->entries - current_entry; + int n = get_bits(f, ilog(limit)); + if (current_length >= 32) return error(f, VORBIS_invalid_setup); + if (current_entry + n > (int) c->entries) { return error(f, VORBIS_invalid_setup); } + memset(lengths + current_entry, current_length, n); + current_entry += n; + ++current_length; + } + } else { + for (j=0; j < c->entries; ++j) { + int present = c->sparse ? get_bits(f,1) : 1; + if (present) { + lengths[j] = get_bits(f, 5) + 1; + ++total; + if (lengths[j] == 32) + return error(f, VORBIS_invalid_setup); + } else { + lengths[j] = NO_CODE; + } + } + } + + if (c->sparse && total >= c->entries >> 2) { + // convert sparse items to non-sparse! + if (c->entries > (int) f->setup_temp_memory_required) + f->setup_temp_memory_required = c->entries; + + c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries); + if (c->codeword_lengths == NULL) return error(f, VORBIS_outofmem); + memcpy(c->codeword_lengths, lengths, c->entries); + setup_temp_free(f, lengths, c->entries); // note this is only safe if there have been no intervening temp mallocs! + lengths = c->codeword_lengths; + c->sparse = 0; + } + + // compute the size of the sorted tables + if (c->sparse) { + sorted_count = total; + } else { + sorted_count = 0; + #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH + for (j=0; j < c->entries; ++j) + if (lengths[j] > STB_VORBIS_FAST_HUFFMAN_LENGTH && lengths[j] != NO_CODE) + ++sorted_count; + #endif + } + + c->sorted_entries = sorted_count; + values = NULL; + + CHECK(f); + if (!c->sparse) { + c->codewords = (uint32 *) setup_malloc(f, sizeof(c->codewords[0]) * c->entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + } else { + unsigned int size; + if (c->sorted_entries) { + c->codeword_lengths = (uint8 *) setup_malloc(f, c->sorted_entries); + if (!c->codeword_lengths) return error(f, VORBIS_outofmem); + c->codewords = (uint32 *) setup_temp_malloc(f, sizeof(*c->codewords) * c->sorted_entries); + if (!c->codewords) return error(f, VORBIS_outofmem); + values = (uint32 *) setup_temp_malloc(f, sizeof(*values) * c->sorted_entries); + if (!values) return error(f, VORBIS_outofmem); + } + size = c->entries + (sizeof(*c->codewords) + sizeof(*values)) * c->sorted_entries; + if (size > f->setup_temp_memory_required) + f->setup_temp_memory_required = size; + } + + if (!compute_codewords(c, lengths, c->entries, values)) { + if (c->sparse) setup_temp_free(f, values, 0); + return error(f, VORBIS_invalid_setup); + } + + if (c->sorted_entries) { + // allocate an extra slot for sentinels + c->sorted_codewords = (uint32 *) setup_malloc(f, sizeof(*c->sorted_codewords) * (c->sorted_entries+1)); + if (c->sorted_codewords == NULL) return error(f, VORBIS_outofmem); + // allocate an extra slot at the front so that c->sorted_values[-1] is defined + // so that we can catch that case without an extra if + c->sorted_values = ( int *) setup_malloc(f, sizeof(*c->sorted_values ) * (c->sorted_entries+1)); + if (c->sorted_values == NULL) return error(f, VORBIS_outofmem); + ++c->sorted_values; + c->sorted_values[-1] = -1; + compute_sorted_huffman(c, lengths, values); + } + + if (c->sparse) { + setup_temp_free(f, values, sizeof(*values)*c->sorted_entries); + setup_temp_free(f, c->codewords, sizeof(*c->codewords)*c->sorted_entries); + setup_temp_free(f, lengths, c->entries); + c->codewords = NULL; + } + + compute_accelerated_huffman(c); + + CHECK(f); + c->lookup_type = get_bits(f, 4); + if (c->lookup_type > 2) return error(f, VORBIS_invalid_setup); + if (c->lookup_type > 0) { + uint16 *mults; + c->minimum_value = float32_unpack(get_bits(f, 32)); + c->delta_value = float32_unpack(get_bits(f, 32)); + c->value_bits = get_bits(f, 4)+1; + c->sequence_p = get_bits(f,1); + if (c->lookup_type == 1) { + int values = lookup1_values(c->entries, c->dimensions); + if (values < 0) return error(f, VORBIS_invalid_setup); + c->lookup_values = (uint32) values; + } else { + c->lookup_values = c->entries * c->dimensions; + } + if (c->lookup_values == 0) return error(f, VORBIS_invalid_setup); + mults = (uint16 *) setup_temp_malloc(f, sizeof(mults[0]) * c->lookup_values); + if (mults == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < (int) c->lookup_values; ++j) { + int q = get_bits(f, c->value_bits); + if (q == EOP) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_invalid_setup); } + mults[j] = q; + } + +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + if (c->lookup_type == 1) { + int len, sparse = c->sparse; + float last=0; + // pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop + if (sparse) { + if (c->sorted_entries == 0) goto skip; + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions); + } else + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries * c->dimensions); + if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + len = sparse ? c->sorted_entries : c->entries; + for (j=0; j < len; ++j) { + unsigned int z = sparse ? c->sorted_values[j] : j; + unsigned int div=1; + for (k=0; k < c->dimensions; ++k) { + int off = (z / div) % c->lookup_values; + float val = mults[off]; + val = mults[off]*c->delta_value + c->minimum_value + last; + c->multiplicands[j*c->dimensions + k] = val; + if (c->sequence_p) + last = val; + if (k+1 < c->dimensions) { + if (div > UINT_MAX / (unsigned int) c->lookup_values) { + setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); + return error(f, VORBIS_invalid_setup); + } + div *= c->lookup_values; + } + } + } + c->lookup_type = 2; + } + else +#endif + { + float last=0; + CHECK(f); + c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values); + if (c->multiplicands == NULL) { setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); } + for (j=0; j < (int) c->lookup_values; ++j) { + float val = mults[j] * c->delta_value + c->minimum_value + last; + c->multiplicands[j] = val; + if (c->sequence_p) + last = val; + } + } +#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK + skip:; +#endif + setup_temp_free(f, mults, sizeof(mults[0])*c->lookup_values); + + CHECK(f); + } + CHECK(f); + } + + // time domain transfers (notused) + + x = get_bits(f, 6) + 1; + for (i=0; i < x; ++i) { + uint32 z = get_bits(f, 16); + if (z != 0) return error(f, VORBIS_invalid_setup); + } + + // Floors + f->floor_count = get_bits(f, 6)+1; + f->floor_config = (Floor *) setup_malloc(f, f->floor_count * sizeof(*f->floor_config)); + if (f->floor_config == NULL) return error(f, VORBIS_outofmem); + for (i=0; i < f->floor_count; ++i) { + f->floor_types[i] = get_bits(f, 16); + if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup); + if (f->floor_types[i] == 0) { + Floor0 *g = &f->floor_config[i].floor0; + g->order = get_bits(f,8); + g->rate = get_bits(f,16); + g->bark_map_size = get_bits(f,16); + g->amplitude_bits = get_bits(f,6); + g->amplitude_offset = get_bits(f,8); + g->number_of_books = get_bits(f,4) + 1; + for (j=0; j < g->number_of_books; ++j) + g->book_list[j] = get_bits(f,8); + return error(f, VORBIS_feature_not_supported); + } else { + stbv__floor_ordering p[31*8+2]; + Floor1 *g = &f->floor_config[i].floor1; + int max_class = -1; + g->partitions = get_bits(f, 5); + for (j=0; j < g->partitions; ++j) { + g->partition_class_list[j] = get_bits(f, 4); + if (g->partition_class_list[j] > max_class) + max_class = g->partition_class_list[j]; + } + for (j=0; j <= max_class; ++j) { + g->class_dimensions[j] = get_bits(f, 3)+1; + g->class_subclasses[j] = get_bits(f, 2); + if (g->class_subclasses[j]) { + g->class_masterbooks[j] = get_bits(f, 8); + if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + for (k=0; k < 1 << g->class_subclasses[j]; ++k) { + g->subclass_books[j][k] = get_bits(f,8)-1; + if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } + } + g->floor1_multiplier = get_bits(f,2)+1; + g->rangebits = get_bits(f,4); + g->Xlist[0] = 0; + g->Xlist[1] = 1 << g->rangebits; + g->values = 2; + for (j=0; j < g->partitions; ++j) { + int c = g->partition_class_list[j]; + for (k=0; k < g->class_dimensions[c]; ++k) { + g->Xlist[g->values] = get_bits(f, g->rangebits); + ++g->values; + } + } + // precompute the sorting + for (j=0; j < g->values; ++j) { + p[j].x = g->Xlist[j]; + p[j].id = j; + } + qsort(p, g->values, sizeof(p[0]), point_compare); + for (j=0; j < g->values-1; ++j) + if (p[j].x == p[j+1].x) + return error(f, VORBIS_invalid_setup); + for (j=0; j < g->values; ++j) + g->sorted_order[j] = (uint8) p[j].id; + // precompute the neighbors + for (j=2; j < g->values; ++j) { + int low = 0,hi = 0; + neighbors(g->Xlist, j, &low,&hi); + g->neighbors[j][0] = low; + g->neighbors[j][1] = hi; + } + + if (g->values > longest_floorlist) + longest_floorlist = g->values; + } + } + + // Residue + f->residue_count = get_bits(f, 6)+1; + f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(f->residue_config[0])); + if (f->residue_config == NULL) return error(f, VORBIS_outofmem); + memset(f->residue_config, 0, f->residue_count * sizeof(f->residue_config[0])); + for (i=0; i < f->residue_count; ++i) { + uint8 residue_cascade[64]; + Residue *r = f->residue_config+i; + f->residue_types[i] = get_bits(f, 16); + if (f->residue_types[i] > 2) return error(f, VORBIS_invalid_setup); + r->begin = get_bits(f, 24); + r->end = get_bits(f, 24); + if (r->end < r->begin) return error(f, VORBIS_invalid_setup); + r->part_size = get_bits(f,24)+1; + r->classifications = get_bits(f,6)+1; + r->classbook = get_bits(f,8); + if (r->classbook >= f->codebook_count) return error(f, VORBIS_invalid_setup); + for (j=0; j < r->classifications; ++j) { + uint8 high_bits=0; + uint8 low_bits=get_bits(f,3); + if (get_bits(f,1)) + high_bits = get_bits(f,5); + residue_cascade[j] = high_bits*8 + low_bits; + } + r->residue_books = (short (*)[8]) setup_malloc(f, sizeof(r->residue_books[0]) * r->classifications); + if (r->residue_books == NULL) return error(f, VORBIS_outofmem); + for (j=0; j < r->classifications; ++j) { + for (k=0; k < 8; ++k) { + if (residue_cascade[j] & (1 << k)) { + r->residue_books[j][k] = get_bits(f, 8); + if (r->residue_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup); + } else { + r->residue_books[j][k] = -1; + } + } + } + // precompute the classifications[] array to avoid inner-loop mod/divide + // call it 'classdata' since we already have r->classifications + r->classdata = (uint8 **) setup_malloc(f, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + if (!r->classdata) return error(f, VORBIS_outofmem); + memset(r->classdata, 0, sizeof(*r->classdata) * f->codebooks[r->classbook].entries); + for (j=0; j < f->codebooks[r->classbook].entries; ++j) { + int classwords = f->codebooks[r->classbook].dimensions; + int temp = j; + r->classdata[j] = (uint8 *) setup_malloc(f, sizeof(r->classdata[j][0]) * classwords); + if (r->classdata[j] == NULL) return error(f, VORBIS_outofmem); + for (k=classwords-1; k >= 0; --k) { + r->classdata[j][k] = temp % r->classifications; + temp /= r->classifications; + } + } + } + + f->mapping_count = get_bits(f,6)+1; + f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping)); + if (f->mapping == NULL) return error(f, VORBIS_outofmem); + memset(f->mapping, 0, f->mapping_count * sizeof(*f->mapping)); + for (i=0; i < f->mapping_count; ++i) { + Mapping *m = f->mapping + i; + int mapping_type = get_bits(f,16); + if (mapping_type != 0) return error(f, VORBIS_invalid_setup); + m->chan = (MappingChannel *) setup_malloc(f, f->channels * sizeof(*m->chan)); + if (m->chan == NULL) return error(f, VORBIS_outofmem); + if (get_bits(f,1)) + m->submaps = get_bits(f,4)+1; + else + m->submaps = 1; + if (m->submaps > max_submaps) + max_submaps = m->submaps; + if (get_bits(f,1)) { + m->coupling_steps = get_bits(f,8)+1; + if (m->coupling_steps > f->channels) return error(f, VORBIS_invalid_setup); + for (k=0; k < m->coupling_steps; ++k) { + m->chan[k].magnitude = get_bits(f, ilog(f->channels-1)); + m->chan[k].angle = get_bits(f, ilog(f->channels-1)); + if (m->chan[k].magnitude >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].angle >= f->channels) return error(f, VORBIS_invalid_setup); + if (m->chan[k].magnitude == m->chan[k].angle) return error(f, VORBIS_invalid_setup); + } + } else + m->coupling_steps = 0; + + // reserved field + if (get_bits(f,2)) return error(f, VORBIS_invalid_setup); + if (m->submaps > 1) { + for (j=0; j < f->channels; ++j) { + m->chan[j].mux = get_bits(f, 4); + if (m->chan[j].mux >= m->submaps) return error(f, VORBIS_invalid_setup); + } + } else + // @SPECIFICATION: this case is missing from the spec + for (j=0; j < f->channels; ++j) + m->chan[j].mux = 0; + + for (j=0; j < m->submaps; ++j) { + get_bits(f,8); // discard + m->submap_floor[j] = get_bits(f,8); + m->submap_residue[j] = get_bits(f,8); + if (m->submap_floor[j] >= f->floor_count) return error(f, VORBIS_invalid_setup); + if (m->submap_residue[j] >= f->residue_count) return error(f, VORBIS_invalid_setup); + } + } + + // Modes + f->mode_count = get_bits(f, 6)+1; + for (i=0; i < f->mode_count; ++i) { + Mode *m = f->mode_config+i; + m->blockflag = get_bits(f,1); + m->windowtype = get_bits(f,16); + m->transformtype = get_bits(f,16); + m->mapping = get_bits(f,8); + if (m->windowtype != 0) return error(f, VORBIS_invalid_setup); + if (m->transformtype != 0) return error(f, VORBIS_invalid_setup); + if (m->mapping >= f->mapping_count) return error(f, VORBIS_invalid_setup); + } + + flush_packet(f); + + f->previous_length = 0; + + for (i=0; i < f->channels; ++i) { + f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1); + f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + f->finalY[i] = (int16 *) setup_malloc(f, sizeof(int16) * longest_floorlist); + if (f->channel_buffers[i] == NULL || f->previous_window[i] == NULL || f->finalY[i] == NULL) return error(f, VORBIS_outofmem); + memset(f->channel_buffers[i], 0, sizeof(float) * f->blocksize_1); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + f->floor_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2); + if (f->floor_buffers[i] == NULL) return error(f, VORBIS_outofmem); + #endif + } + + if (!init_blocksize(f, 0, f->blocksize_0)) return FALSE; + if (!init_blocksize(f, 1, f->blocksize_1)) return FALSE; + f->blocksize[0] = f->blocksize_0; + f->blocksize[1] = f->blocksize_1; + +#ifdef STB_VORBIS_DIVIDE_TABLE + if (integer_divide_table[1][1]==0) + for (i=0; i < DIVTAB_NUMER; ++i) + for (j=1; j < DIVTAB_DENOM; ++j) + integer_divide_table[i][j] = i / j; +#endif + + // compute how much temporary memory is needed + + // 1. + { + uint32 imdct_mem = (f->blocksize_1 * sizeof(float) >> 1); + uint32 classify_mem; + int i,max_part_read=0; + for (i=0; i < f->residue_count; ++i) { + Residue *r = f->residue_config + i; + unsigned int actual_size = f->blocksize_1 / 2; + unsigned int limit_r_begin = r->begin < actual_size ? r->begin : actual_size; + unsigned int limit_r_end = r->end < actual_size ? r->end : actual_size; + int n_read = limit_r_end - limit_r_begin; + int part_read = n_read / r->part_size; + if (part_read > max_part_read) + max_part_read = part_read; + } + #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(uint8 *)); + #else + classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(int *)); + #endif + + // maximum reasonable partition size is f->blocksize_1 + + f->temp_memory_required = classify_mem; + if (imdct_mem > f->temp_memory_required) + f->temp_memory_required = imdct_mem; + } + + + if (f->alloc.alloc_buffer) { + assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes); + // check if there's enough temp memory so we don't error later + if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset) + return error(f, VORBIS_outofmem); + } + + // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page + // without PAGEFLAG_continued_packet, so this either points to the first page, or + // the page after the end of the headers. It might be cleaner to point to a page + // in the middle of the headers, when that's the page where the first audio packet + // starts, but we'd have to also correctly skip the end of any continued packet in + // stb_vorbis_seek_start. + if (f->next_seg == -1) { + f->first_audio_page_offset = stb_vorbis_get_file_offset(f); + } else { + f->first_audio_page_offset = 0; + } + + return TRUE; +} + +static void vorbis_deinit(stb_vorbis *p) +{ + int i,j; + + setup_free(p, p->vendor); + for (i=0; i < p->comment_list_length; ++i) { + setup_free(p, p->comment_list[i]); + } + setup_free(p, p->comment_list); + + if (p->residue_config) { + for (i=0; i < p->residue_count; ++i) { + Residue *r = p->residue_config+i; + if (r->classdata) { + for (j=0; j < p->codebooks[r->classbook].entries; ++j) + setup_free(p, r->classdata[j]); + setup_free(p, r->classdata); + } + setup_free(p, r->residue_books); + } + } + + if (p->codebooks) { + CHECK(p); + for (i=0; i < p->codebook_count; ++i) { + Codebook *c = p->codebooks + i; + setup_free(p, c->codeword_lengths); + setup_free(p, c->multiplicands); + setup_free(p, c->codewords); + setup_free(p, c->sorted_codewords); + // c->sorted_values[-1] is the first entry in the array + setup_free(p, c->sorted_values ? c->sorted_values-1 : NULL); + } + setup_free(p, p->codebooks); + } + setup_free(p, p->floor_config); + setup_free(p, p->residue_config); + if (p->mapping) { + for (i=0; i < p->mapping_count; ++i) + setup_free(p, p->mapping[i].chan); + setup_free(p, p->mapping); + } + CHECK(p); + for (i=0; i < p->channels && i < STB_VORBIS_MAX_CHANNELS; ++i) { + setup_free(p, p->channel_buffers[i]); + setup_free(p, p->previous_window[i]); + #ifdef STB_VORBIS_NO_DEFER_FLOOR + setup_free(p, p->floor_buffers[i]); + #endif + setup_free(p, p->finalY[i]); + } + for (i=0; i < 2; ++i) { + setup_free(p, p->A[i]); + setup_free(p, p->B[i]); + setup_free(p, p->C[i]); + setup_free(p, p->window[i]); + setup_free(p, p->bit_reverse[i]); + } + #ifndef STB_VORBIS_NO_STDIO + if (p->close_on_free) fclose(p->f); + #endif +} + +void stb_vorbis_close(stb_vorbis *p) +{ + if (p == NULL) return; + vorbis_deinit(p); + setup_free(p,p); +} + +static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z) +{ + memset(p, 0, sizeof(*p)); // NULL out all malloc'd pointers to start + if (z) { + p->alloc = *z; + p->alloc.alloc_buffer_length_in_bytes &= ~7; + p->temp_offset = p->alloc.alloc_buffer_length_in_bytes; + } + p->eof = 0; + p->error = VORBIS__no_error; + p->stream = NULL; + p->codebooks = NULL; + p->page_crc_tests = -1; + #ifndef STB_VORBIS_NO_STDIO + p->close_on_free = FALSE; + p->f = NULL; + #endif +} + +int stb_vorbis_get_sample_offset(stb_vorbis *f) +{ + if (f->current_loc_valid) + return f->current_loc; + else + return -1; +} + +stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f) +{ + stb_vorbis_info d; + d.channels = f->channels; + d.sample_rate = f->sample_rate; + d.setup_memory_required = f->setup_memory_required; + d.setup_temp_memory_required = f->setup_temp_memory_required; + d.temp_memory_required = f->temp_memory_required; + d.max_frame_size = f->blocksize_1 >> 1; + return d; +} + +stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f) +{ + stb_vorbis_comment d; + d.vendor = f->vendor; + d.comment_list_length = f->comment_list_length; + d.comment_list = f->comment_list; + return d; +} + +int stb_vorbis_get_error(stb_vorbis *f) +{ + int e = f->error; + f->error = VORBIS__no_error; + return e; +} + +static stb_vorbis * vorbis_alloc(stb_vorbis *f) +{ + stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p)); + return p; +} + +#ifndef STB_VORBIS_NO_PUSHDATA_API + +void stb_vorbis_flush_pushdata(stb_vorbis *f) +{ + f->previous_length = 0; + f->page_crc_tests = 0; + f->discard_samples_deferred = 0; + f->current_loc_valid = FALSE; + f->first_decode = FALSE; + f->samples_output = 0; + f->channel_buffer_start = 0; + f->channel_buffer_end = 0; +} + +static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len) +{ + int i,n; + for (i=0; i < f->page_crc_tests; ++i) + f->scan[i].bytes_done = 0; + + // if we have room for more scans, search for them first, because + // they may cause us to stop early if their header is incomplete + if (f->page_crc_tests < STB_VORBIS_PUSHDATA_CRC_COUNT) { + if (data_len < 4) return 0; + data_len -= 3; // need to look for 4-byte sequence, so don't miss + // one that straddles a boundary + for (i=0; i < data_len; ++i) { + if (data[i] == 0x4f) { + if (0==memcmp(data+i, ogg_page_header, 4)) { + int j,len; + uint32 crc; + // make sure we have the whole page header + if (i+26 >= data_len || i+27+data[i+26] >= data_len) { + // only read up to this page start, so hopefully we'll + // have the whole page header start next time + data_len = i; + break; + } + // ok, we have it all; compute the length of the page + len = 27 + data[i+26]; + for (j=0; j < data[i+26]; ++j) + len += data[i+27+j]; + // scan everything up to the embedded crc (which we must 0) + crc = 0; + for (j=0; j < 22; ++j) + crc = crc32_update(crc, data[i+j]); + // now process 4 0-bytes + for ( ; j < 26; ++j) + crc = crc32_update(crc, 0); + // len is the total number of bytes we need to scan + n = f->page_crc_tests++; + f->scan[n].bytes_left = len-j; + f->scan[n].crc_so_far = crc; + f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24); + // if the last frame on a page is continued to the next, then + // we can't recover the sample_loc immediately + if (data[i+27+data[i+26]-1] == 255) + f->scan[n].sample_loc = ~0; + else + f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24); + f->scan[n].bytes_done = i+j; + if (f->page_crc_tests == STB_VORBIS_PUSHDATA_CRC_COUNT) + break; + // keep going if we still have room for more + } + } + } + } + + for (i=0; i < f->page_crc_tests;) { + uint32 crc; + int j; + int n = f->scan[i].bytes_done; + int m = f->scan[i].bytes_left; + if (m > data_len - n) m = data_len - n; + // m is the bytes to scan in the current chunk + crc = f->scan[i].crc_so_far; + for (j=0; j < m; ++j) + crc = crc32_update(crc, data[n+j]); + f->scan[i].bytes_left -= m; + f->scan[i].crc_so_far = crc; + if (f->scan[i].bytes_left == 0) { + // does it match? + if (f->scan[i].crc_so_far == f->scan[i].goal_crc) { + // Houston, we have page + data_len = n+m; // consumption amount is wherever that scan ended + f->page_crc_tests = -1; // drop out of page scan mode + f->previous_length = 0; // decode-but-don't-output one frame + f->next_seg = -1; // start a new page + f->current_loc = f->scan[i].sample_loc; // set the current sample location + // to the amount we'd have decoded had we decoded this page + f->current_loc_valid = f->current_loc != ~0U; + return data_len; + } + // delete entry + f->scan[i] = f->scan[--f->page_crc_tests]; + } else { + ++i; + } + } + + return data_len; +} + +// return value: number of bytes we used +int stb_vorbis_decode_frame_pushdata( + stb_vorbis *f, // the file we're decoding + const uint8 *data, int data_len, // the memory available for decoding + int *channels, // place to write number of float * buffers + float ***output, // place to write float ** array of float * buffers + int *samples // place to write number of output samples + ) +{ + int i; + int len,right,left; + + if (!IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (f->page_crc_tests >= 0) { + *samples = 0; + return vorbis_search_for_page_pushdata(f, (uint8 *) data, data_len); + } + + f->stream = (uint8 *) data; + f->stream_end = (uint8 *) data + data_len; + f->error = VORBIS__no_error; + + // check that we have the entire packet in memory + if (!is_whole_packet_present(f)) { + *samples = 0; + return 0; + } + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + // save the actual error we encountered + enum STBVorbisError error = f->error; + if (error == VORBIS_bad_packet_type) { + // flush and resynch + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + if (error == VORBIS_continued_packet_flag_invalid) { + if (f->previous_length == 0) { + // we may be resynching, in which case it's ok to hit one + // of these; just discard the packet + f->error = VORBIS__no_error; + while (get8_packet(f) != EOP) + if (f->eof) break; + *samples = 0; + return (int) (f->stream - data); + } + } + // if we get an error while parsing, what to do? + // well, it DEFINITELY won't work to continue from where we are! + stb_vorbis_flush_pushdata(f); + // restore the error that actually made us bail + f->error = error; + *samples = 0; + return 1; + } + + // success! + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + if (channels) *channels = f->channels; + *samples = len; + *output = f->outputs; + return (int) (f->stream - data); +} + +stb_vorbis *stb_vorbis_open_pushdata( + const unsigned char *data, int data_len, // the memory available for decoding + int *data_used, // only defined if result is not NULL + int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + data_len; + p.push_mode = TRUE; + if (!start_decoder(&p)) { + if (p.eof) + *error = VORBIS_need_more_data; + else + *error = p.error; + return NULL; + } + f = vorbis_alloc(&p); + if (f) { + *f = p; + *data_used = (int) (f->stream - data); + *error = 0; + return f; + } else { + vorbis_deinit(&p); + return NULL; + } +} +#endif // STB_VORBIS_NO_PUSHDATA_API + +unsigned int stb_vorbis_get_file_offset(stb_vorbis *f) +{ + #ifndef STB_VORBIS_NO_PUSHDATA_API + if (f->push_mode) return 0; + #endif + if (USE_MEMORY(f)) return (unsigned int) (f->stream - f->stream_start); + #ifndef STB_VORBIS_NO_STDIO + return (unsigned int) (ftell(f->f) - f->f_start); + #endif +} + +#ifndef STB_VORBIS_NO_PULLDATA_API +// +// DATA-PULLING API +// + +static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last) +{ + for(;;) { + int n; + if (f->eof) return 0; + n = get8(f); + if (n == 0x4f) { // page header candidate + unsigned int retry_loc = stb_vorbis_get_file_offset(f); + int i; + // check if we're off the end of a file_section stream + if (retry_loc - 25 > f->stream_len) + return 0; + // check the rest of the header + for (i=1; i < 4; ++i) + if (get8(f) != ogg_page_header[i]) + break; + if (f->eof) return 0; + if (i == 4) { + uint8 header[27]; + uint32 i, crc, goal, len; + for (i=0; i < 4; ++i) + header[i] = ogg_page_header[i]; + for (; i < 27; ++i) + header[i] = get8(f); + if (f->eof) return 0; + if (header[4] != 0) goto invalid; + goal = header[22] + (header[23] << 8) + (header[24]<<16) + (header[25]<<24); + for (i=22; i < 26; ++i) + header[i] = 0; + crc = 0; + for (i=0; i < 27; ++i) + crc = crc32_update(crc, header[i]); + len = 0; + for (i=0; i < header[26]; ++i) { + int s = get8(f); + crc = crc32_update(crc, s); + len += s; + } + if (len && f->eof) return 0; + for (i=0; i < len; ++i) + crc = crc32_update(crc, get8(f)); + // finished parsing probable page + if (crc == goal) { + // we could now check that it's either got the last + // page flag set, OR it's followed by the capture + // pattern, but I guess TECHNICALLY you could have + // a file with garbage between each ogg page and recover + // from it automatically? So even though that paranoia + // might decrease the chance of an invalid decode by + // another 2^32, not worth it since it would hose those + // invalid-but-useful files? + if (end) + *end = stb_vorbis_get_file_offset(f); + if (last) { + if (header[5] & 0x04) + *last = 1; + else + *last = 0; + } + set_file_offset(f, retry_loc-1); + return 1; + } + } + invalid: + // not a valid page, so rewind and look for next one + set_file_offset(f, retry_loc); + } + } +} + + +#define SAMPLE_unknown 0xffffffff + +// seeking is implemented with a binary search, which narrows down the range to +// 64K, before using a linear search (because finding the synchronization +// pattern can be expensive, and the chance we'd find the end page again is +// relatively high for small ranges) +// +// two initial interpolation-style probes are used at the start of the search +// to try to bound either side of the binary search sensibly, while still +// working in O(log n) time if they fail. + +static int get_seek_page_info(stb_vorbis *f, ProbedPage *z) +{ + uint8 header[27], lacing[255]; + int i,len; + + // record where the page starts + z->page_start = stb_vorbis_get_file_offset(f); + + // parse the header + getn(f, header, 27); + if (header[0] != 'O' || header[1] != 'g' || header[2] != 'g' || header[3] != 'S') + return 0; + getn(f, lacing, header[26]); + + // determine the length of the payload + len = 0; + for (i=0; i < header[26]; ++i) + len += lacing[i]; + + // this implies where the page ends + z->page_end = z->page_start + 27 + header[26] + len; + + // read the last-decoded sample out of the data + z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 24); + + // restore file state to where we were + set_file_offset(f, z->page_start); + return 1; +} + +// rarely used function to seek back to the preceding page while finding the +// start of a packet +static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset) +{ + unsigned int previous_safe, end; + + // now we want to seek back 64K from the limit + if (limit_offset >= 65536 && limit_offset-65536 >= f->first_audio_page_offset) + previous_safe = limit_offset - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + + while (vorbis_find_page(f, &end, NULL)) { + if (end >= limit_offset && stb_vorbis_get_file_offset(f) < limit_offset) + return 1; + set_file_offset(f, end); + } + + return 0; +} + +// implements the search logic for finding a page and starting decoding. if +// the function succeeds, current_loc_valid will be true and current_loc will +// be less than or equal to the provided sample number (the closer the +// better). +static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number) +{ + ProbedPage left, right, mid; + int i, start_seg_with_known_loc, end_pos, page_start; + uint32 delta, stream_length, padding, last_sample_limit; + double offset = 0.0, bytes_per_sample = 0.0; + int probe = 0; + + // find the last page and validate the target sample + stream_length = stb_vorbis_stream_length_in_samples(f); + if (stream_length == 0) return error(f, VORBIS_seek_without_length); + if (sample_number > stream_length) return error(f, VORBIS_seek_invalid); + + // this is the maximum difference between the window-center (which is the + // actual granule position value), and the right-start (which the spec + // indicates should be the granule position (give or take one)). + padding = ((f->blocksize_1 - f->blocksize_0) >> 2); + if (sample_number < padding) + last_sample_limit = 0; + else + last_sample_limit = sample_number - padding; + + left = f->p_first; + while (left.last_decoded_sample == ~0U) { + // (untested) the first page does not have a 'last_decoded_sample' + set_file_offset(f, left.page_end); + if (!get_seek_page_info(f, &left)) goto error; + } + + right = f->p_last; + assert(right.last_decoded_sample != ~0U); + + // starting from the start is handled differently + if (last_sample_limit <= left.last_decoded_sample) { + if (stb_vorbis_seek_start(f)) { + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + return 1; + } + return 0; + } + + while (left.page_end != right.page_start) { + assert(left.page_end < right.page_start); + // search range in bytes + delta = right.page_start - left.page_end; + if (delta <= 65536) { + // there's only 64K left to search - handle it linearly + set_file_offset(f, left.page_end); + } else { + if (probe < 2) { + if (probe == 0) { + // first probe (interpolate) + double data_bytes = right.page_end - left.page_start; + bytes_per_sample = data_bytes / right.last_decoded_sample; + offset = left.page_start + bytes_per_sample * (last_sample_limit - left.last_decoded_sample); + } else { + // second probe (try to bound the other side) + double error = ((double) last_sample_limit - mid.last_decoded_sample) * bytes_per_sample; + if (error >= 0 && error < 8000) error = 8000; + if (error < 0 && error > -8000) error = -8000; + offset += error * 2; + } + + // ensure the offset is valid + if (offset < left.page_end) + offset = left.page_end; + if (offset > right.page_start - 65536) + offset = right.page_start - 65536; + + set_file_offset(f, (unsigned int) offset); + } else { + // binary search for large ranges (offset by 32K to ensure + // we don't hit the right page) + set_file_offset(f, left.page_end + (delta / 2) - 32768); + } + + if (!vorbis_find_page(f, NULL, NULL)) goto error; + } + + for (;;) { + if (!get_seek_page_info(f, &mid)) goto error; + if (mid.last_decoded_sample != ~0U) break; + // (untested) no frames end on this page + set_file_offset(f, mid.page_end); + assert(mid.page_start < right.page_start); + } + + // if we've just found the last page again then we're in a tricky file, + // and we're close enough (if it wasn't an interpolation probe). + if (mid.page_start == right.page_start) { + if (probe >= 2 || delta <= 65536) + break; + } else { + if (last_sample_limit < mid.last_decoded_sample) + right = mid; + else + left = mid; + } + + ++probe; + } + + // seek back to start of the last packet + page_start = left.page_start; + set_file_offset(f, page_start); + if (!start_page(f)) return error(f, VORBIS_seek_failed); + end_pos = f->end_seg_with_known_loc; + assert(end_pos >= 0); + + for (;;) { + for (i = end_pos; i > 0; --i) + if (f->segments[i-1] != 255) + break; + + start_seg_with_known_loc = i; + + if (start_seg_with_known_loc > 0 || !(f->page_flag & PAGEFLAG_continued_packet)) + break; + + // (untested) the final packet begins on an earlier page + if (!go_to_page_before(f, page_start)) + goto error; + + page_start = stb_vorbis_get_file_offset(f); + if (!start_page(f)) goto error; + end_pos = f->segment_count - 1; + } + + // prepare to start decoding + f->current_loc_valid = FALSE; + f->last_seg = FALSE; + f->valid_bits = 0; + f->packet_bytes = 0; + f->bytes_in_seg = 0; + f->previous_length = 0; + f->next_seg = start_seg_with_known_loc; + + for (i = 0; i < start_seg_with_known_loc; i++) + skip(f, f->segments[i]); + + // start decoding (optimizable - this frame is generally discarded) + if (!vorbis_pump_first_frame(f)) + return 0; + if (f->current_loc > sample_number) + return error(f, VORBIS_seek_failed); + return 1; + +error: + // try to restore the file to a valid state + stb_vorbis_seek_start(f); + return error(f, VORBIS_seek_failed); +} + +// the same as vorbis_decode_initial, but without advancing +static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode) +{ + int bits_read, bytes_read; + + if (!vorbis_decode_initial(f, p_left_start, p_left_end, p_right_start, p_right_end, mode)) + return 0; + + // either 1 or 2 bytes were read, figure out which so we can rewind + bits_read = 1 + ilog(f->mode_count-1); + if (f->mode_config[*mode].blockflag) + bits_read += 2; + bytes_read = (bits_read + 7) / 8; + + f->bytes_in_seg += bytes_read; + f->packet_bytes -= bytes_read; + skip(f, -bytes_read); + if (f->next_seg == -1) + f->next_seg = f->segment_count - 1; + else + f->next_seg--; + f->valid_bits = 0; + + return 1; +} + +int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number) +{ + uint32 max_frame_samples; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + // fast page-level search + if (!seek_to_sample_coarse(f, sample_number)) + return 0; + + assert(f->current_loc_valid); + assert(f->current_loc <= sample_number); + + // linear search for the relevant packet + max_frame_samples = (f->blocksize_1*3 - f->blocksize_0) >> 2; + while (f->current_loc < sample_number) { + int left_start, left_end, right_start, right_end, mode, frame_samples; + if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode)) + return error(f, VORBIS_seek_failed); + // calculate the number of samples returned by the next frame + frame_samples = right_start - left_start; + if (f->current_loc + frame_samples > sample_number) { + return 1; // the next frame will contain the sample + } else if (f->current_loc + frame_samples + max_frame_samples > sample_number) { + // there's a chance the frame after this could contain the sample + vorbis_pump_first_frame(f); + } else { + // this frame is too early to be relevant + f->current_loc += frame_samples; + f->previous_length = 0; + maybe_start_packet(f); + flush_packet(f); + } + } + // the next frame should start with the sample + if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed); + return 1; +} + +int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number) +{ + if (!stb_vorbis_seek_frame(f, sample_number)) + return 0; + + if (sample_number != f->current_loc) { + int n; + uint32 frame_start = f->current_loc; + stb_vorbis_get_frame_float(f, &n, NULL); + assert(sample_number > frame_start); + assert(f->channel_buffer_start + (int) (sample_number-frame_start) <= f->channel_buffer_end); + f->channel_buffer_start += (sample_number - frame_start); + } + + return 1; +} + +int stb_vorbis_seek_start(stb_vorbis *f) +{ + if (IS_PUSH_MODE(f)) { return error(f, VORBIS_invalid_api_mixing); } + set_file_offset(f, f->first_audio_page_offset); + f->previous_length = 0; + f->first_decode = TRUE; + f->next_seg = -1; + return vorbis_pump_first_frame(f); +} + +unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f) +{ + unsigned int restore_offset, previous_safe; + unsigned int end, last_page_loc; + + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + if (!f->total_samples) { + unsigned int last; + uint32 lo,hi; + char header[6]; + + // first, store the current decode position so we can restore it + restore_offset = stb_vorbis_get_file_offset(f); + + // now we want to seek back 64K from the end (the last page must + // be at most a little less than 64K, but let's allow a little slop) + if (f->stream_len >= 65536 && f->stream_len-65536 >= f->first_audio_page_offset) + previous_safe = f->stream_len - 65536; + else + previous_safe = f->first_audio_page_offset; + + set_file_offset(f, previous_safe); + // previous_safe is now our candidate 'earliest known place that seeking + // to will lead to the final page' + + if (!vorbis_find_page(f, &end, &last)) { + // if we can't find a page, we're hosed! + f->error = VORBIS_cant_find_last_page; + f->total_samples = 0xffffffff; + goto done; + } + + // check if there are more pages + last_page_loc = stb_vorbis_get_file_offset(f); + + // stop when the last_page flag is set, not when we reach eof; + // this allows us to stop short of a 'file_section' end without + // explicitly checking the length of the section + while (!last) { + set_file_offset(f, end); + if (!vorbis_find_page(f, &end, &last)) { + // the last page we found didn't have the 'last page' flag + // set. whoops! + break; + } + previous_safe = last_page_loc+1; + last_page_loc = stb_vorbis_get_file_offset(f); + } + + set_file_offset(f, last_page_loc); + + // parse the header + getn(f, (unsigned char *)header, 6); + // extract the absolute granule position + lo = get32(f); + hi = get32(f); + if (lo == 0xffffffff && hi == 0xffffffff) { + f->error = VORBIS_cant_find_last_page; + f->total_samples = SAMPLE_unknown; + goto done; + } + if (hi) + lo = 0xfffffffe; // saturate + f->total_samples = lo; + + f->p_last.page_start = last_page_loc; + f->p_last.page_end = end; + f->p_last.last_decoded_sample = lo; + + done: + set_file_offset(f, restore_offset); + } + return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples; +} + +float stb_vorbis_stream_length_in_seconds(stb_vorbis *f) +{ + return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate; +} + + + +int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output) +{ + int len, right,left,i; + if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing); + + if (!vorbis_decode_packet(f, &len, &left, &right)) { + f->channel_buffer_start = f->channel_buffer_end = 0; + return 0; + } + + len = vorbis_finish_frame(f, len, left, right); + for (i=0; i < f->channels; ++i) + f->outputs[i] = f->channel_buffers[i] + left; + + f->channel_buffer_start = left; + f->channel_buffer_end = left+len; + + if (channels) *channels = f->channels; + if (output) *output = f->outputs; + return len; +} + +#ifndef STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length) +{ + stb_vorbis *f, p; + vorbis_init(&p, alloc); + p.f = file; + p.f_start = (uint32) ftell(file); + p.stream_len = length; + p.close_on_free = close_on_free; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc) +{ + unsigned int len, start; + start = (unsigned int) ftell(file); + fseek(file, 0, SEEK_END); + len = (unsigned int) (ftell(file) - start); + fseek(file, start, SEEK_SET); + return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len); +} + +stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc) +{ + FILE *f; +#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__) + if (0 != fopen_s(&f, filename, "rb")) + f = NULL; +#else + f = fopen(filename, "rb"); +#endif + if (f) + return stb_vorbis_open_file(f, TRUE, error, alloc); + if (error) *error = VORBIS_file_open_failure; + return NULL; +} +#endif // STB_VORBIS_NO_STDIO + +stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc) +{ + stb_vorbis *f, p; + if (data == NULL) return NULL; + vorbis_init(&p, alloc); + p.stream = (uint8 *) data; + p.stream_end = (uint8 *) data + len; + p.stream_start = (uint8 *) p.stream; + p.stream_len = len; + p.push_mode = FALSE; + if (start_decoder(&p)) { + f = vorbis_alloc(&p); + if (f) { + *f = p; + vorbis_pump_first_frame(f); + if (error) *error = VORBIS__no_error; + return f; + } + } + if (error) *error = p.error; + vorbis_deinit(&p); + return NULL; +} + +#ifndef STB_VORBIS_NO_INTEGER_CONVERSION +#define PLAYBACK_MONO 1 +#define PLAYBACK_LEFT 2 +#define PLAYBACK_RIGHT 4 + +#define L (PLAYBACK_LEFT | PLAYBACK_MONO) +#define C (PLAYBACK_LEFT | PLAYBACK_RIGHT | PLAYBACK_MONO) +#define R (PLAYBACK_RIGHT | PLAYBACK_MONO) + +static int8 channel_position[7][6] = +{ + { 0 }, + { C }, + { L, R }, + { L, C, R }, + { L, R, L, R }, + { L, C, R, L, R }, + { L, C, R, L, R, C }, +}; + + +#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT + typedef union { + float f; + int i; + } float_conv; + typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4]; + #define FASTDEF(x) float_conv x + // add (1<<23) to convert to int, then divide by 2^SHIFT, then add 0.5/2^SHIFT to round + #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT)) + #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22)) + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s)) + #define check_endianness() +#else + #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s)))) + #define check_endianness() + #define FASTDEF(x) +#endif + +static void copy_samples(short *dest, float *src, int len) +{ + int i; + check_endianness(); + for (i=0; i < len; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp, src[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + dest[i] = v; + } +} + +static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len) +{ + #define BUFFER_SIZE 32 + float buffer[BUFFER_SIZE]; + int i,j,o,n = BUFFER_SIZE; + check_endianness(); + for (o = 0; o < len; o += BUFFER_SIZE) { + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + if (channel_position[num_c][j] & mask) { + for (i=0; i < n; ++i) + buffer[i] += data[j][d_offset+o+i]; + } + } + for (i=0; i < n; ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o+i] = v; + } + } +} + +static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len) +{ + #define BUFFER_SIZE 32 + float buffer[BUFFER_SIZE]; + int i,j,o,n = BUFFER_SIZE >> 1; + // o is the offset in the source data + check_endianness(); + for (o = 0; o < len; o += BUFFER_SIZE >> 1) { + // o2 is the offset in the output data + int o2 = o << 1; + memset(buffer, 0, sizeof(buffer)); + if (o + n > len) n = len - o; + for (j=0; j < num_c; ++j) { + int m = channel_position[num_c][j] & (PLAYBACK_LEFT | PLAYBACK_RIGHT); + if (m == (PLAYBACK_LEFT | PLAYBACK_RIGHT)) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_LEFT) { + for (i=0; i < n; ++i) { + buffer[i*2+0] += data[j][d_offset+o+i]; + } + } else if (m == PLAYBACK_RIGHT) { + for (i=0; i < n; ++i) { + buffer[i*2+1] += data[j][d_offset+o+i]; + } + } + } + for (i=0; i < (n<<1); ++i) { + FASTDEF(temp); + int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + output[o2+i] = v; + } + } +} + +static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples) +{ + int i; + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} }; + for (i=0; i < buf_c; ++i) + compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + for (i=0; i < limit; ++i) + copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples); + for ( ; i < buf_c; ++i) + memset(buffer[i]+b_offset, 0, sizeof(short) * samples); + } +} + +int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples) +{ + float **output = NULL; + int len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len > num_samples) len = num_samples; + if (len) + convert_samples_short(num_c, buffer, 0, f->channels, output, 0, len); + return len; +} + +static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len) +{ + int i; + check_endianness(); + if (buf_c != data_c && buf_c <= 2 && data_c <= 6) { + assert(buf_c == 2); + for (i=0; i < buf_c; ++i) + compute_stereo_samples(buffer, data_c, data, d_offset, len); + } else { + int limit = buf_c < data_c ? buf_c : data_c; + int j; + for (j=0; j < len; ++j) { + for (i=0; i < limit; ++i) { + FASTDEF(temp); + float f = data[i][d_offset+j]; + int v = FAST_SCALED_FLOAT_TO_INT(temp, f,15);//data[i][d_offset+j],15); + if ((unsigned int) (v + 32768) > 65535) + v = v < 0 ? -32768 : 32767; + *buffer++ = v; + } + for ( ; i < buf_c; ++i) + *buffer++ = 0; + } + } +} + +int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts) +{ + float **output; + int len; + if (num_c == 1) return stb_vorbis_get_frame_short(f,num_c,&buffer, num_shorts); + len = stb_vorbis_get_frame_float(f, NULL, &output); + if (len) { + if (len*num_c > num_shorts) len = num_shorts / num_c; + convert_channels_short_interleaved(num_c, buffer, f->channels, output, 0, len); + } + return len; +} + +int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts) +{ + float **outputs; + int len = num_shorts / channels; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_channels_short_interleaved(channels, buffer, f->channels, f->channel_buffers, f->channel_buffer_start, k); + buffer += k*channels; + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len) +{ + float **outputs; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + if (k) + convert_samples_short(channels, buffer, n, f->channels, f->channel_buffers, f->channel_buffer_start, k); + n += k; + f->channel_buffer_start += k; + if (n == len) break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break; + } + return n; +} + +#ifndef STB_VORBIS_NO_STDIO +int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_filename(filename, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // NO_STDIO + +int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output) +{ + int data_len, offset, total, limit, error; + short *data; + stb_vorbis *v = stb_vorbis_open_memory(mem, len, &error, NULL); + if (v == NULL) return -1; + limit = v->channels * 4096; + *channels = v->channels; + if (sample_rate) + *sample_rate = v->sample_rate; + offset = data_len = 0; + total = limit; + data = (short *) malloc(total * sizeof(*data)); + if (data == NULL) { + stb_vorbis_close(v); + return -2; + } + for (;;) { + int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset); + if (n == 0) break; + data_len += n; + offset += n * v->channels; + if (offset + limit > total) { + short *data2; + total *= 2; + data2 = (short *) realloc(data, total * sizeof(*data)); + if (data2 == NULL) { + free(data); + stb_vorbis_close(v); + return -2; + } + data = data2; + } + } + *output = data; + stb_vorbis_close(v); + return data_len; +} +#endif // STB_VORBIS_NO_INTEGER_CONVERSION + +int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats) +{ + float **outputs; + int len = num_floats / channels; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < len) { + int i,j; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= len) k = len - n; + for (j=0; j < k; ++j) { + for (i=0; i < z; ++i) + *buffer++ = f->channel_buffers[i][f->channel_buffer_start+j]; + for ( ; i < channels; ++i) + *buffer++ = 0; + } + n += k; + f->channel_buffer_start += k; + if (n == len) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} + +int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples) +{ + float **outputs; + int n=0; + int z = f->channels; + if (z > channels) z = channels; + while (n < num_samples) { + int i; + int k = f->channel_buffer_end - f->channel_buffer_start; + if (n+k >= num_samples) k = num_samples - n; + if (k) { + for (i=0; i < z; ++i) + memcpy(buffer[i]+n, f->channel_buffers[i]+f->channel_buffer_start, sizeof(float)*k); + for ( ; i < channels; ++i) + memset(buffer[i]+n, 0, sizeof(float) * k); + } + n += k; + f->channel_buffer_start += k; + if (n == num_samples) + break; + if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) + break; + } + return n; +} +#endif // STB_VORBIS_NO_PULLDATA_API + +/* Version history + 1.17 - 2019-07-08 - fix CVE-2019-13217, -13218, -13219, -13220, -13221, -13222, -13223 + found with Mayhem by ForAllSecure + 1.16 - 2019-03-04 - fix warnings + 1.15 - 2019-02-07 - explicit failure if Ogg Skeleton data is found + 1.14 - 2018-02-11 - delete bogus dealloca usage + 1.13 - 2018-01-29 - fix truncation of last frame (hopefully) + 1.12 - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files + 1.11 - 2017-07-23 - fix MinGW compilation + 1.10 - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory + 1.09 - 2016-04-04 - back out 'avoid discarding last frame' fix from previous version + 1.08 - 2016-04-02 - fixed multiple warnings; fix setup memory leaks; + avoid discarding last frame of audio data + 1.07 - 2015-01-16 - fixed some warnings, fix mingw, const-correct API + some more crash fixes when out of memory or with corrupt files + 1.06 - 2015-08-31 - full, correct support for seeking API (Dougall Johnson) + some crash fixes when out of memory or with corrupt files + 1.05 - 2015-04-19 - don't define __forceinline if it's redundant + 1.04 - 2014-08-27 - fix missing const-correct case in API + 1.03 - 2014-08-07 - Warning fixes + 1.02 - 2014-07-09 - Declare qsort compare function _cdecl on windows + 1.01 - 2014-06-18 - fix stb_vorbis_get_samples_float + 1.0 - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in multichannel + (API change) report sample rate for decode-full-file funcs + 0.99996 - bracket #include for macintosh compilation by Laurent Gomila + 0.99995 - use union instead of pointer-cast for fast-float-to-int to avoid alias-optimization problem + 0.99994 - change fast-float-to-int to work in single-precision FPU mode, remove endian-dependence + 0.99993 - remove assert that fired on legal files with empty tables + 0.99992 - rewind-to-start + 0.99991 - bugfix to stb_vorbis_get_samples_short by Bernhard Wodo + 0.9999 - (should have been 0.99990) fix no-CRT support, compiling as C++ + 0.9998 - add a full-decode function with a memory source + 0.9997 - fix a bug in the read-from-FILE case in 0.9996 addition + 0.9996 - query length of vorbis stream in samples/seconds + 0.9995 - bugfix to another optimization that only happened in certain files + 0.9994 - bugfix to one of the optimizations that caused significant (but inaudible?) errors + 0.9993 - performance improvements; runs in 99% to 104% of time of reference implementation + 0.9992 - performance improvement of IMDCT; now performs close to reference implementation + 0.9991 - performance improvement of IMDCT + 0.999 - (should have been 0.9990) performance improvement of IMDCT + 0.998 - no-CRT support from Casey Muratori + 0.997 - bugfixes for bugs found by Terje Mathisen + 0.996 - bugfix: fast-huffman decode initialized incorrectly for sparse codebooks; fixing gives 10% speedup - found by Terje Mathisen + 0.995 - bugfix: fix to 'effective' overrun detection - found by Terje Mathisen + 0.994 - bugfix: garbage decode on final VQ symbol of a non-multiple - found by Terje Mathisen + 0.993 - bugfix: pushdata API required 1 extra byte for empty page (failed to consume final page if empty) - found by Terje Mathisen + 0.992 - fixes for MinGW warning + 0.991 - turn fast-float-conversion on by default + 0.990 - fix push-mode seek recovery if you seek into the headers + 0.98b - fix to bad release of 0.98 + 0.98 - fix push-mode seek recovery; robustify float-to-int and support non-fast mode + 0.97 - builds under c++ (typecasting, don't use 'class' keyword) + 0.96 - somehow MY 0.95 was right, but the web one was wrong, so here's my 0.95 rereleased as 0.96, fixes a typo in the clamping code + 0.95 - clamping code for 16-bit functions + 0.94 - not publically released + 0.93 - fixed all-zero-floor case (was decoding garbage) + 0.92 - fixed a memory leak + 0.91 - conditional compiles to omit parts of the API and the infrastructure to support them: STB_VORBIS_NO_PULLDATA_API, STB_VORBIS_NO_PUSHDATA_API, STB_VORBIS_NO_STDIO, STB_VORBIS_NO_INTEGER_CONVERSION + 0.90 - first public release +*/ + +#endif // STB_VORBIS_HEADER_ONLY + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ \ No newline at end of file diff --git a/source/text.cpp b/source/text.cpp new file mode 100644 index 0000000..211d50c --- /dev/null +++ b/source/text.cpp @@ -0,0 +1,177 @@ +#include "const.h" +#include "text.h" +#include +#include + +// Constructor +Text::Text(std::string file, LTexture *texture, SDL_Renderer *renderer) +{ + mSprite = new Sprite(); + mSprite->setTexture(texture); + mSprite->setRenderer(renderer); + mFile = file; + + init(); +} + +// Destructor +Text::~Text() +{ + delete mSprite; + mSprite = nullptr; +} + +// Inicializador +void Text::init() +{ + // Inicializa a cero el vector con las coordenadas + for (int i = 0; i < 128; i++) + { + mOffset[i].x = 0; + mOffset[i].y = 0; + mOffset[i].w = 0; + } + + // Carga los offsets desde el fichero + initOffsetFromFile(); + + // Inicia los valores del sprite que dibuja las letras + mSprite->setWidth(mBoxWidth); + mSprite->setHeight(mBoxHeight); + mSprite->setPosX(0); + mSprite->setPosY(0); + mSprite->setSpriteClip(0, 0, mSprite->getWidth(), mSprite->getHeight()); + + // Establece las coordenadas para cada caracter ascii de la cadena y su ancho + for (int i = 32; i < 128; i++) + { + mOffset[i].x = ((i - 32) % 15) * mBoxWidth; + mOffset[i].y = ((i - 32) / 15) * mBoxHeight; + } +} + +// Escribe texto en pantalla +void Text::write(int x, int y, std::string text, int kerning, int lenght) +{ + Uint16 shift = 0; + + if (lenght == -1) + lenght = text.length(); + + for (int i = 0; i < lenght; ++i) + { + mSprite->setSpriteClip(mOffset[int(text[i])].x, mOffset[int(text[i])].y, mSprite->getWidth(), mSprite->getHeight()); + mSprite->setPosX(x + shift); + mSprite->setPosY(y); + mSprite->render(); + shift += (mOffset[int(text[i])].w + kerning); + } +} + +// Escribe el texto con colores +void Text::writeColored(int x, int y, std::string text, color_t color, int kerning, int lenght) +{ + mSprite->getTexture()->setColor(color.r, color.g, color.b); + write(x, y, text, kerning, lenght); + mSprite->getTexture()->setColor(255, 255, 255); +} + +// Escribe el texto con sombra +void Text::writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance, int kerning, int lenght) +{ + mSprite->getTexture()->setColor(color.r, color.g, color.b); + write(x + shadowDistance, y + shadowDistance, text, kerning, lenght); + mSprite->getTexture()->setColor(255, 255, 255); + write(x, y, text, kerning, lenght); +} + +// Escribe el texto centrado en un punto x +void Text::writeCentered(int x, int y, std::string text, int kerning, int lenght) +{ + x -= (Text::lenght(text, kerning) / 2); + write(x, y, text, kerning, lenght); +} + +// Escribe texto con extras +void Text::writeDX(Uint8 flags, int x, int y, std::string text, int kerning, color_t textColor, Uint8 shadowDistance, color_t shadowColor, int lenght) +{ + const bool centered = ((flags & TXT_CENTER) == TXT_CENTER); + const bool shadowed = ((flags & TXT_SHADOW) == TXT_SHADOW); + const bool colored = ((flags & TXT_COLOR) == TXT_COLOR); + const bool stroked = ((flags & TXT_STROKE) == TXT_STROKE); + + if (centered) + x -= (Text::lenght(text, kerning) / 2); + + if (shadowed) + writeColored(x + shadowDistance, y + shadowDistance, text, shadowColor, kerning, lenght); + + if (stroked) + { + writeColored(x + shadowDistance, y + shadowDistance, text, shadowColor, kerning, lenght); + writeColored(x - shadowDistance, y + shadowDistance, text, shadowColor, kerning, lenght); + writeColored(x + shadowDistance, y - shadowDistance, text, shadowColor, kerning, lenght); + writeColored(x - shadowDistance, y - shadowDistance, text, shadowColor, kerning, lenght); + + writeColored(x, y + shadowDistance, text, shadowColor, kerning, lenght); + writeColored(x, y - shadowDistance, text, shadowColor, kerning, lenght); + writeColored(x + shadowDistance, y, text, shadowColor, kerning, lenght); + writeColored(x - shadowDistance, y, text, shadowColor, kerning, lenght); + } + + if (colored) + writeColored(x, y, text, textColor, kerning, lenght); + else + write(x, y, text, kerning, lenght); +} + +// Obtiene la longitud en pixels de una cadena +Uint16 Text::lenght(std::string text, int kerning) +{ + Uint16 shift = 0; + + for (int i = 0; i < (int)text.length(); ++i) + shift += (mOffset[int(text[i])].w + kerning); + + return shift; +} + +// Inicializa el vector de offsets desde un fichero +void Text::initOffsetFromFile() +{ + std::ifstream rfile(mFile); + if (rfile.is_open() && rfile.good()) + { + std::string buffer; + //printf("Reading %s file\n", mFile.c_str()); + + // Lee los dos primeros valores del fichero + std::getline(rfile, buffer); + std::getline(rfile, buffer); + mBoxWidth = std::stoi(buffer); + + std::getline(rfile, buffer); + std::getline(rfile, buffer); + mBoxHeight = std::stoi(buffer); + + // lee el resto de datos del fichero + int index = 32; + int line_read = 0; + while (std::getline(rfile, buffer)) + { + // Almacena solo las lineas impares + if (line_read % 2 == 1) + mOffset[index++].w = std::stoi(buffer); + + // Limpia el buffer + buffer.clear(); + line_read++; + }; + } +} + +// Devuelve el valor de la variable +Uint8 Text::getCharacterWidth() +{ + return mBoxWidth; +} \ No newline at end of file diff --git a/source/text.h b/source/text.h new file mode 100644 index 0000000..e74b9db --- /dev/null +++ b/source/text.h @@ -0,0 +1,66 @@ +#pragma once +#include "sprite.h" +#include "utils.h" + +#ifndef TEXT_H +#define TEXT_H + +#define TXT_COLOR 1 +#define TXT_SHADOW 2 +#define TXT_CENTER 4 +#define TXT_STROKE 8 + +// Clase texto. Pinta texto en pantalla a partir de un bitmap +class Text +{ +private: + Sprite *mSprite; // Objeto con los graficos para el texto + + struct Offset + { + int x; + int y; + Uint8 w; + }; + Offset mOffset[128]; // Vector con las posiciones y ancho de cada letra + + Uint8 mBoxWidth; // Anchura de la caja de cada caracter en el png + Uint8 mBoxHeight; // Altura de la caja de cada caracter en el png + std::string mFile; // Fichero con los descriptores de la fuente + + // Inicializa el vector de offsets desde un fichero + void initOffsetFromFile(); + +public: + // Constructor + Text(std::string file, LTexture *texture, SDL_Renderer *renderer); + + // Destructor + ~Text(); + + // Inicializador + void init(); + + // Escribe el texto en pantalla + void write(int x, int y, std::string text, int kerning = 1, int lenght = -1); + + // Escribe el texto con colores + void writeColored(int x, int y, std::string text, color_t color, int kerning = 1, int lenght = -1); + + // Escribe el texto con sombra + void writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance = 1, int kerning = 1, int lenght = -1); + + // Escribe el texto centrado en un punto x y con kerning + void writeCentered(int x, int y, std::string text, int kerning = 1, int lenght = -1); + + // Escribe texto con extras + void writeDX(Uint8 flags, int x, int y, std::string text, int kerning = 1, color_t textColor = {255, 255, 255}, Uint8 shadowDistance = 1, color_t shadowColor = {0, 0, 0}, int lenght = -1); + + // Obtiene la longitud en pixels de una cadena + Uint16 lenght(std::string text, int kerning = 1); + + // Devuelve el valor de la variable + Uint8 getCharacterWidth(); +}; + +#endif diff --git a/source/utils.cpp b/source/utils.cpp new file mode 100644 index 0000000..2b28c40 --- /dev/null +++ b/source/utils.cpp @@ -0,0 +1,124 @@ +#include "utils.h" + +// Calcula el cuadrado de la distancia entre dos puntos +double distanceSquared(int x1, int y1, int x2, int y2) +{ + int deltaX = x2 - x1; + int deltaY = y2 - y1; + return deltaX * deltaX + deltaY * deltaY; +} + +// Detector de colisiones entre dos circulos +bool checkCollision(circle_t &a, circle_t &b) +{ + // Calcula el radio total al cuadrado + int totalRadiusSquared = a.r + b.r; + totalRadiusSquared = totalRadiusSquared * totalRadiusSquared; + + // Si la distancia entre el centro de los circulos es inferior a la suma de sus radios + if (distanceSquared(a.x, a.y, b.x, b.y) < (totalRadiusSquared)) + { + // Los circulos han colisionado + return true; + } + + // En caso contrario + return false; +} + +// Detector de colisiones entre un circulo y un rectangulo +bool checkCollision(circle_t &a, SDL_Rect &b) +{ + //Closest point on collision box + int cX, cY; + + //Find closest x offset + if (a.x < b.x) + { + cX = b.x; + } + else if (a.x > b.x + b.w) + { + cX = b.x + b.w; + } + else + { + cX = a.x; + } + + //Find closest y offset + if (a.y < b.y) + { + cY = b.y; + } + else if (a.y > b.y + b.h) + { + cY = b.y + b.h; + } + else + { + cY = a.y; + } + + //If the closest point is inside the circle_t + if (distanceSquared(a.x, a.y, cX, cY) < a.r * a.r) + { + //This box and the circle_t have collided + return true; + } + + //If the shapes have not collided + return false; +} + +// Detector de colisiones entre un dos rectangulos +bool checkCollision(SDL_Rect &a, SDL_Rect &b) +{ + //Calculate the sides of rect A + int leftA = a.x; + int rightA = a.x + a.w; + int topA = a.y; + int bottomA = a.y + a.h; + + //Calculate the sides of rect B + int leftB = b.x; + int rightB = b.x + b.w; + int topB = b.y; + int bottomB = b.y + b.h; + + //If any of the sides from A are outside of B + if (bottomA <= topB) + { + return false; + } + + if (topA >= bottomB) + { + return false; + } + + if (rightA <= leftB) + { + return false; + } + + if (leftA >= rightB) + { + return false; + } + + //If none of the sides from A are outside B + return true; +} + +// Carga un archivo de imagen en una textura +bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer) +{ + bool success = true; + if (!texture->loadFromFile(path, renderer)) + { + printf("Failed to load %s texture!\n", path.c_str()); + success = false; + } + return success; +} \ No newline at end of file diff --git a/source/utils.h b/source/utils.h new file mode 100644 index 0000000..6d25712 --- /dev/null +++ b/source/utils.h @@ -0,0 +1,78 @@ +#pragma once +#include "ifdefs.h" +#include "ltexture.h" +#include + +#ifndef UTILS_H +#define UTILS_H + +// Estructura para definir un circulo +struct circle_t +{ + int x; + int y; + int r; +}; + +// Estructura para definir un color +struct color_t +{ + Uint8 r; + Uint8 g; + Uint8 b; +}; + +// Estructura para saber la seccion y subseccion del programa +struct section_t +{ + Uint8 name; + Uint8 subsection; +}; + +// Estructura para mapear el teclado usado en la demo +struct demoKeys_t +{ + Uint8 left; + Uint8 right; + Uint8 noInput; + Uint8 fire; + Uint8 fireLeft; + Uint8 fireRight; +}; + +// Estructura para albergar métodos de control +struct input_t +{ + int id; // Identificador en el vector de mandos + std::string name; // Nombre del dispositivo + Uint8 deviceType; // Tipo de dispositivo (teclado o mando) +}; + +// Estructura con todas las opciones de configuración del programa +struct options_t +{ + Uint8 difficulty; // Dificultad del juego + input_t input[2]; // Modo de control (teclado o mando) + Uint8 language; // Idioma usado en el juego + Uint32 fullScreenMode; // Contiene el valor del modo de pantalla completa + Uint8 windowSize; // Contiene el valor del tamaño de la ventana + Uint32 filter; // Filtro usado para el escalado de la imagen + bool vSync; // Indica si se quiere usar vsync o no +}; + +// Calcula el cuadrado de la distancia entre dos puntos +double distanceSquared(int x1, int y1, int x2, int y2); + +// Detector de colisiones entre dos circulos +bool checkCollision(circle_t &a, circle_t &b); + +// Detector de colisiones entre un circulo y un rectangulo +bool checkCollision(circle_t &a, SDL_Rect &b); + +// Detector de colisiones entre un dos rectangulos +bool checkCollision(SDL_Rect a, SDL_Rect b); + +// Carga un archivo de imagen en una textura +bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer); + +#endif \ No newline at end of file diff --git a/source/writer.cpp b/source/writer.cpp new file mode 100644 index 0000000..ef9cfa7 --- /dev/null +++ b/source/writer.cpp @@ -0,0 +1,158 @@ +#include "const.h" +#include "writer.h" + +// Constructor +Writer::Writer(Text *text) +{ + mText = text; + init(); +} + +// Destructor +Writer::~Writer() +{ + mText = nullptr; +} + +// Inicializador +void Writer::init() +{ + mPosX = 0; + mPosY = 0; + mKerning = 0; + mCaption = ""; + mSpeed = 0; + mTimer = 0; + mIndex = 0; + mLenght = 0; + mCompleted = false; + mEnabled = false; + mEnabledTimer = 0; + mId = -1; + mIntroEvents = nullptr; +} + +// Establece el valor de la variable +void Writer::setPosX(int value) +{ + mPosX = value; +} + +// Establece el valor de la variable +void Writer::setPosY(int value) +{ + mPosY = value; +} + +// Establece el valor de la variable +void Writer::setKerning(int value) +{ + mKerning = value; +} + +// Establece el valor de la variable +void Writer::setCaption(std::string text) +{ + mCaption = text; + mLenght = text.length(); +} + +// Establece el valor de la variable +void Writer::setSpeed(Uint16 value) +{ + mSpeed = value; + mTimer = value; +} + +// Establece el valor de la variable +void Writer::setEnabled(bool value) +{ + mEnabled = value; +} + +// Obtiene el valor de la variable +bool Writer::IsEnabled() +{ + return mEnabled; +} + +// Establece el valor de la variable +void Writer::setEnabledTimer(Uint16 value) +{ + mEnabledTimer = value; +} + +// Obtiene el valor de la variable +Uint16 Writer::getEnabledTimer() +{ + return mEnabledTimer; +} + +// Actualiza el objeto +void Writer::update() +{ + if (mEnabled) + { + if (mCompleted == false) + { + if (mTimer > 0) + { + mTimer--; + } + if (mTimer == 0) + { + mIndex++; + mTimer = mSpeed; + } + if (mIndex == mLenght) + { + mCompleted = true; + } + } + if (mCompleted) + { + if (mEnabledTimer > 0) + { + mEnabledTimer--; + } + else if (mEnabledTimer == 0) + { + if (mId < 0) + { + mEnabled = false; + } + else + { + mIntroEvents[mId] = EVENT_COMPLETED; + } + } + } + } +} + +// Dibuja el objeto en pantalla +void Writer::render() +{ + if (mEnabled) + { + mText->write(mPosX, mPosY, mCaption, mKerning, mIndex); + } +} + +// Centra la cadena de texto a un punto X +void Writer::center(int x) +{ + setPosX(x - (mText->lenght(mCaption, mKerning) / 2)); +} + +// Establece el valor de la variable +void Writer::setId(int id) +{ + mId = id; +} + +// Establece el valor de la variable +void Writer::setIntroEvents(Uint8 *value) +{ + mIntroEvents = value; +} diff --git a/source/writer.h b/source/writer.h new file mode 100644 index 0000000..b3a4051 --- /dev/null +++ b/source/writer.h @@ -0,0 +1,80 @@ +#pragma once +#include "sprite.h" +#include "text.h" + +#ifndef WRITER_H +#define WRITER_H + +// Clase texto. Pinta texto en pantalla a partir de un bitmap +class Writer +{ +private: + int mPosX; // Posicion en el eje X donde empezar a escribir el texto + int mPosY; // Posicion en el eje Y donde empezar a escribir el texto + int mKerning; // Kerning del texto, es decir, espaciado entre caracteres + std::string mCaption; // El texto para escribir + Uint16 mSpeed; // Velocidad de escritura + Uint16 mTimer; // Temporizador de escritura para cada caracter + Uint16 mIndex; // Posición del texto que se está escribiendo + Uint16 mLenght; // Longitud de la cadena a escribir + bool mCompleted; // Indica si se ha escrito todo el texto + bool mEnabled; // Indica si el objeto está habilitado + Uint16 mEnabledTimer; // Temporizador para deshabilitar el objeto + int mId; // Temporizador para deshabilitar el objeto + Uint8 *mIntroEvents; // Dirección del array de eventos donde notificar el estado + Text *mText; // Objeto encargado de escribir el texto + +public: + // Constructor + Writer(Text *text); + + // Destructor + ~Writer(); + + // Inicializador + void init(); + + // Establece el valor de la variable + void setPosX(int value); + + // Establece el valor de la variable + void setPosY(int value); + + // Establece el valor de la variable + void setKerning(int value); + + // Establece el valor de la variable + void setCaption(std::string text); + + // Establece el valor de la variable + void setSpeed(Uint16 value); + + // Establece el valor de la variable + void setEnabled(bool value); + + // Obtiene el valor de la variable + bool IsEnabled(); + + // Establece el valor de la variable + void setEnabledTimer(Uint16 value); + + // Obtiene el valor de la variable + Uint16 getEnabledTimer(); + + // Actualiza el objeto + void update(); + + // Dibuja el objeto en pantalla + void render(); + + // Centra la cadena de texto a un punto X + void center(int x); + + // Establece el valor de la variable + void setId(int id); + + // Establece el valor de la variable + void setIntroEvents(Uint8 *value); +}; + +#endif