diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5e4f6ac --- /dev/null +++ b/Makefile @@ -0,0 +1,6 @@ +macos: + mkdir -p bin + g++ -std=c++11 -Wall -O2 source/*.cpp -o bin/coffee_crisis_macos -lSDL2 +linux: + mkdir -p bin + g++ -std=c++11 -Wall -O2 source/*.cpp -o bin/coffee_crisis_linux -lSDL2 \ No newline at end of file diff --git a/data/demo.bin b/data/demo.bin new file mode 100644 index 0000000..cef4d56 Binary files /dev/null and b/data/demo.bin differ diff --git a/media/.DS_Store b/media/.DS_Store new file mode 100644 index 0000000..3b4105f Binary files /dev/null and b/media/.DS_Store differ diff --git a/media/gfx/.DS_Store b/media/gfx/.DS_Store new file mode 100644 index 0000000..69694f0 Binary files /dev/null and b/media/gfx/.DS_Store differ diff --git a/media/gfx/balloon.png b/media/gfx/balloon.png new file mode 100644 index 0000000..109efde Binary files /dev/null and b/media/gfx/balloon.png differ diff --git a/media/gfx/bullet.png b/media/gfx/bullet.png new file mode 100644 index 0000000..2bf612f Binary files /dev/null and b/media/gfx/bullet.png differ diff --git a/media/gfx/font_black.png b/media/gfx/font_black.png new file mode 100644 index 0000000..e748aa8 Binary files /dev/null and b/media/gfx/font_black.png differ diff --git a/media/gfx/font_nokia.png b/media/gfx/font_nokia.png new file mode 100644 index 0000000..e25095d Binary files /dev/null and b/media/gfx/font_nokia.png differ diff --git a/media/gfx/font_white.png b/media/gfx/font_white.png new file mode 100644 index 0000000..71bcd7c Binary files /dev/null and b/media/gfx/font_white.png differ diff --git a/media/gfx/game_bg.png b/media/gfx/game_bg.png new file mode 100644 index 0000000..83fe965 Binary files /dev/null and b/media/gfx/game_bg.png differ diff --git a/media/gfx/game_text.png b/media/gfx/game_text.png new file mode 100644 index 0000000..f10bb20 Binary files /dev/null and b/media/gfx/game_text.png differ diff --git a/media/gfx/intro.png b/media/gfx/intro.png new file mode 100644 index 0000000..af50d59 Binary files /dev/null and b/media/gfx/intro.png differ diff --git a/media/gfx/items.png b/media/gfx/items.png new file mode 100644 index 0000000..b8c3a75 Binary files /dev/null and b/media/gfx/items.png differ diff --git a/media/gfx/logo.png b/media/gfx/logo.png new file mode 100644 index 0000000..10e7f42 Binary files /dev/null and b/media/gfx/logo.png differ diff --git a/media/gfx/menu.png b/media/gfx/menu.png new file mode 100644 index 0000000..805518a Binary files /dev/null and b/media/gfx/menu.png differ diff --git a/media/gfx/player_body.png b/media/gfx/player_body.png new file mode 100644 index 0000000..6612800 Binary files /dev/null and b/media/gfx/player_body.png differ diff --git a/media/gfx/player_death.png b/media/gfx/player_death.png new file mode 100644 index 0000000..6ee12f0 Binary files /dev/null and b/media/gfx/player_death.png differ diff --git a/media/gfx/player_legs.png b/media/gfx/player_legs.png new file mode 100644 index 0000000..2421820 Binary files /dev/null and b/media/gfx/player_legs.png differ diff --git a/media/gfx/title.png b/media/gfx/title.png new file mode 100644 index 0000000..1768f59 Binary files /dev/null and b/media/gfx/title.png differ diff --git a/media/music/.DS_Store b/media/music/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/media/music/.DS_Store differ diff --git a/media/music/credits.txt b/media/music/credits.txt new file mode 100644 index 0000000..803687b --- /dev/null +++ b/media/music/credits.txt @@ -0,0 +1,10 @@ +playing.ogg +ARCADE GOBLINS +https://soundimage.org/chiptunes-3/ + +title.ogg +ARCADE STORIES +https://soundimage.org/chiptunes-3/ + +intro.ogg +JailDoctor \ No newline at end of file diff --git a/media/music/intro.ogg b/media/music/intro.ogg new file mode 100644 index 0000000..26fdce4 Binary files /dev/null and b/media/music/intro.ogg differ diff --git a/media/music/playing.ogg b/media/music/playing.ogg new file mode 100644 index 0000000..75f86e7 Binary files /dev/null and b/media/music/playing.ogg differ diff --git a/media/music/title.ogg b/media/music/title.ogg new file mode 100644 index 0000000..4204e28 Binary files /dev/null and b/media/music/title.ogg differ diff --git a/media/sound/balloon.wav b/media/sound/balloon.wav new file mode 100644 index 0000000..e4fd892 Binary files /dev/null and b/media/sound/balloon.wav differ diff --git a/media/sound/bubble1.wav b/media/sound/bubble1.wav new file mode 100644 index 0000000..876ce1d Binary files /dev/null and b/media/sound/bubble1.wav differ diff --git a/media/sound/bubble2.wav b/media/sound/bubble2.wav new file mode 100644 index 0000000..a44743e Binary files /dev/null and b/media/sound/bubble2.wav differ diff --git a/media/sound/bubble3.wav b/media/sound/bubble3.wav new file mode 100644 index 0000000..fdda857 Binary files /dev/null and b/media/sound/bubble3.wav differ diff --git a/media/sound/bubble4.wav b/media/sound/bubble4.wav new file mode 100644 index 0000000..90c7472 Binary files /dev/null and b/media/sound/bubble4.wav differ diff --git a/media/sound/bullet.wav b/media/sound/bullet.wav new file mode 100644 index 0000000..9d241ff Binary files /dev/null and b/media/sound/bullet.wav differ diff --git a/media/sound/coffeeout.wav b/media/sound/coffeeout.wav new file mode 100644 index 0000000..1e3c4ff Binary files /dev/null and b/media/sound/coffeeout.wav differ diff --git a/media/sound/credits.txt b/media/sound/credits.txt new file mode 100644 index 0000000..01e9d6e --- /dev/null +++ b/media/sound/credits.txt @@ -0,0 +1,60 @@ +bullet.wav +Gun11.wav +http://www.themotionmonkey.co.uk/free-resources/retro-arcade-sounds/ + +balloon.wav +Impact3.wav +http://www.themotionmonkey.co.uk/free-resources/retro-arcade-sounds/ + +player_collision.wav +Impact5.wav +http://www.themotionmonkey.co.uk/free-resources/retro-arcade-sounds/ + +title.wav +Explosion2.wav +http://www.themotionmonkey.co.uk/free-resources/retro-arcade-sounds/ + +menu_select.wav +kenney_digitalaudio/powerUp2.ogg +www.kenney.nl + +menu_move.wav +kenney_uiaudio/switch11.ogg +www.kenney.nl + +hiscore.wav +kenney_digitalaudio/powerUp1.ogg +www.kenney.nl + +itemdrop.wav +kenney_digitalaudio/PowerUp10.ogg +www.kenney.nl + +itempickup.wav +kenney_digitalaudio/PowerUp7.ogg +www.kenney.nl + +coffeeout.wav +kenney_digitalaudio/lowDown.ogg +www.kenney.nl + +stage_change.wav +kenney_digitalaudio/phaserUp2.ogg +www.kenney.nl + +menu_cancel.wav +kenney_digitalaudio/lowRandom.ogg +kenney_digitalaudio/pepSound1.ogg <- +www.kenney.nl + +bubble1.wav +JailDoctor + +bubble2.wav +JailDoctor + +bubble3.wav +JailDoctor + +bubble4.wav +JailDoctor \ No newline at end of file diff --git a/media/sound/hiscore.wav b/media/sound/hiscore.wav new file mode 100644 index 0000000..87ba9ad Binary files /dev/null and b/media/sound/hiscore.wav differ diff --git a/media/sound/itemdrop.wav b/media/sound/itemdrop.wav new file mode 100644 index 0000000..820ca68 Binary files /dev/null and b/media/sound/itemdrop.wav differ diff --git a/media/sound/itempickup.wav b/media/sound/itempickup.wav new file mode 100644 index 0000000..1f9c387 Binary files /dev/null and b/media/sound/itempickup.wav differ diff --git a/media/sound/menu_cancel.wav b/media/sound/menu_cancel.wav new file mode 100644 index 0000000..e33dc03 Binary files /dev/null and b/media/sound/menu_cancel.wav differ diff --git a/media/sound/menu_move.wav b/media/sound/menu_move.wav new file mode 100644 index 0000000..6503184 Binary files /dev/null and b/media/sound/menu_move.wav differ diff --git a/media/sound/menu_select.wav b/media/sound/menu_select.wav new file mode 100644 index 0000000..7475499 Binary files /dev/null and b/media/sound/menu_select.wav differ diff --git a/media/sound/player_collision.wav b/media/sound/player_collision.wav new file mode 100644 index 0000000..e3748a6 Binary files /dev/null and b/media/sound/player_collision.wav differ diff --git a/media/sound/stage_change.wav b/media/sound/stage_change.wav new file mode 100644 index 0000000..95834dc Binary files /dev/null and b/media/sound/stage_change.wav differ diff --git a/media/sound/title.wav b/media/sound/title.wav new file mode 100644 index 0000000..3ad8006 Binary files /dev/null and b/media/sound/title.wav differ diff --git a/media/sound/tnt.wav b/media/sound/tnt.wav new file mode 100644 index 0000000..3ad8006 Binary files /dev/null and b/media/sound/tnt.wav differ diff --git a/source/.DS_Store b/source/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/source/.DS_Store differ diff --git a/source/animatedsprite.cpp b/source/animatedsprite.cpp new file mode 100644 index 0000000..f39ea0f --- /dev/null +++ b/source/animatedsprite.cpp @@ -0,0 +1,112 @@ +#include "const.h" +#include "animatedsprite.h" +#include + +// 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 (Uint8 i = 0; i < 20; i++) + { + mAnimation[i].numFrames = 0; + mAnimation[i].speed = 0; + mAnimation[i].loop = true; + for (Uint8 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) +{ + // 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; +} + +// 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..380089c --- /dev/null +++ b/source/animatedsprite.h @@ -0,0 +1,64 @@ +#pragma once +#include "ifdefs.h" +#include "movingsprite.h" + +#ifndef ANIMATEDSPRITE_H +#define ANIMATEDSPRITE_H + +// Clase AnimatedSprite +class AnimatedSprite : public MovingSprite +{ +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); + + // Devuelve el rectangulo de una animación y frame concreto + SDL_Rect getAnimationClip(Uint8 index_animation, Uint8 index_frame); + +private: + struct sAnimation + { + SDL_Rect frames[20]; // Hasta 20 frames + Uint8 numFrames; + Uint8 speed; + bool loop; + }; + + // Vector con las diferentes animaciones y los diferentes frames de cada animación + sAnimation mAnimation[20]; // Hasta 20 animaciones + + // Frame actual + Uint8 mCurrentFrame; + + // Contador para las animaciones + Uint16 mAnimationCounter; +}; + +#endif diff --git a/source/balloon.cpp b/source/balloon.cpp new file mode 100644 index 0000000..e9da6e5 --- /dev/null +++ b/source/balloon.cpp @@ -0,0 +1,644 @@ +#include "const.h" +#include "balloon.h" + +// Constructor +Balloon::Balloon() +{ + mSprite = new AnimatedSprite(); + init(0, 0, NO_KIND, BALLON_VELX_POSITIVE, 0, nullptr, nullptr); +} + +// Destructor +Balloon::~Balloon() +{ + delete mSprite; +} + +// Inicializador +void Balloon::init(float x, int y, Uint8 kind, float velx, Uint16 creationtimer, LTexture *texture, SDL_Renderer *renderer) +{ + const Uint8 NUM_FRAMES_BALLON = 10; + const Uint8 NUM_FRAMES_BALLON_POP = 12; + const Uint8 NUM_FRAMES_BALLON_BORN = 10; + + switch (kind) + { + case BALLOON_1: + // Posición inicial + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 8; + mHeight = mWidth; + + // Inicializa los valores de velocidad y gravedad + mVelX = velx; + mVelY = 0; + mMaxVelY = 3; + mGravity = 0.09f; + mDefaultVelY = 3; + + // Puntos que da el globo al ser destruido + mScore = 50; + + // Amenaza que genera el globo + mMenace = 1; + + // Establece los frames de cada animación + for (Uint8 i = 0; i < NUM_FRAMES_BALLON; i++) + { + mSprite->setAnimationFrames(BALLOON_MOVING_ANIMATION, i, 50, 21 + (37 * i), getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_BORN; i++) + { + mSprite->setAnimationFrames(BALLOON_BORN_ANIMATION, i, 50 + 58, 21 + (37 * i), getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_POP; i++) + { + mSprite->setAnimationFrames(BALLOON_POP_ANIMATION, i, 50 + 58 + 58, 21 + (37 * i), getWidth(), getHeight()); + } + + break; + + case BALLOON_2: + // Posición inicial + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 13; + mHeight = mWidth; + + // Inicializa los valores de velocidad y gravedad + mVelX = velx; + mVelY = 0; + mMaxVelY = 3; + mGravity = 0.10f; + mDefaultVelY = 4; + + // Puntos que da el globo al ser destruido + mScore = 100; + + // Amenaza que genera el globo + mMenace = 2; + + // Establece los frames de cada animación + for (Uint8 i = 0; i < NUM_FRAMES_BALLON; i++) + { + mSprite->setAnimationFrames(BALLOON_MOVING_ANIMATION, i, 37, 21 + (37 * i), getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_BORN; i++) + { + mSprite->setAnimationFrames(BALLOON_BORN_ANIMATION, i, 37 + 58, 21 + (37 * i), getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_POP; i++) + { + mSprite->setAnimationFrames(BALLOON_POP_ANIMATION, i, 37 + 58 + 58, 21 + (37 * i), getWidth(), getHeight()); + } + + break; + + case BALLOON_3: + // Posición inicial + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 21; + mHeight = mWidth; + + // Inicializa los valores de velocidad y gravedad + mVelX = velx; + mVelY = 0; + mMaxVelY = 3; + mGravity = 0.10f; + mDefaultVelY = 4.5; + + // Puntos que da el globo al ser destruido + mScore = 200; + + // Amenaza que genera el globo + mMenace = 4; + + // Establece los frames de cada animación + for (Uint8 i = 0; i < NUM_FRAMES_BALLON; i++) + { + mSprite->setAnimationFrames(BALLOON_MOVING_ANIMATION, i, 37, 37 * i, getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_BORN; i++) + { + mSprite->setAnimationFrames(BALLOON_BORN_ANIMATION, i, 37 + 58, 37 * i, getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_POP; i++) + { + mSprite->setAnimationFrames(BALLOON_POP_ANIMATION, i, 37 + 58 + 58, 37 * i, getWidth(), getHeight()); + } + + break; + + case BALLOON_4: + // Posición inicial + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 37; + mHeight = mWidth; + + // Inicializa los valores de velocidad y gravedad + mVelX = velx; + mVelY = 0; + mMaxVelY = 3; + mGravity = 0.10f; + mDefaultVelY = 5; + + // Puntos que da el globo al ser destruido + mScore = 400; + + // Amenaza que genera el globo + mMenace = 8; + + // Establece los frames de cada animación + for (Uint8 i = 0; i < NUM_FRAMES_BALLON; i++) + { + mSprite->setAnimationFrames(BALLOON_MOVING_ANIMATION, i, 0, 37 * i, getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_BORN; i++) + { + mSprite->setAnimationFrames(BALLOON_BORN_ANIMATION, i, 58, 37 * i, getWidth(), getHeight()); + } + for (Uint8 i = 0; i < NUM_FRAMES_BALLON_POP; i++) + { + mSprite->setAnimationFrames(BALLOON_POP_ANIMATION, i, 58 + 58, 37 * i, getWidth(), getHeight()); + } + + break; + + default: + // Posición inicial + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 0; + mHeight = mWidth; + + // Inicializa los valores de velocidad y gravedad + mVelX = velx; + mVelY = 0; + mMaxVelY = 0; + mGravity = 0; + mDefaultVelY = 0; + + // Puntos que da el globo al ser destruido + mScore = 0; + + // Amenaza que genera el globo + mMenace = 0; + + // Establece los frames de cada animación + mSprite->setAnimationFrames(0, 0, 0, 0, getWidth(), getHeight()); + mSprite->setAnimationFrames(1, 0, 0, 0, getWidth(), getHeight()); + mSprite->setAnimationFrames(2, 0, 0, 0, getWidth(), getHeight()); + + break; + } + + // Textura con los gráficos del sprite + mSprite->setTexture(texture); + + // Renderizador + mSprite->setRenderer(renderer); + + // Alto y ancho del sprite + mSprite->setWidth(mWidth); + mSprite->setHeight(mHeight); + + // Posición X,Y del sprite + mSprite->setPosX(int(mPosX)); + mSprite->setPosY(mPosY); + + // Tamaño del circulo de colisión + mCollider.r = mWidth / 2; + + // Alinea el circulo de colisión con el objeto + shiftColliders(); + + // Inicializa variables + mStopped = true; + mStoppedTimer = 0; + mBlinking = false; + mVisible = true; + mInvulnerable = false; + mBeingCreated = true; + mCreationTimer = creationtimer; + mPopping = false; + + // Tipo + mKind = kind; + + // Inicializa las variables para la animación + mSprite->setCurrentFrame(0); + mSprite->setAnimationCounter(0); + + // Establece el numero de frames de cada animacion + mSprite->setAnimationNumFrames(BALLOON_MOVING_ANIMATION, NUM_FRAMES_BALLON); + mSprite->setAnimationNumFrames(BALLOON_POP_ANIMATION, NUM_FRAMES_BALLON_POP); + mSprite->setAnimationNumFrames(BALLOON_BORN_ANIMATION, NUM_FRAMES_BALLON_BORN); + + // Establece la velocidad de cada animación + mSprite->setAnimationSpeed(BALLOON_MOVING_ANIMATION, 10); + mSprite->setAnimationSpeed(BALLOON_POP_ANIMATION, 5); + mSprite->setAnimationSpeed(BALLOON_BORN_ANIMATION, 20); + + // Establece si la animación se reproduce en bucle + mSprite->setAnimationLoop(BALLOON_MOVING_ANIMATION, true); + mSprite->setAnimationLoop(BALLOON_POP_ANIMATION, false); + mSprite->setAnimationLoop(BALLOON_BORN_ANIMATION, true); + + // Selecciona un frame para pintar + mSprite->setSpriteClip(mSprite->getAnimationClip(0, 0)); +} + +// Centra el globo en la posición X +void Balloon::allignTo(int x) +{ + mPosX = float(x - (mWidth / 2)); + + if (mPosX < PLAY_AREA_LEFT) + { + mPosX = PLAY_AREA_LEFT + 1; + } + else if ((mPosX + mWidth) > PLAY_AREA_RIGHT) + { + mPosX = float(PLAY_AREA_RIGHT - mWidth - 1); + } + + // Posición X,Y del sprite + mSprite->setPosX(getPosX()); + mSprite->setPosY(getPosY()); + + // Alinea el circulo de colisión con el objeto + shiftColliders(); +} + +// Pinta el globo en la pantalla +void Balloon::render() +{ + if (mVisible) + { + mSprite->render(); + } +} + +// Actualiza la posición y estados del globo +void Balloon::move() +{ + // Comprobamos si se puede mover + if (isStopped() == false) + { + // Lo movemos a izquierda o derecha + mPosX += mVelX; + + // Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido + if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT)) + { + // Corregir posición + mPosX -= mVelX; + + // Invertir sentido + mVelX = -mVelX; + } + + // Mueve el globo hacia arriba o hacia abajo + mPosY += int(mVelY); + + // Si se sale por arriba + if (mPosY < PLAY_AREA_TOP) + { + // Corregimos + mPosY -= int(mVelY); + + // Invertimos sentido + mVelY = -mVelY; + } + + // Si el globo se sale por la parte inferior + if (mPosY + mHeight > PLAY_AREA_BOTTOM) + { + // Corregimos + mPosY -= int(mVelY); + + // Invertimos colocando una velocidad por defecto + mVelY = -mDefaultVelY; + } + + // Aplica gravedad al objeto, sin pasarse de un limite establecido + if (int(mVelY) > mMaxVelY) + { + mVelY = float(mMaxVelY); + } + else + { + mVelY += mGravity; + } + + // Actualiza la posición del sprite + mSprite->setPosX(getPosX()); + mSprite->setPosY(mPosY); + } + // Si no se puede mover: + // Comprobar si se está creando + else if (isBeingCreated() == true) + { + // Actualiza el valor de las variables + setStop(true); + setInvulnerable(true); + + // Todavia tiene tiempo en el contador + if (mCreationTimer > 0) + { + // Desplaza lentamente el globo hacia abajo y hacia un lado + if (mCreationTimer % 10 == 0) + { + ++mPosY; + mPosX += mVelX; + + // Actualiza la posición del sprite + mSprite->setPosX(getPosX()); + mSprite->setPosY(mPosY); + + // Actualiza la posición del circulo de colisión + shiftColliders(); + } + + // Hace visible el globo de forma intermitente + if (mCreationTimer > 100) + { + setVisible(mCreationTimer / 10 % 2 == 0); + } + else + { + setVisible(mCreationTimer / 5 % 2 == 0); + } + + --mCreationTimer; + } + // El contador ha llegado a cero + else + { + setBeingCreated(false); + setStop(false); + setVisible(true); + setInvulnerable(false); + } + } + // Comprobar si está detenido + else if (isStopped() == true) + { + // Si todavía está detenido, reduce el contador + if (mStoppedTimer > 0) + { + --mStoppedTimer; + } // Si el contador ha llegado a cero, ya no está detenido + else + { + setStop(false); + } + } +} + +// Pone a cero todos los valores del globo +void Balloon::erase() +{ + init(0, 0, NO_KIND, 0, 0, nullptr, nullptr); +} + +// Explosiona el globo +void Balloon::pop() +{ + setPopping(true); + mSprite->setAnimationCounter(0); + setTimeToLive(120); + setStop(true); + setStoppedTimer(2000); + setInvulnerable(true); + mMenace = 0; +} + +// Actualiza al globo a su posicion, animación y controla los contadores +void Balloon::update() +{ + move(); + setAnimation(); + shiftColliders(); + if (isPopping()) + { + setInvulnerable(true); + setStop(true); + if (mTimeToLive > 0) + { + --mTimeToLive; + } + else + { + erase(); + } + } +} + +// Establece la animación correspondiente al estado +void Balloon::setAnimation() +{ + // Establece el frame de animación + if (isPopping()) + { + mSprite->animate(BALLOON_POP_ANIMATION); + } + else if (isBeingCreated()) + { + mSprite->animate(BALLOON_BORN_ANIMATION); + } + else + { + mSprite->animate(BALLOON_MOVING_ANIMATION); + } +} + +// Comprueba si el globo tiene algun tipo asignado +bool Balloon::isActive() +{ + if (mKind == NO_KIND) + { + return false; + } + else + { + return true; + } +} + +// Obtiene del valor de la variable +int Balloon::getPosX() +{ + return int(mPosX); +} + +// Obtiene del valor de la variable +int Balloon::getPosY() +{ + return mPosY; +} + +// Obtiene del valor de la variable +float Balloon::getVelY() +{ + return mVelY; +} + +// Obtiene del valor de la variable +int Balloon::getWidth() +{ + return mWidth; +} + +// Obtiene del valor de la variable +int Balloon::getHeight() +{ + return mHeight; +} + +// Establece el valor de la variable +void Balloon::setVelY(float velY) +{ + mVelY = velY; +} + +// Obtiene del valor de la variable +int Balloon::getKind() +{ + return mKind; +} + +// Establece el valor de la variable +void Balloon::setStop(bool state) +{ + mStopped = state; +} + +// Obtiene del valor de la variable +bool Balloon::isStopped() +{ + return mStopped; +} + +// Establece el valor de la variable +void Balloon::setBlink(bool state) +{ + mBlinking = state; +} + +// Obtiene del valor de la variable +bool Balloon::isBlinking() +{ + return mBlinking; +} + +// Establece el valor de la variable +void Balloon::setVisible(bool state) +{ + mVisible = state; +} + +// Obtiene del valor de la variable +bool Balloon::isVisible() +{ + return mVisible; +} + +// Establece el valor de la variable +void Balloon::setInvulnerable(bool state) +{ + mInvulnerable = state; +} + +// Obtiene del valor de la variable +bool Balloon::isInvulnerable() +{ + return mInvulnerable; +} + +// Establece el valor de la variable +void Balloon::setBeingCreated(bool state) +{ + mBeingCreated = state; +} + +// Obtiene del valor de la variable +bool Balloon::isBeingCreated() +{ + return mBeingCreated; +} + +// Establece el valor de la variable +void Balloon::setPopping(bool state) +{ + mPopping = state; +} + +// Obtiene del valor de la variable +bool Balloon::isPopping() +{ + return mPopping; +} + +// Establece el valor de la variable +void Balloon::setTimeToLive(Uint16 time) +{ + mTimeToLive = time; +} + +// Obtiene del valor de la variable +Uint16 Balloon::getTimeToLive() +{ + return mTimeToLive; +} + +// Establece el valor de la variable +void Balloon::setStoppedTimer(Uint16 time) +{ + mStoppedTimer = time; +} + +// Obtiene del valor de la variable +Uint16 Balloon::getStoppedTimer() +{ + return mStoppedTimer; +} + +// Obtiene del valor de la variable +Uint16 Balloon::getScore() +{ + return mScore; +} + +// Obtiene el circulo de colisión +Circle &Balloon::getCollider() +{ + return mCollider; +} + +// Alinea el circulo de colisión con la posición del objeto globo +void Balloon::shiftColliders() +{ + // Align collider to center of balloon + mCollider.x = Uint16(mPosX + mCollider.r); + mCollider.y = mPosY + mCollider.r; +} + +// Obtiene le valor de la variable +Uint8 Balloon::getMenace() +{ + return mMenace; +} \ No newline at end of file diff --git a/source/balloon.h b/source/balloon.h new file mode 100644 index 0000000..bd3f8e0 --- /dev/null +++ b/source/balloon.h @@ -0,0 +1,185 @@ +#pragma once +#include "struct.h" +#include "animatedsprite.h" + +#ifndef BALLOON_H +#define BALLOON_H + +// Clase globo +class Balloon +{ +public: + // Constructor + Balloon(); + + // Destructor + ~Balloon(); + + // Inicializador + void init(float x, int y, Uint8 kind, float velx, Uint16 creationtimer, LTexture* texture, SDL_Renderer *renderer); + + // Centra el globo en la posición X + void allignTo(int x); + + // Pinta el globo en la pantalla + void render(); + + // Actualiza la posición y estados del globo + void move(); + + // Pone a cero todos los valores del globo + void erase(); + + // Explosiona el globo + void pop(); + + // Actualiza al globo a su posicion, animación y controla los contadores + void update(); + + // Establece la animación correspondiente + void setAnimation(); + + // Comprueba si el globo tiene algun tipo asignado + bool isActive(); + + // Obtiene del valor de la variable + int getPosX(); + + // Obtiene del valor de la variable + int getPosY(); + + // Obtiene del valor de la variable + float getVelY(); + + // Obtiene del valor de la variable + int getWidth(); + + // Obtiene del valor de la variable + int getHeight(); + + // Establece el valor de la variable + void setVelY(float velY); + + // Obtiene del valor de la variable + int getKind(); + + // Establece el valor de la variable + void setStop(bool state); + + // Obtiene del valor de la variable + bool isStopped(); + + // Establece el valor de la variable + void setBlink(bool state); + + // Obtiene del valor de la variable + bool isBlinking(); + + // Establece el valor de la variable + void setVisible(bool state); + + // Obtiene del valor de la variable + bool isVisible(); + + // Establece el valor de la variable + void setInvulnerable(bool state); + + // Obtiene del valor de la variable + bool isInvulnerable(); + + // Establece el valor de la variable + void setBeingCreated(bool state); + + // Obtiene del valor de la variable + bool isBeingCreated(); + + // Establece el valor de la variable + void setPopping(bool state); + + // Obtiene del valor de la variable + bool isPopping(); + + // Establece el valor de la variable + void setTimeToLive(Uint16 time); + + // Obtiene del valor de la variable + Uint16 getTimeToLive(); + + // Establece el valor de la variable + void setStoppedTimer(Uint16 time); + + // Obtiene del valor de la variable + Uint16 getStoppedTimer(); + + // Obtiene del valor de la variable + Uint16 getScore(); + + // Obtiene el circulo de colisión + Circle &getCollider(); + + // Obtiene le valor de la variable + Uint8 getMenace(); + +private: + // Posición X,Y del objeto globo + float mPosX; + int mPosY; + + // Alto y ancho del objeto globo + Uint8 mWidth; + Uint8 mHeight; + + // Variables para controlar la velocidad del globo + float mVelX; + float mVelY; + float mGravity; + float mDefaultVelY; + int mMaxVelY; + + // Puntos que da el globo al ser destruido + Uint16 mScore; + + // Nivel de amenaza del globo + Uint8 mMenace; + + // Indica si el globo está parado + bool mStopped; + + // Temporizador para controlar el estado "parado" + Uint16 mStoppedTimer; + + // Indica si el globo está intermitente + bool mBlinking; + + // Indica si el globo es visible + bool mVisible; + + // Indica si el globo es invulnerable + bool mInvulnerable; + + // Indica si el globo se está creando + bool mBeingCreated; + + // Indica si el globo está explotando + bool mPopping; + + // Indica el tiempo de vida que le queda al globo + Uint16 mTimeToLive; + + // Temporizador para controlar el estado "creandose" + Uint16 mCreationTimer; + + // Tipo de globo + Uint8 mKind; + + // Sprite del objeto globo + AnimatedSprite *mSprite; + + // Circulo de colisión del objeto + Circle mCollider; + + // Alinea el circulo de colisión con la posición del objeto globo + void shiftColliders(); +}; + +#endif diff --git a/source/bullet.cpp b/source/bullet.cpp new file mode 100644 index 0000000..f6b078d --- /dev/null +++ b/source/bullet.cpp @@ -0,0 +1,213 @@ +#include "const.h" +#include "bullet.h" + +// Constructor +Bullet::Bullet() +{ + mSprite = new Sprite(); + init(0, 0, NO_KIND, nullptr, nullptr); +} + +// Destructor +Bullet::~Bullet() +{ + init(0, 0, NO_KIND, nullptr, nullptr); + delete mSprite; +} + +// Iniciador +void Bullet::init(int x, int y, int kind, LTexture *texture, SDL_Renderer *renderer) +{ + // Posición inicial del objeto + mPosX = x; + mPosY = y; + + // Alto y ancho del objeto + mWidth = 10; + mHeight = mWidth; + + // Velocidad inicial en el eje Y + mVelY = -3; + + // Tipo de bala + mKind = kind; + + // Textura con los gráficos del objeto + mSprite->setTexture(texture); + + // Renderizador + mSprite->setRenderer(renderer); + + // Alto y ancho del sprite + mSprite->setWidth(mWidth); + mSprite->setHeight(mHeight); + + // Posición inicial del sprite + mSprite->setPosX(mPosX); + mSprite->setPosY(mPosY); + + // Valores especificos según el tipo + switch (kind) + { + case BULLET_UP: + // Establece la velocidad inicial + mVelX = 0; + + // Rectangulo con los gráficos del objeto + mSprite->setSpriteClip(0 * mWidth, 0, mSprite->getWidth(), mSprite->getHeight()); + break; + + case BULLET_LEFT: + // Establece la velocidad inicial + mVelX = -2; + + // Rectangulo con los gráficos del objeto + mSprite->setSpriteClip(1 * mWidth, 0, mSprite->getWidth(), mSprite->getHeight()); + break; + + case BULLET_RIGHT: + // Establece la velocidad inicial + mVelX = 2; + + // Rectangulo con los gráficos del objeto + mSprite->setSpriteClip(2 * mWidth, 0, mSprite->getWidth(), mSprite->getHeight()); + break; + + default: + break; + } + + // Establece el tamaño del circulo de colisión + mCollider.r = mWidth / 2; + + // Alinea el circulo de colisión con el objeto + shiftColliders(); +} + +// Pinta el objeto en pantalla +void Bullet::render() +{ + mSprite->render(); +} + +// Actualiza la posición y estado del objeto en horizontal +Uint8 Bullet::move() +{ + // Variable con el valor de retorno + Uint8 msg = MSG_OK; + + // Mueve el objeto a su nueva posición + mPosX += mVelX; + + // Si el objeto se sale del area de juego por los laterales + if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT)) + { + // Se deshabilita + mKind = NO_KIND; + + // Mensaje de salida + msg = MSG_BULLET_OUT; + } + + // Mueve el objeto a su nueva posición en vertical + mPosY += int(mVelY); + + // Si el objeto se sale del area de juego por la parte superior o inferior + if ((mPosY < PLAY_AREA_TOP) || (mPosY + mHeight > PLAY_AREA_BOTTOM)) + { + // Se deshabilita + mKind = NO_KIND; + + // Mensaje de salida + msg = MSG_BULLET_OUT; + } + + // Actualiza la posición del sprite + mSprite->setPosX(mPosX); + mSprite->setPosY(mPosY); + + // Alinea el circulo de colisión con el objeto + shiftColliders(); + + return msg; +} + +#ifdef TEST +void Bullet::testMove() +{ + // Update sprite position + mSprite->setPosX(mPosX); + mSprite->setPosY(mPosY); + + // Update circle colliders + shiftColliders(); +} +#endif + +// Deshabilita el objeto +void Bullet::erase() +{ + init(0, 0, 0, nullptr, nullptr); +} + +// Comprueba si el objeto está activo +bool Bullet::isActive() +{ + if (mKind == NO_KIND) + { + return false; + } + else + { + return true; + } +} + +// Obtiene el valor de la variable +int Bullet::getPosX() +{ + return mPosX; +} + +// Obtiene el valor de la variable +int Bullet::getPosY() +{ + return mPosY; +} + +// Establece el valor de la variable +void Bullet::setPosX(int x) +{ + mPosX = x; +} + +// Establece el valor de la variable +void Bullet::setPosY(int y) +{ + mPosY = y; +} + +// Obtiene el valor de la variable +int Bullet::getVelY() +{ + return mVelY; +} + +// Obtiene el valor de la variable +int Bullet::getKind() +{ + return mKind; +} + +// Obtiene el circulo de colisión +Circle &Bullet::getCollider() +{ + return mCollider; +} + +// Alinea el circulo de colisión con el objeto +void Bullet::shiftColliders() +{ + mCollider.x = mPosX + mCollider.r; + mCollider.y = mPosY + mCollider.r; +} diff --git a/source/bullet.h b/source/bullet.h new file mode 100644 index 0000000..48d744d --- /dev/null +++ b/source/bullet.h @@ -0,0 +1,80 @@ +#pragma once +#include "struct.h" +#include "sprite.h" + +#ifndef BULLET_H +#define BULLET_H + +// Clase bala +class Bullet +{ +public: + // Constructor + Bullet(); + + // Destructor + ~Bullet(); + + // Iniciador + void init(int x, int y, int kind, LTexture* texture, SDL_Renderer *renderer); + + // Pinta el objeto en pantalla + void render(); + + // Actualiza la posición y estado del objeto + Uint8 move(); + + // Deshabilita el objeto + void erase(); + + // Comprueba si el objeto está activo + bool isActive(); + + // Obtiene el valor de la variable + int getPosX(); + + // Obtiene el valor de la variable + int getPosY(); + + // Establece el valor de la variable + void setPosX(int x); + + // Establece el valor de la variable + void setPosY(int y); + + // Obtiene el valor de la variable + int getVelY(); + + // Obtiene el valor de la variable + int getKind(); + + // Obtiene el circulo de colisión + Circle &getCollider(); + +private: + // Posición X/Y del objeto + int mPosX; + int mPosY; + + // Alto y ancho el objeto + Uint8 mWidth; + Uint8 mHeight; + + // Velocidad del objeto + int mVelX; + int mVelY; + + // Tipo de objeto + int mKind; + + // Sprite con los graficos y métodos de pintado + Sprite *mSprite; + + // Balloon's collision circle + Circle mCollider; + + // Alinea el circulo de colisión con el objeto + void shiftColliders(); +}; + +#endif diff --git a/source/const.h b/source/const.h new file mode 100644 index 0000000..c64146a --- /dev/null +++ b/source/const.h @@ -0,0 +1,282 @@ +#pragma once +#include "ifdefs.h" +#include + +#ifndef CONST_H +#define CONST_H + +// Textos +#define WINDOW_CAPTION "Coffee Crisis" +#define TEXT_COPYRIGHT "@2020,2021 JAILDESIGNER (V1.3*)" + +// Recursos +const Uint8 BINFILE_SCORE = 0; +const Uint8 BINFILE_DEMO = 1; +const Uint8 BINFILE_CONFIG = 2; + +const Uint8 TOTAL_BINFILE = 3; + +const Uint8 MUSIC_INTRO = 0; +const Uint8 MUSIC_PLAYING = 1; +const Uint8 MUSIC_TITLE = 2; + +const Uint8 TOTAL_MUSIC = 3; + +const Uint8 SOUND_BALLON = 0; +const Uint8 SOUND_BULLET = 1; +const Uint8 SOUND_MENU_SELECT = 2; +const Uint8 SOUND_MENU_CANCEL = 3; +const Uint8 SOUND_MENU_MOVE = 4; +const Uint8 SOUND_TITLE = 5; +const Uint8 SOUND_PLAYER_COLLISION = 6; +const Uint8 SOUND_HISCORE = 7; +const Uint8 SOUND_ITEM_DROP = 8; +const Uint8 SOUND_ITEM_PICKUP = 9; +const Uint8 SOUND_COFFEE_OUT = 10; +const Uint8 SOUND_STAGE_CHANGE = 11; +const Uint8 SOUND_BUBBLE1 = 12; +const Uint8 SOUND_BUBBLE2 = 13; +const Uint8 SOUND_BUBBLE3 = 14; +const Uint8 SOUND_BUBBLE4 = 15; + +const Uint8 TOTAL_SOUND = 16; + +const Uint8 TEXTURE_BALLOON = 0; +const Uint8 TEXTURE_BULLET = 1; +const Uint8 TEXTURE_FONT_BLACK = 2; +const Uint8 TEXTURE_FONT_NOKIA = 3; +const Uint8 TEXTURE_FONT_WHITE = 4; +const Uint8 TEXTURE_GAME_BG = 5; +const Uint8 TEXTURE_GAME_TEXT = 6; +const Uint8 TEXTURE_INTRO = 7; +const Uint8 TEXTURE_ITEMS = 8; +const Uint8 TEXTURE_LOGO = 9; +const Uint8 TEXTURE_MENU = 10; +const Uint8 TEXTURE_PLAYER_BODY = 11; +const Uint8 TEXTURE_PLAYER_LEGS = 12; +const Uint8 TEXTURE_PLAYER_DEATH = 13; +const Uint8 TEXTURE_TITLE = 14; + +const Uint8 TOTAL_TEXTURE = 15; + +// Tamaño de bloque +const Uint8 BLOCK = 8; +const Uint8 HALF_BLOCK = BLOCK / 2; + +// Tamaño de la pantalla real +const int SCREEN_WIDTH = 256; +const int SCREEN_HEIGHT = SCREEN_WIDTH * 3 / 4; // 192 + +// Tamaño de la pantalla que se muestra +const int VIEW_WIDTH = SCREEN_WIDTH * 3; // 768 +const int VIEW_HEIGHT = SCREEN_HEIGHT * 3; // 576 + +// Cantidad de enteros a escribir en los ficheros de datos +const Uint8 TOTAL_SCORE_DATA = 3; +const Uint16 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_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; + +// Color transparente para los sprites +const Uint8 COLOR_KEY_R = 0xff; +const Uint8 COLOR_KEY_G = 0x00; +const Uint8 COLOR_KEY_B = 0xff; + +// Opciones de menu +const int MENU_NO_OPTION = -1; +const int MENU_OPTION_START = 0; +const int MENU_OPTION_QUIT = 1; +const int MENU_OPTION_TOTAL = 2; + +// Selector de menu +const int MENU_SELECTOR_BLACK = (BLOCK * 0); +const int MENU_SELECTOR_WHITE = (BLOCK * 1); + +// Tipos de fondos para el menu +const int MENU_BACKGROUND_TRANSPARENT = 0; +const int MENU_BACKGROUND_SOLID = 1; + +// Estados del jugador +const Uint8 PLAYER_STATUS_WALKING_LEFT = 0; +const Uint8 PLAYER_STATUS_WALKING_RIGHT = 1; +const Uint8 PLAYER_STATUS_WALKING_STOP = 2; + +const Uint8 PLAYER_STATUS_FIRING_UP = 0; +const Uint8 PLAYER_STATUS_FIRING_LEFT = 1; +const Uint8 PLAYER_STATUS_FIRING_RIGHT = 2; +const Uint8 PLAYER_STATUS_FIRING_NO = 3; + +const Uint8 PLAYER_ANIMATION_LEGS_WALKING_LEFT = 0; +const Uint8 PLAYER_ANIMATION_LEGS_WALKING_RIGHT = 1; +const Uint8 PLAYER_ANIMATION_LEGS_WALKING_STOP = 2; + +const Uint8 PLAYER_ANIMATION_BODY_WALKING_LEFT = 0; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_LEFT = 1; +const Uint8 PLAYER_ANIMATION_BODY_WALKING_RIGHT = 2; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_RIGHT = 3; +const Uint8 PLAYER_ANIMATION_BODY_WALKING_STOP = 4; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_UP = 5; +const Uint8 PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT = 6; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT = 7; +const Uint8 PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT = 8; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT = 9; +const Uint8 PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT = 10; +const Uint8 PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT = 11; + +// Variables del jugador +const Uint16 PLAYER_INVULNERABLE_TIMER = 200; + +// Estados del juego +const Uint8 GAME_STATE_TITLE = 0; +const Uint8 GAME_STATE_PLAYING = 1; +const Uint8 GAME_STATE_QUIT = 2; +const Uint8 GAME_STATE_GAME_OVER_SCREEN = 3; +const Uint8 GAME_STATE_INTRO = 4; +const Uint8 GAME_STATE_DEMO = 5; +const Uint8 GAME_STATE_INSTRUCTIONS = 6; +const Uint8 GAME_STATE_LOGO = 7; +const Uint8 GAME_STATE_INIT = 8; + +// Estados de cada elemento que pertenece a un evento +const Uint8 EVENT_WAITING = 1; +const Uint8 EVENT_RUNNING = 2; +const Uint8 EVENT_COMPLETED = 3; + +// Cantidad de eventos de la intro +const Uint8 INTRO_TOTAL_BITMAPS = 6; +const Uint8 INTRO_TOTAL_TEXTS = 9; +const Uint8 INTRO_TOTAL_EVENTS = INTRO_TOTAL_BITMAPS + INTRO_TOTAL_TEXTS; + +// Cantidad de eventos de la pantalla de titulo +const Uint8 TITLE_TOTAL_EVENTS = 2; + +// Relaciones de Id con nomnbres +const Uint8 BITMAP0 = 0; +const Uint8 BITMAP1 = 1; +const Uint8 BITMAP2 = 2; +const Uint8 BITMAP3 = 3; +const Uint8 BITMAP4 = 4; +const Uint8 BITMAP5 = 5; +const Uint8 TEXT0 = 6; +const Uint8 TEXT1 = 7; +const Uint8 TEXT2 = 8; +const Uint8 TEXT3 = 9; +const Uint8 TEXT4 = 10; +const Uint8 TEXT5 = 11; +const Uint8 TEXT6 = 12; +const Uint8 TEXT7 = 13; +const Uint8 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 +const Uint8 NO_KIND = 0; + +// Tipos de globo +const Uint8 BALLOON_1 = 1; +const Uint8 BALLOON_2 = 2; +const Uint8 BALLOON_3 = 3; +const Uint8 BALLOON_4 = 4; + +// Velocidad del globo +const float BALLON_VELX_POSITIVE = 0.7f; +const float BALLON_VELX_NEGATIVE = -0.7f; + +// Indice para las animaciones de los globos +const Uint8 BALLOON_MOVING_ANIMATION = 0; +const Uint8 BALLOON_POP_ANIMATION = 1; +const Uint8 BALLOON_BORN_ANIMATION = 2; + +// Cantidad posible de globos +const Uint8 MAX_BALLOONS = 75; + +// Tipos de bala +const Uint8 BULLET_UP = 1; +const Uint8 BULLET_LEFT = 2; +const Uint8 BULLET_RIGHT = 3; + +// Cantidad posible de globos +const Uint8 MAX_BULLETS = 50; + +// Tipos de objetos +const Uint8 ITEM_POINTS_1_DISK = 1; +const Uint8 ITEM_POINTS_2_GAVINA = 2; +const Uint8 ITEM_POINTS_3_PACMAR = 3; +const Uint8 ITEM_CLOCK = 4; +const Uint8 ITEM_TNT = 5; +const Uint8 ITEM_COFFEE = 6; + +// Cantidad de objetos simultaneos +const Uint8 MAX_ITEMS = 5; + +// Valores para las variables asociadas a los objetos +const Uint8 REMAINING_EXPLOSIONS = 3; +const Uint8 REMAINING_EXPLOSIONS_TIMER = 50; +const Uint16 TIME_STOPPED_TIMER = 300; + +// Estados de entrada +const Uint8 NO_INPUT = 0; +const Uint8 INPUT_UP = 1; +const Uint8 INPUT_DOWN = 2; +const Uint8 INPUT_LEFT = 3; +const Uint8 INPUT_RIGHT = 4; +const Uint8 INPUT_ACCEPT = 5; +const Uint8 INPUT_CANCEL = 6; +const Uint8 INPUT_FIRE_UP = 7; +const Uint8 INPUT_FIRE_LEFT = 8; +const Uint8 INPUT_FIRE_RIGHT = 9; +const Uint8 INPUT_PAUSE = 10; + +// Zona muerta del mando analógico +const int JOYSTICK_DEAD_ZONE = 8000; + +// Tipos de mensajes para el retorno de las funciones +const Uint8 MSG_OK = 0; +const Uint8 MSG_BULLET_OUT = 1; + +// Tipos de texto +const Uint8 TEXT_FIXED = 0; +const Uint8 TEXT_VARIABLE = 1; + +// Cantidad de elementos del vector de SmartSprites +const Uint8 MAX_SMART_SPRITES = 10; + +// Contadores +const Uint16 TITLE_TIMER = 800; +const Uint8 STAGE_COUNTER = 200; +const Uint16 INSTRUCTIONS_COUNTER = 600; +const Uint16 DEATH_COUNTER = 350; + +#endif \ No newline at end of file diff --git a/source/gamedirector.cpp b/source/gamedirector.cpp new file mode 100644 index 0000000..15c621c --- /dev/null +++ b/source/gamedirector.cpp @@ -0,0 +1,3950 @@ +#include "const.h" +#include "struct.h" +#include "gamedirector.h" +#include + +const Uint8 *keystates; + +// 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 &a, Circle &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; +} + +// Constructor +GameDirector::GameDirector() +{ + // Texturas + mTexture[TEXTURE_BALLOON].texture = new LTexture(); + mTexture[TEXTURE_BULLET].texture = new LTexture(); + mTexture[TEXTURE_FONT_BLACK].texture = new LTexture(); + mTexture[TEXTURE_FONT_NOKIA].texture = new LTexture(); + mTexture[TEXTURE_FONT_WHITE].texture = new LTexture(); + mTexture[TEXTURE_GAME_BG].texture = new LTexture(); + mTexture[TEXTURE_GAME_TEXT].texture = new LTexture(); + mTexture[TEXTURE_INTRO].texture = new LTexture(); + mTexture[TEXTURE_ITEMS].texture = new LTexture(); + mTexture[TEXTURE_LOGO].texture = new LTexture(); + mTexture[TEXTURE_MENU].texture = new LTexture(); + mTexture[TEXTURE_PLAYER_BODY].texture = new LTexture(); + mTexture[TEXTURE_PLAYER_LEGS].texture = new LTexture(); + mTexture[TEXTURE_PLAYER_DEATH].texture = new LTexture(); + mTexture[TEXTURE_TITLE].texture = new LTexture(); + + // Manejador de eventos + mEventHandler = new SDL_Event(); + + // Objetos para el juego + mPlayer = new Player(); + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + mBalloon[i] = new Balloon(); + } + for (Uint8 i = 0; i < MAX_BULLETS; i++) + { + mBullet[i] = new Bullet(); + } + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + mItem[i] = new Item(); + } + for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++) + { + mSmartSprite[i] = new SmartSprite(); + } + mGameBackgroundFront = new Sprite(); + mGameBackgroundSky = new Sprite(); + mGBClouds1 = new MovingSprite(); + mGBClouds1b = new MovingSprite(); + mGBClouds2 = new MovingSprite(); + mGBClouds2b = new MovingSprite(); + mGrass = new Sprite(); + mTitleTile = new Sprite(); + mText.white = new Text(); + mText.black = new Text(); + mText.nokia = new Text(); + mMenu.title = new Menu(); + mMenu.pause = new Menu(); + mMenu.gameOver = new Menu(); + mMenu.options = new Menu(); + mMenu.active = new Menu(); + mGetReadyBitmap = new SmartSprite(); + mCoffeeBitmap = new SmartSprite(); + mCrisisBitmap = new SmartSprite(); + mDustSpriteLeft = new AnimatedSprite(); + mDustSpriteRight = new AnimatedSprite(); + m1000Bitmap = new SmartSprite(); + m2500Bitmap = new SmartSprite(); + m5000Bitmap = new SmartSprite(); + mInstructions = new Sprite(); + for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++) + { + mIntroBitmap[i] = new SmartSprite(); + } + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + mIntroText[i] = new Text2(); + } + mLogo.sprite = new Sprite(); +} + +GameDirector::~GameDirector() +{ + // Libera los recursos globales + unLoadMedia(GAME_STATE_INIT); + + // Libera el mando + if (mGameControllerFound) + { + SDL_JoystickClose(mGameController); + mGameController = NULL; + } + + // Destuye el manejador de eventos + delete mEventHandler; + + // Destruye los objetos + delete mTexture[TEXTURE_BALLOON].texture; + delete mTexture[TEXTURE_BULLET].texture; + delete mTexture[TEXTURE_FONT_BLACK].texture; + delete mTexture[TEXTURE_FONT_NOKIA].texture; + delete mTexture[TEXTURE_FONT_WHITE].texture; + delete mTexture[TEXTURE_GAME_BG].texture; + delete mTexture[TEXTURE_GAME_TEXT].texture; + delete mTexture[TEXTURE_INTRO].texture; + delete mTexture[TEXTURE_ITEMS].texture; + delete mTexture[TEXTURE_LOGO].texture; + delete mTexture[TEXTURE_MENU].texture; + delete mTexture[TEXTURE_PLAYER_BODY].texture; + delete mTexture[TEXTURE_PLAYER_LEGS].texture; + delete mTexture[TEXTURE_PLAYER_DEATH].texture; + delete mTexture[TEXTURE_TITLE].texture; + + delete mPlayer; + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + delete mBalloon[i]; + } + for (Uint8 i = 0; i < MAX_BULLETS; i++) + { + delete mBullet[i]; + } + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + delete mItem[i]; + } + for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++) + { + delete mSmartSprite[i]; + } + delete mGameBackgroundFront; + delete mGameBackgroundSky; + delete mGBClouds1; + delete mGBClouds1b; + delete mGBClouds2; + delete mGBClouds2b; + delete mGrass; + delete mTitleTile; + delete mText.white; + delete mText.black; + delete mText.nokia; + delete mMenu.title; + delete mMenu.pause; + delete mMenu.gameOver; + delete mMenu.options; + mMenu.active = nullptr; + delete mGetReadyBitmap; + delete mCoffeeBitmap; + delete mCrisisBitmap; + delete mDustSpriteLeft; + delete mDustSpriteRight; + delete m1000Bitmap; + delete m2500Bitmap; + delete m5000Bitmap; + delete mInstructions; + for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++) + { + delete mIntroBitmap[i]; + } + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + delete mIntroText[i]; + } + delete mLogo.sprite; + + // Destruye la ventana + SDL_DestroyTexture(mBackbuffer); + SDL_DestroyTexture(mTitleSurface); + SDL_DestroyTexture(mInstructionsSurface); + SDL_DestroyRenderer(mRenderer); + SDL_DestroyWindow(mWindow); + mBackbuffer = nullptr; + mTitleSurface = nullptr; + mInstructionsSurface = nullptr; + mWindow = nullptr; + mRenderer = nullptr; + + // Sal del subsistema SDL + SDL_Quit(); +} + +// Iniciador +void GameDirector::init(bool reset) +{ + if (true) + { + // Variables + mTicks = 0; + mTicksSpeed = 15; + mMenaceLevel = 0; + mMenaceLevelThreshold = 0; + mGame.score = 0; + mGame.hiScoreAchieved = false; + mGame.stage = 1; + mGame.stageCounter = 0; + mGame.paused = false; + mGame.deathCounter = DEATH_COUNTER; + for (Uint8 i = 0; i < STAGE_COUNTER; i++) + { + mGame.stagePath[i] = (sin(double(i * 180.0 / double(STAGE_COUNTER)) * 3.14 / 180.0) * (BLOCK * 4)) - BLOCK; + } + mPlayFieldDrawOnly = true; + mDebug = false; + mTitleStatus = 0; + mTitleTimer = TITLE_TIMER; + mExplosionTime = false; + mRemainingExplosions = REMAINING_EXPLOSIONS; + mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER; + mTimeStopped = false; + mTimeStoppedTimer = TIME_STOPPED_TIMER; + mInstructionsCounter = INSTRUCTIONS_COUNTER; + mDemo = false; + mDemoRecording = false; + mDemoCounter = 0; + mGameCounter = 0; + mMenuKeyPressed = false; + mMenu.active = mMenu.title; + for (int i = 0; i < 360; i++) + { + mSen[i] = sin(i * 3.14 / 180); + } + mTitleBackgroundTimer = 0; + mTitleBackgroundMode = rand() % 2; + mTitleMenuVisible = false; + mLogo.counter = 0; + + // Fondo animado + mGBClouds1->init(0, 0, 256, 52, -0.1f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGBClouds1->setSpriteClip(256, 0, 256, 52); + + mGBClouds1b->init(256, 0, 256, 52, -0.1f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGBClouds1b->setSpriteClip(256, 0, 256, 52); + + mGBClouds2->init(0, 52, 256, 32, -0.05f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGBClouds2->setSpriteClip(256, 52, 256, 32); + + mGBClouds2b->init(256, 52, 256, 32, -0.05f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGBClouds2b->setSpriteClip(256, 52, 256, 32); + + mGrass->init(0, 85, SCREEN_WIDTH, 6, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGrass->setPosY(154); + + // Objeto jugador + mPlayer->init(PLAY_AREA_CENTER_X - 12, PLAY_AREA_BOTTOM - 24, mTexture[TEXTURE_PLAYER_LEGS].texture, mTexture[TEXTURE_PLAYER_BODY].texture, mRenderer); + + // Establece a cero todos los valores del vector de objetos globo + resetBalloons(); + + // Crea objetos globo y los centra en el area de juego + mBalloon[0]->init(0, BLOCK, BALLOON_4, BALLON_VELX_POSITIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer); + mBalloon[0]->allignTo(PLAY_AREA_CENTER_X); + + // Con los globos creados, calcula el nivel de amenaza + calculateMenaceLevel(); + + // 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 sprite del logo + mLogo.sprite->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_LOGO].texture, mRenderer); + + // Inicializa el bitmap de GetReady! + mGetReadyBitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, mRenderer); + mGetReadyBitmap->setPosX(-113); + mGetReadyBitmap->setPosY(PLAY_AREA_CENTER_Y - 10); + mGetReadyBitmap->setWidth(109); + mGetReadyBitmap->setHeight(20); + mGetReadyBitmap->setVelX(2.0f); + mGetReadyBitmap->setVelY(0.0f); + mGetReadyBitmap->setAccelX(0.00f); + mGetReadyBitmap->setAccelY(0.0f); + mGetReadyBitmap->setSpriteClip(0, 0, 109, 20); + mGetReadyBitmap->setEnabled(true); + mGetReadyBitmap->setEnabledTimer(0); + mGetReadyBitmap->setDestX(PLAY_AREA_RIGHT); + mGetReadyBitmap->setDestY(PLAY_AREA_CENTER_Y - 10); + + // Inicializa el bitmap de Coffee + mCoffeeBitmap->init(mTexture[TEXTURE_TITLE].texture, mRenderer); + mCoffeeBitmap->setId(0); + mCoffeeBitmap->setIntroEvents(&mTitleEvents[0]); + mCoffeeBitmap->setPosX(45); + mCoffeeBitmap->setPosY(11 - 200); + mCoffeeBitmap->setWidth(167); + mCoffeeBitmap->setHeight(46); + mCoffeeBitmap->setVelX(0.0f); + mCoffeeBitmap->setVelY(2.5f); + mCoffeeBitmap->setAccelX(0.0f); + mCoffeeBitmap->setAccelY(0.1f); + //mCoffeeBitmap->setSpriteClip(45, 11, 167, 46); + mCoffeeBitmap->setSpriteClip(0, 0, 167, 46); + mCoffeeBitmap->setEnabled(true); + mCoffeeBitmap->setEnabledTimer(0); + mCoffeeBitmap->setDestX(45); + mCoffeeBitmap->setDestY(11); + + // Inicializa el bitmap de Crisis + mCrisisBitmap->init(mTexture[TEXTURE_TITLE].texture, mRenderer); + mCrisisBitmap->setId(1); + mCrisisBitmap->setIntroEvents(&mTitleEvents[0]); + mCrisisBitmap->setPosX(60); + mCrisisBitmap->setPosY(57 + 200); + mCrisisBitmap->setWidth(137); + mCrisisBitmap->setHeight(46); + mCrisisBitmap->setVelX(0.0f); + mCrisisBitmap->setVelY(-2.5f); + mCrisisBitmap->setAccelX(0.0f); + mCrisisBitmap->setAccelY(-0.1f); + //mCrisisBitmap->setSpriteClip(60, 57, 137, 46); + mCrisisBitmap->setSpriteClip(0, 46, 137, 46); + mCrisisBitmap->setEnabled(true); + mCrisisBitmap->setEnabledTimer(0); + mCrisisBitmap->setDestX(60); + mCrisisBitmap->setDestY(57); + + // Inicializa el bitmap de DustRight + mDustSpriteRight->init(mTexture[TEXTURE_TITLE].texture, mRenderer); + mDustSpriteRight->setPosX(218); + mDustSpriteRight->setPosY(47); + mDustSpriteRight->setWidth(16); + mDustSpriteRight->setHeight(14); + mDustSpriteRight->setCurrentFrame(0); + mDustSpriteRight->setAnimationCounter(0); + mDustSpriteRight->setAnimationNumFrames(0, 7); + mDustSpriteRight->setAnimationSpeed(0, 8); + mDustSpriteRight->setAnimationLoop(0, false); + mDustSpriteRight->setAnimationFrames(0, 0, 160 + (mDustSpriteRight->getWidth() * 0), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 1, 160 + (mDustSpriteRight->getWidth() * 1), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 2, 160 + (mDustSpriteRight->getWidth() * 2), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 3, 160 + (mDustSpriteRight->getWidth() * 3), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 4, 160 + (mDustSpriteRight->getWidth() * 4), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 5, 160 + (mDustSpriteRight->getWidth() * 5), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + mDustSpriteRight->setAnimationFrames(0, 6, 160 + (mDustSpriteRight->getWidth() * 6), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight()); + + // Inicializa el bitmap de DustLeft + mDustSpriteLeft->init(mTexture[TEXTURE_TITLE].texture, mRenderer); + mDustSpriteLeft->setPosX(33); + mDustSpriteLeft->setPosY(47); + mDustSpriteLeft->setWidth(16); + mDustSpriteLeft->setHeight(14); + mDustSpriteLeft->setCurrentFrame(0); + mDustSpriteLeft->setAnimationCounter(0); + mDustSpriteLeft->setAnimationNumFrames(0, 7); + mDustSpriteLeft->setAnimationSpeed(0, 8); + mDustSpriteLeft->setAnimationLoop(0, false); + mDustSpriteLeft->setAnimationFrames(0, 0, 160 + (mDustSpriteLeft->getWidth() * 0), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 1, 160 + (mDustSpriteLeft->getWidth() * 1), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 2, 160 + (mDustSpriteLeft->getWidth() * 2), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 3, 160 + (mDustSpriteLeft->getWidth() * 3), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 4, 160 + (mDustSpriteLeft->getWidth() * 4), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 5, 160 + (mDustSpriteLeft->getWidth() * 5), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + mDustSpriteLeft->setAnimationFrames(0, 6, 160 + (mDustSpriteLeft->getWidth() * 6), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight()); + + // Inicializa el bitmap de 1000 puntos + m1000Bitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, 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(mTexture[TEXTURE_GAME_TEXT].texture, 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(mTexture[TEXTURE_GAME_TEXT].texture, 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); + + // Inicializa el vector de eventos de la intro + for (Uint8 i = 0; i < INTRO_TOTAL_EVENTS; i++) + { + mIntroEvents[i] = EVENT_WAITING; + } + + // Inicializa el vector de eventos de la pantalla de titulo + for (Uint8 i = 0; i < TITLE_TOTAL_EVENTS; i++) + { + mTitleEvents[i] = EVENT_WAITING; + } + + // Inicializa los bitmaps de la intro + for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++) + { + mIntroBitmap[i]->init(mTexture[TEXTURE_INTRO].texture, mRenderer); + mIntroBitmap[i]->setId(i); + mIntroBitmap[i]->setIntroEvents(&mIntroEvents[0]); + mIntroBitmap[i]->setWidth(128); + mIntroBitmap[i]->setHeight(96); + mIntroBitmap[i]->setEnabled(false); + mIntroBitmap[i]->setEnabledTimer(20); + mIntroBitmap[i]->setDestX(SCREEN_CENTER_X - 64); + mIntroBitmap[i]->setDestY(SCREEN_FIRST_QUARTER_Y - 24); + } + + mIntroBitmap[0]->setPosX(-128); + mIntroBitmap[0]->setPosY(SCREEN_FIRST_QUARTER_Y - 24); + mIntroBitmap[0]->setVelX(0.0f); + mIntroBitmap[0]->setVelY(0.0f); + mIntroBitmap[0]->setAccelX(0.6f); + mIntroBitmap[0]->setAccelY(0.0f); + mIntroBitmap[0]->setSpriteClip(0, 0, 128, 96); + + mIntroBitmap[1]->setPosX(SCREEN_WIDTH); + mIntroBitmap[1]->setPosY(SCREEN_FIRST_QUARTER_Y - 24); + mIntroBitmap[1]->setVelX(-1.0f); + mIntroBitmap[1]->setVelY(0.0f); + mIntroBitmap[1]->setAccelX(-0.3f); + mIntroBitmap[1]->setAccelY(0.0f); + mIntroBitmap[1]->setSpriteClip(128, 0, 128, 96); + + mIntroBitmap[2]->setPosX(SCREEN_CENTER_X - 64); + mIntroBitmap[2]->setPosY(-96); + mIntroBitmap[2]->setVelX(0.0f); + mIntroBitmap[2]->setVelY(3.0f); + mIntroBitmap[2]->setAccelX(0.1f); + mIntroBitmap[2]->setAccelY(0.3f); + mIntroBitmap[2]->setSpriteClip(0, 96, 128, 96); + + mIntroBitmap[2]->setEnabledTimer(250); + + mIntroBitmap[3]->setPosX(SCREEN_CENTER_X - 64); + mIntroBitmap[3]->setPosY(SCREEN_HEIGHT); + mIntroBitmap[3]->setVelX(0.0f); + mIntroBitmap[3]->setVelY(-0.7f); + mIntroBitmap[3]->setAccelX(0.0f); + mIntroBitmap[3]->setAccelY(0.0f); + mIntroBitmap[3]->setSpriteClip(128, 96, 128, 96); + + mIntroBitmap[4]->setPosX(SCREEN_CENTER_X - 64); + mIntroBitmap[4]->setPosY(-96); + mIntroBitmap[4]->setVelX(0.0f); + mIntroBitmap[4]->setVelY(3.0f); + mIntroBitmap[4]->setAccelX(0.1f); + mIntroBitmap[4]->setAccelY(0.3f); + mIntroBitmap[4]->setSpriteClip(0, 192, 128, 96); + + mIntroBitmap[5]->setPosX(SCREEN_WIDTH); + mIntroBitmap[5]->setPosY(SCREEN_FIRST_QUARTER_Y - 24); + mIntroBitmap[5]->setVelX(-0.7f); + mIntroBitmap[5]->setVelY(0.0f); + mIntroBitmap[5]->setAccelX(0.0f); + mIntroBitmap[5]->setAccelY(0.0f); + mIntroBitmap[5]->setSpriteClip(128, 192, 128, 96); + + // Inicializa los textos de la intro + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + mIntroText[i]->init(mTexture[TEXTURE_FONT_NOKIA].texture, mRenderer, TEXT_VARIABLE, 10); + mIntroText[i]->setId(6 + i); + mIntroText[i]->setIntroEvents(&mIntroEvents[0]); + mIntroText[i]->setPosX(BLOCK * 0); + mIntroText[i]->setPosY(SCREEN_HEIGHT - (BLOCK * 6)); + mIntroText[i]->setKerning(-1); + mIntroText[i]->setEnabled(false); + mIntroText[i]->setEnabledTimer(180); + } + + mIntroText[0]->setCaption("Un dia qualsevol de l'any 2000"); + mIntroText[0]->setWrittingSpeed(10); + + mIntroText[1]->setCaption("Tot esta tranquil a la UPV"); + mIntroText[1]->setWrittingSpeed(10); + + mIntroText[2]->setCaption("Fins que un desaprensiu..."); + mIntroText[2]->setWrittingSpeed(15); + + mIntroText[3]->setCaption("HEY! ME ANE A FERME UN CORTAET..."); + mIntroText[3]->setWrittingSpeed(10); + + mIntroText[4]->setCaption("UAAAAAAAAAAAAA!!!"); + mIntroText[4]->setWrittingSpeed(1); + + mIntroText[5]->setCaption("Espera un moment..."); + mIntroText[5]->setWrittingSpeed(20); + + mIntroText[6]->setCaption("Si resulta que no tinc solt!"); + mIntroText[6]->setWrittingSpeed(2); + + mIntroText[7]->setCaption("MERDA DE MAQUINA!"); + mIntroText[7]->setWrittingSpeed(3); + + mIntroText[8]->setCaption("Blop... blop... blop..."); + mIntroText[8]->setWrittingSpeed(20); + + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + mIntroText[i]->center(SCREEN_CENTER_X); + } + } + + // Esta parte solo se ejecuta al arrancar la aplicación + if (reset == false) + { + // Variables + mGame.status = GAME_STATE_LOGO; + mTitleStatus = 0; + mTiteNextGS = GAME_STATE_PLAYING; + + // Teclado + mKeyboard.up = SDL_SCANCODE_UP; + mKeyboard.down = SDL_SCANCODE_DOWN; + mKeyboard.left = SDL_SCANCODE_LEFT; + mKeyboard.right = SDL_SCANCODE_RIGHT; + mKeyboard.accept = SDL_SCANCODE_RETURN; + mKeyboard.cancel = SDL_SCANCODE_ESCAPE; + mKeyboard.fire = SDL_SCANCODE_W; + mKeyboard.fireLeft = SDL_SCANCODE_Q; + mKeyboard.fireRight = SDL_SCANCODE_E; + mKeyboard.pause = SDL_SCANCODE_ESCAPE; + mKeyboard.escape = SDL_SCANCODE_ESCAPE; + + // Buffer de teclado + mKeyboardBuffer.up = 0; + mKeyboardBuffer.down = 0; + mKeyboardBuffer.left = 0; + mKeyboardBuffer.right = 0; + mKeyboardBuffer.accept = 0; + mKeyboardBuffer.cancel = 0; + mKeyboardBuffer.fire = 0; + mKeyboardBuffer.fireLeft = 0; + mKeyboardBuffer.fireRight = 0; + mKeyboardBuffer.pause = 0; + mKeyboardBuffer.escape = 0; + + // Carga la máxima puntuación a partir del fichero de datos + if (mScoreDataFile[0] == 0) + { + mGame.hiScore = 10000; + } + // Comprueba el checksum para ver si se ha modificado el fichero + else if (mScoreDataFile[0] % 43 == mScoreDataFile[1]) + { + mGame.hiScore = mScoreDataFile[0]; + } + else + { + mGame.hiScore = 10000; + } + + // Los fondos + mGameBackgroundFront->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + mGameBackgroundSky->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_GAME_BG].texture, mRenderer); + + // El tile de fondo + mTitleTile->init(0, 0, 64, 64, mTexture[TEXTURE_TITLE].texture, mRenderer); + mTitleTile->setSpriteClip(192, 0, 64, 64); + + // Las instrucciones + //mInstructions->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture.instructions, mRenderer); + + // Objetos texto, uno de cada color + mText.white->init(mTexture[TEXTURE_FONT_WHITE].texture, mRenderer, TEXT_FIXED, BLOCK); + mText.black->init(mTexture[TEXTURE_FONT_BLACK].texture, mRenderer, TEXT_FIXED, BLOCK); + mText.nokia->init(mTexture[TEXTURE_FONT_NOKIA].texture, mRenderer, TEXT_VARIABLE, 10); + + // Inicializa el objeto con el menu del titulo + mMenu.title->init("TITLE", 0, 15 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white); + mMenu.title->addItem("PLAY"); + mMenu.title->addItem("OPTIONS", 0, 5); + mMenu.title->addItem("QUIT"); + mMenu.title->setDefaultActionWhenCancel(2); + mMenu.title->setBackgroundColor(0x30, 0x30, 0x40, 192); + mMenu.title->setSelectorColor(0xe5, 0x1c, 0x23, 255); + mMenu.title->setSelectorTextColor(0xFF, 0xF1, 0x76); + mMenu.title->centerMenu(SCREEN_CENTER_X); + mMenu.title->centerMenuElements(); + + // Inicializa el objeto con el menu de pausa + mMenu.pause->init("PAUSE", 0, 12 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white); + mMenu.pause->addItem("CONTINUE"); + mMenu.pause->addItem("EXIT TO TITLE"); + mMenu.pause->setDefaultActionWhenCancel(0); + mMenu.pause->setBackgroundColor(0x29, 0x39, 0x41, 240); + mMenu.pause->setSelectorColor(0xFF, 0x7A, 0x00, 255); + mMenu.pause->setSelectorTextColor(0xFF, 0xFF, 0xFF); + mMenu.pause->centerMenu(SCREEN_CENTER_X); + mMenu.pause->centerMenuElements(); + + // Inicializa el objeto con el menu de la pantalla de game over + mMenu.gameOver->init("GAME OVER", 0, PLAY_AREA_CENTER_Y + BLOCK * 4, MENU_BACKGROUND_TRANSPARENT, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white); + mMenu.gameOver->addItem("YES"); + mMenu.gameOver->addItem("NO"); + mMenu.gameOver->setDefaultActionWhenCancel(1); + mMenu.gameOver->setBackgroundColor(0, 0, 0, 255); + mMenu.gameOver->setSelectorColor(0x54, 0x6e, 0x7a, 255); + mMenu.gameOver->setSelectorColor(0x54, 0x6e, 0x7a, 0); + mMenu.gameOver->setSelectorTextColor(0xFF, 0xFF, 0xFF); + mMenu.gameOver->setSelectorTextColor(0xFF, 0xF1, 0x76); + mMenu.gameOver->centerMenu(SCREEN_CENTER_X); + mMenu.gameOver->centerMenuElements(); + + // Inicializa el objeto con el menu de las opciones + mMenu.options->init("OPTIONS", 0, 15 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white); + mMenu.options->addItem("FULLSCREEN"); + mMenu.options->addItem("WINDOWS SIZE", 0, 5); + mMenu.options->addItem("[OK]"); + mMenu.options->addItem("[CANCEL]"); + mMenu.options->setDefaultActionWhenCancel(3); + mMenu.options->setBackgroundColor(0x30, 0x30, 0x40, 192); + mMenu.options->setSelectorColor(0xe5, 0x1c, 0x23, 255); + mMenu.options->setSelectorTextColor(0xFF, 0xF1, 0x76); + mMenu.options->centerMenu(SCREEN_CENTER_X); + mMenu.options->centerMenuElements(); + + // Actualiza los elementos del menu de opciones con los valores correspondientes + updateOptionsMenu(); + } +} + +// Arranca SDL y crea la ventana +bool GameDirector::initSDL() +{ + // Indicador de inicialización + bool success = true; + + // Inicializa SDL + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO | SDL_INIT_HAPTIC) < 0) + { + printf("SDL could not initialize!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + else + { + // Establece el filtro de la textura a nearest + if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0")) + { + printf("Warning: Nearest texture filtering not enabled!\n"); + } + + // Inicializa jail_audio + JA_Init(48000, AUDIO_S16, 2); + + // Comprueba si hay algun mando conectado + if (SDL_NumJoysticks() < 1) + { + printf("Warning: No joysticks connected!\n"); + mGameControllerFound = false; + } + else + { + // Carga el mando + mGameController = SDL_JoystickOpen(0); + mGameControllerFound = true; + + if (mGameController == NULL) + { + printf("Warning: Unable to open game controller!\nSDL Error: %s\n", SDL_GetError()); + mGameControllerFound = false; + } + else + { + printf("%i joysticks were found.\n", SDL_NumJoysticks()); + std::cout << SDL_JoystickNumButtons(mGameController) << " buttons\n"; + + //Get controller haptic device + mControllerHaptic = SDL_HapticOpenFromJoystick(mGameController); + if (mControllerHaptic == NULL) + { + printf("Warning: Controller does not support haptics!\nSDL Error: %s\n", SDL_GetError()); + } + else + { + printf("Haptics detected\n"); + + //Get initialize rumble + if (SDL_HapticRumbleInit(mControllerHaptic) < 0) + { + printf("Warning: Unable to initialize rumble!\nSDL Error: %s\n", SDL_GetError()); + } + } + } + } + + // 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 con vsync + mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); + 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); + } + + // Crea un backbuffer para el renderizador + 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()); + success = false; + } + + // Crea una textura para dibujar el fondo del titulo + mTitleSurface = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH * 2, SCREEN_HEIGHT * 2); + if (mTitleSurface == NULL) + { + printf("TitleSurface could not be created!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + + // Crea una textura para dibujar las instrucciones + mInstructionsSurface = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT); + if (mInstructionsSurface == NULL) + { + printf("InstructionsSurface could not be created!\nSDL Error: %s\n", SDL_GetError()); + success = false; + } + } + } + + printf("\n"); + return success; +} + +// Crea el indice de ficheros +void GameDirector::setFileList() +{ + // Ficheros binarios + mBinFile[BINFILE_SCORE].file = mExecutablePath + "/" + "../data/score.bin"; + mBinFile[BINFILE_DEMO].file = mExecutablePath + "/" + "../data/demo.bin"; + mBinFile[BINFILE_CONFIG].file = mExecutablePath + "/" + "../data/config.bin"; + + // Musicas + mMusic[MUSIC_INTRO].file = mExecutablePath + "/" + "../media/music/intro.ogg"; + mMusic[MUSIC_PLAYING].file = mExecutablePath + "/" + "../media/music/playing.ogg"; + mMusic[MUSIC_TITLE].file = mExecutablePath + "/" + "../media/music/title.ogg"; + + // Sonidos + mSound[SOUND_BALLON].file = mExecutablePath + "/" + "../media/sound/balloon.wav"; + mSound[SOUND_BULLET].file = mExecutablePath + "/" + "../media/sound/bullet.wav"; + mSound[SOUND_MENU_SELECT].file = mExecutablePath + "/" + "../media/sound/menu_select.wav"; + mSound[SOUND_MENU_CANCEL].file = mExecutablePath + "/" + "../media/sound/menu_cancel.wav"; + mSound[SOUND_MENU_MOVE].file = mExecutablePath + "/" + "../media/sound/menu_move.wav"; + mSound[SOUND_TITLE].file = mExecutablePath + "/" + "../media/sound/title.wav"; + mSound[SOUND_PLAYER_COLLISION].file = mExecutablePath + "/" + "../media/sound/player_collision.wav"; + mSound[SOUND_HISCORE].file = mExecutablePath + "/" + "../media/sound/hiscore.wav"; + mSound[SOUND_ITEM_DROP].file = mExecutablePath + "/" + "../media/sound/itemdrop.wav"; + mSound[SOUND_ITEM_PICKUP].file = mExecutablePath + "/" + "../media/sound/itempickup.wav"; + mSound[SOUND_COFFEE_OUT].file = mExecutablePath + "/" + "../media/sound/coffeeout.wav"; + mSound[SOUND_STAGE_CHANGE].file = mExecutablePath + "/" + "../media/sound/stage_change.wav"; + mSound[SOUND_BUBBLE1].file = mExecutablePath + "/" + "../media/sound/bubble1.wav"; + mSound[SOUND_BUBBLE2].file = mExecutablePath + "/" + "../media/sound/bubble2.wav"; + mSound[SOUND_BUBBLE3].file = mExecutablePath + "/" + "../media/sound/bubble3.wav"; + mSound[SOUND_BUBBLE4].file = mExecutablePath + "/" + "../media/sound/bubble4.wav"; + + // Texturas + mTexture[TEXTURE_BALLOON].file = mExecutablePath + "/" + "../media/gfx/balloon.png"; + mTexture[TEXTURE_BULLET].file = mExecutablePath + "/" + "../media/gfx/bullet.png"; + mTexture[TEXTURE_FONT_BLACK].file = mExecutablePath + "/" + "../media/gfx/font_black.png"; + mTexture[TEXTURE_FONT_NOKIA].file = mExecutablePath + "/" + "../media/gfx/font_nokia.png"; + mTexture[TEXTURE_FONT_WHITE].file = mExecutablePath + "/" + "../media/gfx/font_white.png"; + mTexture[TEXTURE_GAME_BG].file = mExecutablePath + "/" + "../media/gfx/game_bg.png"; + mTexture[TEXTURE_GAME_TEXT].file = mExecutablePath + "/" + "../media/gfx/game_text.png"; + mTexture[TEXTURE_INTRO].file = mExecutablePath + "/" + "../media/gfx/intro.png"; + mTexture[TEXTURE_ITEMS].file = mExecutablePath + "/" + "../media/gfx/items.png"; + mTexture[TEXTURE_LOGO].file = mExecutablePath + "/" + "../media/gfx/logo.png"; + mTexture[TEXTURE_MENU].file = mExecutablePath + "/" + "../media/gfx/menu.png"; + mTexture[TEXTURE_PLAYER_LEGS].file = mExecutablePath + "/" + "../media/gfx/player_legs.png"; + mTexture[TEXTURE_PLAYER_BODY].file = mExecutablePath + "/" + "../media/gfx/player_body.png"; + mTexture[TEXTURE_PLAYER_DEATH].file = mExecutablePath + "/" + "../media/gfx/player_death.png"; + mTexture[TEXTURE_TITLE].file = mExecutablePath + "/" + "../media/gfx/title.png"; +} + +// Comprueba que todos los ficheros existen +bool GameDirector::checkFileList() +{ + bool success = true; + std::string p; + std::string filename; + SDL_RWops *file; + + // Comprueba los ficheros de musica + printf("\n>> MUSIC FILES\n"); + for (Uint8 i = 0; i < TOTAL_MUSIC; i++) + { + p = mMusic[i].file.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 + { + success = false; + printf("Checking file %-20s [ERROR]\n", filename.c_str()); + } + SDL_RWclose(file); + } + + // Comprueba los ficheros de sonidos + printf("\n>> SOUND FILES\n"); + for (Uint8 i = 0; i < TOTAL_SOUND; i++) + { + p = mSound[i].file.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 + { + success = false; + printf("Checking file %-20s [ERROR]\n", filename.c_str()); + } + SDL_RWclose(file); + } + + // Comprueba los ficheros con texturas + printf("\n>> TEXTURE FILES\n"); + for (Uint8 i = 0; i < TOTAL_TEXTURE; i++) + { + p = mTexture[i].file.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 + { + success = false; + printf("Checking file %-20s [ERROR]\n", filename.c_str()); + } + SDL_RWclose(file); + } + + // Resultado + if (success) + { + printf("\n** All files OK.\n\n"); + } + else + { + printf("\n** File is missing. Exiting.\n\n"); + } + return success; +} + +// Carga un archivo de imagen en una textura +bool GameDirector::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; +} + +// Carga los recursos necesarios +bool GameDirector::loadMedia(Uint8 section) +{ + // Indicador de éxito en la carga + bool success = true; + std::string path = mExecutablePath + "/"; + std::string p; + + switch (section) + { + case GAME_STATE_INIT: + { + p = mBinFile[BINFILE_SCORE].file.c_str(); + std::string filename = p.substr(p.find_last_of("\\/") + 1); + // Abrimos el fichero con la puntuacion para leer en binario + 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); + } + + p = mBinFile[BINFILE_DEMO].file.c_str(); + filename = p.substr(p.find_last_of("\\/") + 1); + // Abrimos el fichero con los datos para el modo demo para leer en binario + 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) + { + mDemoKeys.left = 0; + mDemoKeys.right = 0; + mDemoKeys.noInput = 0; + mDemoKeys.fire = 0; + mDemoKeys.fireLeft = 0; + mDemoKeys.fireRight = 0; + mDemoDataFile[i] = mDemoKeys; + SDL_RWwrite(file, &mDemoDataFile[i], sizeof(DemoKeys), 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, &mDemoDataFile[i], sizeof(DemoKeys), 1); + } + + // Cierra el fichero + SDL_RWclose(file); + } + + p = mBinFile[BINFILE_CONFIG].file.c_str(); + filename = p.substr(p.find_last_of("\\/") + 1); + // Abrimos el fichero con la configuracion de las opciones leer en binario + 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 + mFullScreenMode = 0; + SDL_RWwrite(file, &mFullScreenMode, sizeof(mFullScreenMode), 1); + + mWindowSize = 3; + SDL_RWwrite(file, &mWindowSize, sizeof(mWindowSize), 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()); + SDL_RWread(file, &mFullScreenMode, sizeof(mFullScreenMode), 1); + SDL_SetWindowFullscreen(mWindow, mFullScreenMode); + SDL_RWread(file, &mWindowSize, sizeof(mWindowSize), 1); + SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mWindowSize, SCREEN_HEIGHT * mWindowSize); + + // Cierra el fichero + SDL_RWclose(file); + } + printf("\n"); + + // Texturas + loadTextureFromFile(mTexture[TEXTURE_MENU].texture, mTexture[TEXTURE_MENU].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_FONT_WHITE].texture, mTexture[TEXTURE_FONT_WHITE].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_FONT_BLACK].texture, mTexture[TEXTURE_FONT_BLACK].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_FONT_NOKIA].texture, mTexture[TEXTURE_FONT_NOKIA].file, mRenderer); + + // Sonidos + mSound[SOUND_MENU_SELECT].sound = JA_LoadSound(mSound[SOUND_MENU_SELECT].file.c_str()); + mSound[SOUND_MENU_CANCEL].sound = JA_LoadSound(mSound[SOUND_MENU_CANCEL].file.c_str()); + mSound[SOUND_MENU_MOVE].sound = JA_LoadSound(mSound[SOUND_MENU_MOVE].file.c_str()); + + // Musicas + mMusic[MUSIC_TITLE].music = JA_LoadMusic(mMusic[MUSIC_TITLE].file.c_str()); + } + break; + + case GAME_STATE_TITLE: + { + // Texturas + loadTextureFromFile(mTexture[TEXTURE_TITLE].texture, mTexture[TEXTURE_TITLE].file, mRenderer); + + // Crea el mosaico de fondo del titulo + SDL_SetRenderTarget(mRenderer, mTitleSurface); + SDL_SetRenderDrawColor(mRenderer, 0x43, 0x43, 0x4F, 0xFF); + SDL_RenderClear(mRenderer); + for (Uint8 i = 0; i < 8; i++) + for (Uint8 j = 0; j < 6; j++) + { + mTitleTile->setPosX(i * 64); + mTitleTile->setPosY(j * 64); + mTitleTile->render(); + } + mBackgroundWindow.x = 0; + mBackgroundWindow.y = 0; + mBackgroundWindow.w = SCREEN_WIDTH; + mBackgroundWindow.h = SCREEN_HEIGHT; + SDL_SetRenderTarget(mRenderer, nullptr); + + // Sonidos + mSound[SOUND_TITLE].sound = JA_LoadSound(mSound[SOUND_TITLE].file.c_str()); + } + break; + + case GAME_STATE_PLAYING: + { + // Texturas + loadTextureFromFile(mTexture[TEXTURE_PLAYER_LEGS].texture, mTexture[TEXTURE_PLAYER_LEGS].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_PLAYER_BODY].texture, mTexture[TEXTURE_PLAYER_BODY].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_PLAYER_DEATH].texture, mTexture[TEXTURE_PLAYER_DEATH].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_BALLOON].texture, mTexture[TEXTURE_BALLOON].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_BULLET].texture, mTexture[TEXTURE_BULLET].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_GAME_BG].texture, mTexture[TEXTURE_GAME_BG].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_GAME_TEXT].texture, mTexture[TEXTURE_GAME_TEXT].file, mRenderer); + loadTextureFromFile(mTexture[TEXTURE_ITEMS].texture, mTexture[TEXTURE_ITEMS].file, mRenderer); + + // Sonidos + mSound[SOUND_BALLON].sound = JA_LoadSound(mSound[SOUND_BALLON].file.c_str()); + mSound[SOUND_BULLET].sound = JA_LoadSound(mSound[SOUND_BULLET].file.c_str()); + mSound[SOUND_PLAYER_COLLISION].sound = JA_LoadSound(mSound[SOUND_PLAYER_COLLISION].file.c_str()); + mSound[SOUND_HISCORE].sound = JA_LoadSound(mSound[SOUND_HISCORE].file.c_str()); + mSound[SOUND_ITEM_DROP].sound = JA_LoadSound(mSound[SOUND_ITEM_DROP].file.c_str()); + mSound[SOUND_ITEM_PICKUP].sound = JA_LoadSound(mSound[SOUND_ITEM_PICKUP].file.c_str()); + mSound[SOUND_COFFEE_OUT].sound = JA_LoadSound(mSound[SOUND_COFFEE_OUT].file.c_str()); + mSound[SOUND_STAGE_CHANGE].sound = JA_LoadSound(mSound[SOUND_STAGE_CHANGE].file.c_str()); + mSound[SOUND_TITLE].sound = JA_LoadSound(mSound[SOUND_TITLE].file.c_str()); + mSound[SOUND_BUBBLE1].sound = JA_LoadSound(mSound[SOUND_BUBBLE1].file.c_str()); + mSound[SOUND_BUBBLE2].sound = JA_LoadSound(mSound[SOUND_BUBBLE2].file.c_str()); + mSound[SOUND_BUBBLE3].sound = JA_LoadSound(mSound[SOUND_BUBBLE3].file.c_str()); + mSound[SOUND_BUBBLE4].sound = JA_LoadSound(mSound[SOUND_BUBBLE4].file.c_str()); + + // Musicas + mMusic[MUSIC_PLAYING].music = JA_LoadMusic(mMusic[MUSIC_PLAYING].file.c_str()); + } + break; + + case GAME_STATE_GAME_OVER_SCREEN: + { + } + break; + + case GAME_STATE_INTRO: + { + // Texturas + loadTextureFromFile(mTexture[TEXTURE_INTRO].texture, mTexture[TEXTURE_INTRO].file, mRenderer); + + // Musicas + mMusic[MUSIC_INTRO].music = JA_LoadMusic(mMusic[MUSIC_INTRO].file.c_str()); + } + break; + + case GAME_STATE_DEMO: + { + } + break; + + case GAME_STATE_INSTRUCTIONS: + { + // Texturas + loadTextureFromFile(mTexture[TEXTURE_ITEMS].texture, mTexture[TEXTURE_ITEMS].file, mRenderer); + } + break; + + case GAME_STATE_LOGO: + { + // Texturas + loadTextureFromFile(mTexture[TEXTURE_LOGO].texture, mTexture[TEXTURE_LOGO].file, mRenderer); + } + break; + + default: + { + } + break; + } + + return success; +} + +// Descrga los recursos necesarios +bool GameDirector::unLoadMedia(Uint8 section) +{ + // Indicador de éxito en la carga + bool success = true; + std::string path = mExecutablePath + "/"; + std::string p; + + switch (section) + { + case GAME_STATE_INIT: + { + p = mBinFile[BINFILE_SCORE].file; + std::string filename = p.substr(p.find_last_of("\\/") + 1); + // Abre el fichero de puntuación para escribir + 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()); + } + + p = mBinFile[BINFILE_CONFIG].file; + filename = p.substr(p.find_last_of("\\/") + 1); + // Abre el fichero de puntuación para escribir + SDL_RWops *file2 = SDL_RWFromFile(p.c_str(), "w+b"); + if (file != NULL) + { + // Guardamos los datos + SDL_RWwrite(file2, &mFullScreenMode, sizeof(Uint32), 1); + SDL_RWwrite(file2, &mWindowSize, sizeof(Uint8), 1); + + printf("Writing file %s\n", filename.c_str()); + + // Cerramos el fichero + SDL_RWclose(file2); + } + else + { + printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError()); + } + + p = mBinFile[BINFILE_DEMO].file; + filename = p.substr(p.find_last_of("\\/") + 1); + // Abre el fichero de demo para escribir + if (mDemoRecording) + { + SDL_RWops *file2 = SDL_RWFromFile(p.c_str(), "w+b"); + if (file2 != NULL) + { + // Guardamos los datos + for (int i = 0; i < TOTAL_DEMO_DATA; ++i) + { + SDL_RWwrite(file2, &mDemoDataFile[i], sizeof(DemoKeys), 1); + } + + printf("Writing file %s\n", filename.c_str()); + + // Cerramos el fichero + SDL_RWclose(file2); + } + else + { + printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError()); + } + } + printf("\n"); + + // Texturas + mTexture[TEXTURE_MENU].texture->free(); + mTexture[TEXTURE_FONT_WHITE].texture->free(); + mTexture[TEXTURE_FONT_BLACK].texture->free(); + mTexture[TEXTURE_FONT_NOKIA].texture->free(); + + // Sonidos + JA_DeleteSound(mSound[SOUND_MENU_SELECT].sound); + JA_DeleteSound(mSound[SOUND_MENU_CANCEL].sound); + JA_DeleteSound(mSound[SOUND_MENU_MOVE].sound); + + // Musicas + JA_DeleteMusic(mMusic[MUSIC_TITLE].music); + } + break; + + case GAME_STATE_TITLE: + { + // Texturas + mTexture[TEXTURE_TITLE].texture->free(); + + // Sonidos + JA_DeleteSound(mSound[SOUND_TITLE].sound); + } + break; + + case GAME_STATE_PLAYING: + { + // Texturas + mTexture[TEXTURE_PLAYER_LEGS].texture->free(); + mTexture[TEXTURE_PLAYER_BODY].texture->free(); + mTexture[TEXTURE_PLAYER_DEATH].texture->free(); + mTexture[TEXTURE_BALLOON].texture->free(); + mTexture[TEXTURE_BULLET].texture->free(); + mTexture[TEXTURE_GAME_BG].texture->free(); + mTexture[TEXTURE_GAME_TEXT].texture->free(); + mTexture[TEXTURE_ITEMS].texture->free(); + + // Sonidos + JA_DeleteSound(mSound[SOUND_BALLON].sound); + JA_DeleteSound(mSound[SOUND_BULLET].sound); + JA_DeleteSound(mSound[SOUND_PLAYER_COLLISION].sound); + JA_DeleteSound(mSound[SOUND_HISCORE].sound); + JA_DeleteSound(mSound[SOUND_ITEM_DROP].sound); + JA_DeleteSound(mSound[SOUND_ITEM_PICKUP].sound); + JA_DeleteSound(mSound[SOUND_COFFEE_OUT].sound); + JA_DeleteSound(mSound[SOUND_STAGE_CHANGE].sound); + JA_DeleteSound(mSound[SOUND_TITLE].sound); + JA_DeleteSound(mSound[SOUND_BUBBLE1].sound); + JA_DeleteSound(mSound[SOUND_BUBBLE2].sound); + JA_DeleteSound(mSound[SOUND_BUBBLE3].sound); + JA_DeleteSound(mSound[SOUND_BUBBLE4].sound); + + // Musicas + JA_DeleteMusic(mMusic[MUSIC_PLAYING].music); + } + break; + + case GAME_STATE_GAME_OVER_SCREEN: + { + } + break; + + case GAME_STATE_INTRO: + { + // Texturas + mTexture[TEXTURE_INTRO].texture->free(); + + // Musicas + JA_DeleteMusic(mMusic[MUSIC_INTRO].music); + } + break; + + case GAME_STATE_DEMO: + { + } + break; + + case GAME_STATE_INSTRUCTIONS: + { + // Texturas + mTexture[TEXTURE_ITEMS].texture->free(); + } + break; + + case GAME_STATE_LOGO: + { + // Texturas + mTexture[TEXTURE_LOGO].texture->free(); + } + break; + + default: + { + } + break; + } + + return success; +} + +// Establece el valor de la variable +void GameDirector::setExecutablePath(std::string path) +{ + mExecutablePath = path.substr(0, path.find_last_of("\\/")); +} + +// Establece el valor de la variable +void GameDirector::setScore(Uint32 score) +{ + mGame.score = score; +} + +// Establece el valor de la variable +void GameDirector::setHiScore(Uint32 score) +{ + mGame.hiScore = score; +} + +// Actualiza el valor de HiScore en caso necesario +void GameDirector::updateHiScore() +{ + // La puntuación es mayor que la máxima puntuación + if (mGame.score > mGame.hiScore) + { + // Actualiza la máxima puntuación + mGame.hiScore = mGame.score; + + // Almacena la máxima puntuación en el fichero junto con un checksum + mScoreDataFile[0] = mGame.hiScore; + mScoreDataFile[1] = mGame.hiScore % 43; + + // Si superamos la máxima puntuación + if (mGame.hiScoreAchieved == false) + { + mGame.hiScoreAchieved = true; + JA_PlaySound(mSound[SOUND_HISCORE].sound); + } + } +} + +// Transforma un valor numérico en una cadena de 6 cifras +std::string GameDirector::updateScoreText(Uint32 num) +{ + if ((num >= 0) && (num <= 9)) + { + return ("00000" + std::to_string(num)); + } + + if ((num >= 10) && (num <= 99)) + { + return ("0000" + std::to_string(num)); + } + + if ((num >= 100) && (num <= 999)) + { + return ("000" + std::to_string(num)); + } + + if ((num >= 1000) && (num <= 9999)) + { + return ("00" + std::to_string(num)); + } + + if ((num >= 010000) && (num <= 99999)) + { + return ("0" + std::to_string(num)); + } + + if ((num >= 100000) && (num <= 999999)) + { + return (std::to_string(num)); + } + + return (std::to_string(num)); +} + +// Pinta el marcador en pantalla usando un objeto texto +void GameDirector::renderScoreBoard() +{ + mText.white->write(SCORE_WORD_X, SCORE_WORD_Y, "SCORE", 0); + mText.white->write(SCORE_NUMBER_X, SCORE_NUMBER_Y, updateScoreText(mGame.score), 0); + + mText.white->write(MULTIPLIER_WORD_X, MULTIPLIER_WORD_Y, "MULT", 0); + mText.white->write(MULTIPLIER_NUMBER_X, MULTIPLIER_NUMBER_Y, std::to_string(mPlayer->getScoreMultiplier()), 0, 3); + + mText.white->write(HISCORE_WORD_X, HISCORE_WORD_Y, "HI-SCORE", 0); + mText.white->write(HISCORE_NUMBER_X, HISCORE_NUMBER_Y, updateScoreText(mGame.hiScore), 0); +} + +// Actualiza el valor de la variable mGame.stage +void GameDirector::updateStage() +{ + Uint8 realStage; + realStage = (mGame.score / 10000) + 1; + if (realStage > mGame.stage) + { + mGame.stage = realStage; + JA_PlaySound(mSound[SOUND_STAGE_CHANGE].sound); + mGame.stageCounter = STAGE_COUNTER; + } + + if (mGame.stageCounter > 0) + { + mGame.stageCounter--; + } +} + +// Actualiza el estado de muerte +void GameDirector::updateDeath() +{ + if (!mPlayer->isAlive()) + { + if (mGame.deathCounter > 0) + { + mGame.deathCounter--; + if ((mGame.deathCounter == 250) || (mGame.deathCounter == 200) || (mGame.deathCounter == 180) || (mGame.deathCounter == 120) || (mGame.deathCounter == 60)) + { + Uint8 sound = rand() % 4; + switch (sound) + { + case 0: + JA_PlaySound(mSound[SOUND_BUBBLE1].sound, 0); + break; + case 1: + JA_PlaySound(mSound[SOUND_BUBBLE2].sound, 0); + break; + case 2: + JA_PlaySound(mSound[SOUND_BUBBLE3].sound, 0); + break; + case 3: + JA_PlaySound(mSound[SOUND_BUBBLE4].sound, 0); + break; + + default: + break; + } + } + + // Animación + if ((mGame.deathCounter / 5) % 2 == 0) + { + mSmartSprite[mGame.deathIndex]->setSpriteClip(0, 0, 24, 24); + } + else + { + mSmartSprite[mGame.deathIndex]->setSpriteClip(24, 0, 24, 24); + } + + // Rebote en los laterales + if (mSmartSprite[mGame.deathIndex]->getVelX() > 0) + { + if (mSmartSprite[mGame.deathIndex]->getPosX() > (SCREEN_WIDTH - mSmartSprite[mGame.deathIndex]->getWidth())) + { + mSmartSprite[mGame.deathIndex]->setPosX(SCREEN_WIDTH - mSmartSprite[mGame.deathIndex]->getWidth()); + mSmartSprite[mGame.deathIndex]->setVelX(mSmartSprite[mGame.deathIndex]->getVelX() * (-1)); + mSmartSprite[mGame.deathIndex]->setDestX(mSmartSprite[mGame.deathIndex]->getDestX() * (-1)); + } + } + else + { + if (mSmartSprite[mGame.deathIndex]->getPosX() < 0) + { + mSmartSprite[mGame.deathIndex]->setPosX(0); + mSmartSprite[mGame.deathIndex]->setVelX(mSmartSprite[mGame.deathIndex]->getVelX() * (-1)); + mSmartSprite[mGame.deathIndex]->setDestX(mSmartSprite[mGame.deathIndex]->getDestX() * (-1)); + } + } + } + else + { + setGameStatus(GAME_STATE_GAME_OVER_SCREEN); + } + } +} + +// Renderiza el fade final cuando se acaba la partida +void GameDirector::renderDeathFade() +{ + /*if (!mPlayer->isAlive()) + { + SDL_Rect rect = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + if (mGame.deathCounter < 256) + { + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255 - mGame.deathCounter); + } + else + { + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0); // alpha - 0 trans, 255 opaco + } + SDL_RenderFillRect(mRenderer, &rect); + }*/ + + if (!mPlayer->isAlive() && (mGame.deathCounter < 150)) + { + // 192 / 6 = 32, 6 cuadrados de 32 pixeles + SDL_Rect rect[12]; + Uint8 h = (150 - mGame.deathCounter) / 3; + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); + for (Uint8 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]); + } + } +} + +// Mueve todos los globos activos +void GameDirector::moveBalloons() +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (mBalloon[i]->isActive()) + { + mBalloon[i]->update(); + } + } +} + +// Pinta en pantalla todos los globos activos +void GameDirector::renderBalloons() +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (mBalloon[i]->isActive()) + { + mBalloon[i]->render(); + if ((mDebug) && (mBalloon[i]->isPopping() == false)) + mText.white->write(mBalloon[i]->getPosX() + (mBalloon[i]->getWidth() / 2) - 4, mBalloon[i]->getPosY() - 8, std::to_string(i)); + } + } +} + +// Devuelve el primer indice no activo del vector de globos +Uint8 GameDirector::getBallonFreeIndex() +{ + int index = 0; + + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (mBalloon[i]->isActive() == false) + { + index = i; + break; + } + } + + return index; +} + +// Crea un globo nuevo en el vector de globos +Uint8 GameDirector::createNewBalloon(float x, int y, Uint8 kind, float velx, Uint16 creationtimer, LTexture *texture) +{ + Uint8 index = getBallonFreeIndex(); + mBalloon[index]->init(x, y, kind, velx, creationtimer, texture, mRenderer); + return index; +} + +// Establece a cero todos los valores del vector de objetos globo +void GameDirector::resetBalloons() +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + mBalloon[i]->erase(); + } +} + +// Explosiona un globo. Lo destruye y crea otros dos si es el caso +void GameDirector::popBalloon(Uint8 index) +{ + if (mBalloon[index]->isActive()) + { + // Otorga los puntos correspondientes al globo + mPlayer->addScore(Uint32(mBalloon[index]->getScore() * mPlayer->getScoreMultiplier())); + setScore(mPlayer->getScore()); + updateHiScore(); + + 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; + + // En cualquier otro caso, crea dos globos de un tipo inferior + default: + freeIndex = getBallonFreeIndex(); + mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLON_VELX_NEGATIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer); + mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2)); + mBalloon[freeIndex]->setVelY(-2.5); + // if (isTimeStopped()) mBalloon[freeIndex]->setStop(true); + + freeIndex = getBallonFreeIndex(); + mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLON_VELX_POSITIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer); + mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2)); + mBalloon[freeIndex]->setVelY(-2.5); + // if (isTimeStopped()) mBalloon[freeIndex]->setStop(true); + + // Elimina el globo + mBalloon[index]->pop(); + break; + } + // Reproduce el sonido de explotar el globo + // JA_PlaySound(mFX.popBalloon); + + // Recalcula el nivel de amenaza + calculateMenaceLevel(); + } +} + +// Explosiona todos los globos +void GameDirector::popAllBallons() +{ + int candidate[MAX_BALLOONS]; + Uint8 j = 0; + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if ((mBalloon[i]->isActive()) && (mBalloon[i]->isPopping() == false) && (mBalloon[i]->isBeingCreated() == false)) + { + candidate[j] = i; + } + else + { + candidate[j] = -1; + } + j += 1; + } + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (candidate[i] >= 0) + { + popBalloon(i); + } + } + JA_PlaySound(mSound[SOUND_BALLON].sound); +} + +// Detiene todos los globos +void GameDirector::stopAllBalloons(Uint16 time) +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (mBalloon[i]->isActive()) + { + mBalloon[i]->setStop(true); + mBalloon[i]->setStoppedTimer(time); + } + } +} + +// Pone en marcha todos los globos +void GameDirector::startAllBalloons() +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if ((mBalloon[i]->isActive()) && (mBalloon[i]->isBeingCreated() == false)) + { + mBalloon[i]->setStop(false); + mBalloon[i]->setStoppedTimer(0); + } + } +} + +// Obtiene el numero de globos activos +Uint8 GameDirector::countBalloons() +{ + Uint8 num = 0; + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + if (mBalloon[i]->isActive()) + { + ++num; + } + } + return num; +} + +// Comprueba la colisión entre el jugador y los globos activos +bool GameDirector::checkPlayerBallonCollision() + +{ + bool result = false; + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + //if ((mBalloon[i]->isActive()) && (mBalloon[i]->isStopped() == false)) + if ((mBalloon[i]->isActive()) && !(mBalloon[i]->isStopped()) && !(mBalloon[i]->isInvulnerable())) + { + if (checkCollision(mPlayer->getCollider(), mBalloon[i]->getCollider())) + { + result = true; + break; + } + } + } + return result; +} + +// Comprueba la colisión entre el jugador y los items +void GameDirector::checkPlayerItemCollision() +{ + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + if (mItem[i]->isEnabled()) + { + if (checkCollision(mPlayer->getCollider(), mItem[i]->getCollider())) + { + switch (mItem[i]->getClass()) + { + case ITEM_POINTS_1_DISK: + mPlayer->addScore(1000); + setScore(mPlayer->getScore()); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m1000Bitmap->getWidth() / 2), mItem[i]->getPosY(), m1000Bitmap); + JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound); + break; + case ITEM_POINTS_2_GAVINA: + mPlayer->addScore(2500); + setScore(mPlayer->getScore()); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m2500Bitmap->getWidth() / 2), mItem[i]->getPosY(), m2500Bitmap); + JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound); + break; + case ITEM_POINTS_3_PACMAR: + mPlayer->addScore(5000); + setScore(mPlayer->getScore()); + updateHiScore(); + createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m5000Bitmap->getWidth() / 2), mItem[i]->getPosY(), m5000Bitmap); + JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound); + break; + case ITEM_CLOCK: + enableTimeStopItem(); + JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound); + break; + case ITEM_TNT: + popAllBallons(); + setExplosionTime(true); + JA_PlaySound(mSound[SOUND_TITLE].sound); + break; + case ITEM_COFFEE: + mPlayer->giveExtraHit(); + JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound); + break; + + default: + break; + } + mItem[i]->erase(); + } + } + } +} + +// Comprueba y procesa la colisión entre las balas y los globos +void GameDirector::checkBulletBallonCollision() +{ + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + for (Uint8 j = 0; j < MAX_BULLETS; j++) + { + if (mBalloon[i]->isActive() && !(mBalloon[i]->isInvulnerable()) && mBullet[j]->isActive()) + { + if (checkCollision(mBalloon[i]->getCollider(), mBullet[j]->getCollider())) + { + mPlayer->incScoreMultiplier(); + popBalloon(i); + if (mDemo == false) + JA_PlaySound(mSound[SOUND_BALLON].sound); + mBullet[j]->erase(); + calculateMenaceLevel(); + Uint8 droppeditem = dropItem(); + if ((droppeditem != NO_KIND) && (mDemo == false) && (mDemoRecording == false)) + { + createItem(mBalloon[i]->getPosX(), mBalloon[i]->getPosY(), droppeditem); + JA_PlaySound(mSound[SOUND_ITEM_DROP].sound); + } + break; + } + } + } + } +} + +// Mueve las balas activas +void GameDirector::moveBullets() +{ + for (Uint8 i = 0; i < MAX_BULLETS; i++) + { + if (mBullet[i]->isActive()) + { + if (mBullet[i]->move() == MSG_BULLET_OUT) + { + mPlayer->decScoreMultiplier(); + } + } + } +} + +// Pinta las balas activas +void GameDirector::renderBullets() +{ + for (Uint8 i = 0; i < MAX_BULLETS; i++) + { + if (mBullet[i]->isActive()) + { + mBullet[i]->render(); + } + } +} + +// Devuelve el primer indice no activo del vector de balas +Uint8 GameDirector::getBulletFreeIndex() +{ + Uint8 index = 0; + + for (int i = 0; i < MAX_BULLETS; i++) + { + if (mBullet[i]->isActive() == false) + { + index = i; + break; + } + } + + return index; +} + +// Establece a cero todos los valores del vector de objetos bala +void GameDirector::resetBullets() +{ + for (Uint8 i = 0; i < MAX_BULLETS; i++) + { + mBullet[i]->erase(); + } +} + +// Crea un objeto bala +void GameDirector::createBullet(int x, int y, Uint8 kind) +{ + mBullet[getBulletFreeIndex()]->init(x, y, kind, mTexture[TEXTURE_BULLET].texture, mRenderer); +} + +// Actualiza los items +void GameDirector::updateItems() +{ + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + mItem[i]->update(); + } +} + +// Pinta los items activos +void GameDirector::renderItems() +{ + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + mItem[i]->render(); + } +} + +// Devuelve el primer indice no activo del vector de items +Uint8 GameDirector::getItemFreeIndex() +{ + Uint8 index = 0; + + for (int i = 0; i < MAX_ITEMS; i++) + { + if (mItem[i]->getClass() == NO_KIND) + { + index = i; + break; + } + } + + return index; +} + +// Establece a cero todos los valores del vector de objetos item +void GameDirector::resetItems() +{ + for (Uint8 i = 0; i < MAX_ITEMS; i++) + { + mItem[i]->erase(); + } +} + +// Devuelve un item en función del azar +Uint8 GameDirector::dropItem() +{ + // return ITEM_COFFEE; + Uint8 luckyNumber = rand() % 99; + Uint8 item = rand() % 6; + switch (item) + { + case 0: + if (luckyNumber < 10) + { + return ITEM_POINTS_1_DISK; + } + break; + case 1: + if (luckyNumber < 6) + { + return ITEM_POINTS_2_GAVINA; + } + break; + case 2: + if (luckyNumber < 3) + { + return ITEM_POINTS_3_PACMAR; + } + break; + case 3: + if (luckyNumber < 5) + { + return ITEM_CLOCK; + } + break; + case 4: + if (luckyNumber < 5) + { + return ITEM_TNT; + } + break; + case 5: + if (luckyNumber < 5) + { + return ITEM_COFFEE; + } + break; + default: + break; + } + return NO_KIND; +} + +// Crea un objeto item +void GameDirector::createItem(int x, int y, Uint8 kind) +{ + mItem[getItemFreeIndex()]->init(kind, x, y, mTexture[TEXTURE_ITEMS].texture, mRenderer); +} + +// Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto +void GameDirector::createItemScoreSprite(int x, int y, SmartSprite *sprite) +{ + 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); +} + +// Crea un SmartSprite para arrojar el item café al recibir un impacto +void GameDirector::throwCoffee(int x, int y) +{ + Uint8 index = getSmartSpriteFreeIndex(); + mSmartSprite[index]->init(mTexture[TEXTURE_ITEMS].texture, 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); +} + +// Crea un SmartSprite para arrojar el item café al recibir un impacto +void GameDirector::throwPlayer(int x, int y) +{ + int sentit = ((rand() % 2) ? 1 : -1); + mGame.deathIndex = getSmartSpriteFreeIndex(); + mSmartSprite[mGame.deathIndex]->init(mTexture[TEXTURE_PLAYER_DEATH].texture, mRenderer); + mSmartSprite[mGame.deathIndex]->setPosX(x); + mSmartSprite[mGame.deathIndex]->setPosY(y); + mSmartSprite[mGame.deathIndex]->setWidth(24); + mSmartSprite[mGame.deathIndex]->setHeight(24); + mSmartSprite[mGame.deathIndex]->setVelX(2.0f * sentit); + mSmartSprite[mGame.deathIndex]->setVelY(-5.0f); + mSmartSprite[mGame.deathIndex]->setAccelX(0.0f); + mSmartSprite[mGame.deathIndex]->setAccelY(0.2f); + mSmartSprite[mGame.deathIndex]->setDestX(SCREEN_WIDTH * sentit); + mSmartSprite[mGame.deathIndex]->setDestY(SCREEN_HEIGHT + 1); + mSmartSprite[mGame.deathIndex]->setEnabled(true); + mSmartSprite[mGame.deathIndex]->setEnabledTimer(1); + mSmartSprite[mGame.deathIndex]->setSpriteClip(0, 0, 24, 24); +} + +// Actualiza los SmartSprites +void GameDirector::updateSmartSprites() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + { + mSmartSprite[i]->update(); + } +} + +// Pinta los SmartSprites activos +void GameDirector::renderSmartSprites() +{ + for (int i = 0; i < MAX_SMART_SPRITES; i++) + { + mSmartSprite[i]->render(); + } +} + +// Devuelve el primer indice no activo del vector de SmartSprites +Uint8 GameDirector::getSmartSpriteFreeIndex() +{ + Uint8 index = 0; + + for (int i = 0; i < MAX_SMART_SPRITES; i++) + { + if (mSmartSprite[i]->isEnabled() == false) + { + index = i; + break; + } + } + + return index; +} + +// Establece a cero todos los valores del vector de objetos SmafrtSprite +void GameDirector::resetSmartSprites() +{ + for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++) + { + mSmartSprite[i]->erase(); + } +} + +// Acciones a realizar cuando el jugador muere +void GameDirector::killPlayer() +{ + if (mPlayer->hasExtraHit()) + { + mPlayer->removeExtraHit(); + throwCoffee(mPlayer->getPosX() + (mPlayer->getWidth() / 2), mPlayer->getPosY() + (mPlayer->getHeight() / 2)); + JA_PlaySound(mSound[SOUND_COFFEE_OUT].sound); + } + else if (!mPlayer->isInvulnerable()) + { + stopAllBalloons(10); // 5000 + JA_StopMusic(); + JA_PlaySound(mSound[SOUND_PLAYER_COLLISION].sound); + shakeScreen(); + SDL_Delay(500); // 1000 + JA_PlaySound(mSound[SOUND_COFFEE_OUT].sound); + throwPlayer(mPlayer->getPosX(), mPlayer->getPosY()); + mPlayer->setAlive(false); + } +} + +// Calcula y establece el valor de amenaza en funcion de los globos activos +void GameDirector::calculateMenaceLevel() +{ + mMenaceLevel = 0; + for (Uint8 i = 0; i < MAX_BALLOONS; i++) + { + mMenaceLevel += mBalloon[i]->getMenace(); + } +} + +// Obtiene el valor de la variable +Uint8 GameDirector::getMenaceLevel() +{ + return mMenaceLevel; +} + +// Obtiene el valor de la variable +bool GameDirector::isPlayFieldDrawOnly() +{ + return mPlayFieldDrawOnly; +} + +// Establece el valor de la variable +void GameDirector::setPlayFieldDrawOnly(bool state) +{ + mPlayFieldDrawOnly = state; +} + +// Establece el valor de la variable +void GameDirector::setTimeStopped(bool value) +{ + mTimeStopped = value; +} + +// Obtiene el valor de la variable +bool GameDirector::isTimeStopped() +{ + return mTimeStopped; +} + +// Establece el valor de la variable +void GameDirector::setTimeStoppedTimer(Uint16 value) +{ + mTimeStoppedTimer = value; +} + +// Actualiza y comprueba el valor de la variable +void GameDirector::updateTimeStoppedTimer() +{ + if (isTimeStopped()) + { + if (mTimeStoppedTimer > 0) + { + mTimeStoppedTimer--; + stopAllBalloons(TIME_STOPPED_TIMER); + } + else + { + disableTimeStopItem(); + } + } +} + +// Establece el valor de la variable +void GameDirector::setExplosionTime(bool value) +{ + mExplosionTime = value; +} + +// Obtiene el valor de la variable +bool GameDirector::isExplosionTime() +{ + return mExplosionTime; +} + +// Establece el valor de la variable +void GameDirector::setRemainingExplosions(Uint8 value) +{ + mRemainingExplosions = value; +} + +// Actualiza y comprueba el valor de la variable +void GameDirector::updateRemainingExplosionsTimer() +{ + if (isExplosionTime()) + { + if (mRemainingExplosionsTimer > 0) + { + --mRemainingExplosionsTimer; + } + else if (mRemainingExplosions > 0) + { + popAllBallons(); + --mRemainingExplosions; + mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER; + } + else + { + mExplosionTime = false; + mRemainingExplosions = REMAINING_EXPLOSIONS; + mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER; + } + } +} + +// Actualiza el campo de juego +void GameDirector::updatePlayField() +{ + if (isPlayFieldDrawOnly() == false) + { + // Comprueba el teclado/mando + checkGameInput(); + + // Actualiza el jugador + mPlayer->update(); + + // Mueve los globos + moveBalloons(); + + // Mueve las balas + moveBullets(); + + // Actualiza los items + updateItems(); + + // Actualiza el valor de mGame.stage + updateStage(); + + // Actualiza el estado de muerte + updateDeath(); + + // Actualiza los SmartSprites + updateSmartSprites(); + + // Actualiza los contadores de estado + updateTimeStoppedTimer(); + updateRemainingExplosionsTimer(); + + // Comprueba las colisiones entre globos y balas + checkBulletBallonCollision(); + + // Comprueba las colisiones entre elk jugador y los items + checkPlayerItemCollision(); + + // Comprueba el nivel de amenaza + checkMenaceLevel(); + + // Comprueba la colisión entre el jugador y los globos + if (checkPlayerBallonCollision()) + { + if (mPlayer->isAlive()) + { + if (mDemo) + { + mGame.status = GAME_STATE_INSTRUCTIONS; + } + else + { + killPlayer(); + } + } + } + } + else + { + // Actualiza el mensaje de GetReady + mGetReadyBitmap->update(); + } +} + +// Actualiza el fondo +void GameDirector::updateBackground() +{ + mGBClouds1->move(); + mGBClouds1b->move(); + mGBClouds2->move(); + mGBClouds2b->move(); + if (mGBClouds1->getPosX() < -mGBClouds1->getWidth()) + { + mGBClouds1->setPosX(mGBClouds1->getWidth()); + } + if (mGBClouds1b->getPosX() < -mGBClouds1b->getWidth()) + { + mGBClouds1b->setPosX(mGBClouds1b->getWidth()); + } + if (mGBClouds2->getPosX() < -mGBClouds2->getWidth()) + { + mGBClouds2->setPosX(mGBClouds2->getWidth()); + } + if (mGBClouds2b->getPosX() < -mGBClouds2b->getWidth()) + { + mGBClouds2b->setPosX(mGBClouds2b->getWidth()); + } + mGrass->setSpriteClip(256, 85 + (6 * (mGameCounter / 20 % 2)), SCREEN_WIDTH, 6); +} + +// Dibuja el fondo +void GameDirector::renderBackground() +{ + int alpha = (255 - (mGame.score / 392)); + + if (alpha < 0) + { + alpha = 0; + } + + updateBackground(); + mGameBackgroundSky->setSpriteClip(SCREEN_WIDTH, 192, SCREEN_WIDTH, SCREEN_HEIGHT); + mTexture[TEXTURE_GAME_BG].texture->setAlpha(255); + mGameBackgroundSky->render(); + + mGameBackgroundSky->setSpriteClip(0, 192, SCREEN_WIDTH, SCREEN_HEIGHT); + mTexture[TEXTURE_GAME_BG].texture->setAlpha(alpha); + mGameBackgroundSky->render(); + + mTexture[TEXTURE_GAME_BG].texture->setAlpha(255); + mGBClouds1->render(); + mGBClouds1b->render(); + mGBClouds2->render(); + mGBClouds2b->render(); + mGameBackgroundFront->render(); + mGrass->render(); +} + +// Dibuja el campo de juego +void GameDirector::renderPlayField() +{ + renderBackground(); + renderBalloons(); + renderBullets(); + renderItems(); + renderSmartSprites(); + mPlayer->render(); + renderDeathFade(); + if (!mDemo) + { + renderScoreBoard(); + } + else + { + mText.nokia->writeCentered(SCREEN_FIRST_QUARTER_X, SCORE_WORD_Y - 3, "A game by", -1); + mText.nokia->writeCentered(SCREEN_FIRST_QUARTER_X, SCORE_NUMBER_Y, "JailDesigner", -1); + mText.nokia->writeCentered(SCREEN_THIRD_QUARTER_X, HISCORE_WORD_Y - 3, "Intro music by", -1); + mText.nokia->writeCentered(SCREEN_THIRD_QUARTER_X, HISCORE_NUMBER_Y, "JailDoctor", -1); + } + renderMessages(); + renderDebugInfo(); +} + +// Gestiona el nivel de amenaza +void GameDirector::checkMenaceLevel() +{ + // Aumenta el nivel de amenaza en función de la puntuación + mMenaceLevelThreshold = 7 + (4 * (mGame.score / 10000)); + + // Si el nivel de amenza es inferior al umbral + if (mMenaceLevel < mMenaceLevelThreshold) + { + Uint8 index = 0; + + // Obtiene el centro del jugador en el eje X + int x = mPlayer->getPosX() + (mPlayer->getWidth() / 2); + + // Crea un globo sobre el jugador en dirección hacia el centro + if (x < (PLAY_AREA_WIDTH / 2)) + { + index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_POSITIVE, 400, mTexture[TEXTURE_BALLOON].texture); + } + else + { + index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_NEGATIVE, 400, mTexture[TEXTURE_BALLOON].texture); + } + mBalloon[index]->allignTo(x); + + // Recalcula el nivel de amenaza con el nuevo globo + calculateMenaceLevel(); + } +} + +// Gestiona las entradas desde el mando de juego +bool GameDirector::checkGameController(Uint8 state) +{ + // No hay mando. Siempre devuelve falso salvo NO_INPUT que siempre es cierto + if (!mGameControllerFound) + { + if (state == NO_INPUT) + return true; + else + return false; + } + + bool success = false; + + switch (state) + { + case NO_INPUT: + success = !checkGameController(INPUT_UP) && !checkGameController(INPUT_DOWN) && !checkGameController(INPUT_LEFT) && !checkGameController(INPUT_RIGHT) && + !checkGameController(INPUT_ACCEPT) && !checkGameController(INPUT_CANCEL) && !checkGameController(INPUT_PAUSE) && + !checkGameController(INPUT_FIRE_UP) && !checkGameController(INPUT_FIRE_LEFT) && !checkGameController(INPUT_FIRE_RIGHT); + break; + case INPUT_UP: + success = (SDL_JoystickGetAxis(mGameController, 1) < -JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_UP)); + break; + case INPUT_DOWN: + success = (SDL_JoystickGetAxis(mGameController, 1) > JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_DOWN)); + break; + case INPUT_LEFT: + success = (SDL_JoystickGetAxis(mGameController, 0) < -JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_LEFT)); + break; + case INPUT_RIGHT: + success = (SDL_JoystickGetAxis(mGameController, 0) > JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_RIGHT)); + break; + case INPUT_ACCEPT: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_B)); + break; + case INPUT_CANCEL: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_A)); + break; + case INPUT_PAUSE: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_START)); + break; + case INPUT_FIRE_UP: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_Y)); + break; + case INPUT_FIRE_LEFT: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_X)); + break; + case INPUT_FIRE_RIGHT: + success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_B)); + break; + + default: + break; + } + return success; +} + +// Gestiona la entrada durante el juego +void GameDirector::checkGameInput() +{ + // Obtiene el estado de las teclas pulsadas del teclado + keystates = SDL_GetKeyboardState(NULL); + + mDemoKeys.left = 0; + mDemoKeys.right = 0; + mDemoKeys.noInput = 0; + mDemoKeys.fire = 0; + mDemoKeys.fireLeft = 0; + mDemoKeys.fireRight = 0; + + // Modo Demo activo + if (mDemo) + { + if (mDemoDataFile[mDemoCounter].left == 1) + mPlayer->setInput(INPUT_LEFT); + if (mDemoDataFile[mDemoCounter].right == 1) + mPlayer->setInput(INPUT_RIGHT); + if (mDemoDataFile[mDemoCounter].noInput == 1) + mPlayer->setInput(NO_INPUT); + if (mDemoDataFile[mDemoCounter].fire == 1) + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_UP); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP); + mPlayer->setFireCooldown(10); + } + if (mDemoDataFile[mDemoCounter].fireLeft == 1) + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_LEFT); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP); + mPlayer->setFireCooldown(10); + } + if (mDemoDataFile[mDemoCounter].fireRight == 1) + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_RIGHT); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP); + mPlayer->setFireCooldown(10); + } + + // Comprobamos la tecla o el botón de pausa/menu + if ((keystates[mKeyboard.accept] != 0) || (keystates[mKeyboard.cancel] != 0) || (checkGameController(INPUT_PAUSE)) || (checkGameController(INPUT_ACCEPT)) || (checkGameController(INPUT_CANCEL))) + { + setGameStatus(GAME_STATE_TITLE); + } + + if (mDemoCounter < TOTAL_DEMO_DATA) + { + mDemoCounter++; + } + else + { + mGame.status = GAME_STATE_INSTRUCTIONS; + //mDemoCounter = 0; + } + } + // Modo Demo no activo + else + { + // Tecla izquierda o el mando hacia la izquierda + if ((keystates[mKeyboard.left] != 0) || (checkGameController(INPUT_LEFT))) + { + mPlayer->setInput(INPUT_LEFT); + mDemoKeys.left = 1; + } + else + { + // Tecla derecha o el mando hacia la derecha + if ((keystates[mKeyboard.right] != 0) || (checkGameController(INPUT_RIGHT))) + { + mPlayer->setInput(INPUT_RIGHT); + mDemoKeys.right = 1; + } + else + { + // Ninguna de las dos direcciones pulsadas + mPlayer->setInput(NO_INPUT); + mDemoKeys.noInput = 1; + } + } + // Comprueba la tecla o el botón de disparo central + if ((keystates[mKeyboard.fire] != 0) || (checkGameController(INPUT_FIRE_UP))) + { + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_UP); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP); + mPlayer->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSound[SOUND_BULLET].sound); + + mDemoKeys.fire = 1; + } + } + + // Comprueba la tecla o el botón de disparo izquierdo + if ((keystates[mKeyboard.fireLeft] != 0) || (checkGameController(INPUT_FIRE_LEFT))) + { + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_LEFT); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_LEFT); + mPlayer->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSound[SOUND_BULLET].sound); + + mDemoKeys.fireLeft = 1; + } + } + + // Comprueba la tecla o el botón de disparo derecho + if ((keystates[mKeyboard.fireRight] != 0) || (checkGameController(INPUT_FIRE_RIGHT))) + { + if (mPlayer->canFire()) + { + mPlayer->setInput(INPUT_FIRE_RIGHT); + createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_RIGHT); + mPlayer->setFireCooldown(10); + + // Reproduce el sonido de disparo + JA_PlaySound(mSound[SOUND_BULLET].sound); + + mDemoKeys.fireRight = 1; + } + } + + // Para la pausa actuaremos cuando se suelte la tecla de pausa + // Comprueba la tecla o el botón de pausa/menu y su buffer + if (((keystates[mKeyboard.pause] != 0) || (checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause == 0)) //|| ((mGameControllerFound) && (SDL_JoystickGetButton(mGameController, BUTTON_START)))) + { + // Se acaba de pulsar la tecla. Lo anotamos en su buffer + mKeyboardBuffer.pause = 1; + } + else + { + // Aqui sigue la tecla pulsada, mantenemos el buffer activo + if (((keystates[mKeyboard.pause] != 0) || (checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause != 0)) + { + mKeyboardBuffer.pause = 1; + } + else + { + // Se ha soltado la tecla, procedemos a ejecutar la accion + if (((keystates[mKeyboard.pause] == 0) || (!checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause != 0)) + { + //setGameStatus(GAME_STATE_PAUSED); + mGame.paused = true; + + if (JA_GetMusicState() == JA_MUSIC_PLAYING) + { + JA_PauseMusic(); + } + + mKeyboardBuffer.pause = 0; + } + } + } + + if (mDemoCounter < TOTAL_DEMO_DATA) + { + if (mDemoRecording) + { + mDemoDataFile[mDemoCounter] = mDemoKeys; + } + mDemoCounter++; + } + else if (mDemoRecording) + { + mGame.status = GAME_STATE_QUIT; + } + } +} + +// Gestiona la entrada de teclado y mando durante el menu +void GameDirector::checkMenuInput(Menu *menu) +{ + // Obtiene el estado de las teclas pulsadas del teclado + keystates = SDL_GetKeyboardState(NULL); + + if (!mMenuKeyPressed) + { + // Tecla arriba o el mando hacia arriba + if ((keystates[mKeyboard.up] != 0) || (checkGameController(INPUT_UP))) + { + if (menu->checkInput(INPUT_UP)) + { + mMenuKeyPressed = true; + JA_PlaySound(mSound[SOUND_MENU_MOVE].sound); + } + } + + // Tecla abajo o el mando hacia abajo + if ((keystates[mKeyboard.down] != 0) || (checkGameController(INPUT_DOWN))) + { + if (menu->checkInput(INPUT_DOWN)) + { + mMenuKeyPressed = true; + JA_PlaySound(mSound[SOUND_MENU_MOVE].sound); + } + } + + // Tecla o el botón de aceptar + if ((keystates[mKeyboard.accept] != 0) || (checkGameController(INPUT_ACCEPT))) + { + menu->checkInput(INPUT_ACCEPT); + mMenuKeyPressed = true; + } + + // Tecla o el botón de cancelar + if ((keystates[mKeyboard.cancel] != 0) || (checkGameController(INPUT_CANCEL))) + { + menu->checkInput(INPUT_CANCEL); + mMenuKeyPressed = true; + } + } + + // Ningún botón, libera la variable + if ((keystates[mKeyboard.up] == 0) && (keystates[mKeyboard.down] == 0) && (keystates[mKeyboard.accept] == 0) && + (keystates[mKeyboard.cancel] == 0) && (checkGameController(NO_INPUT))) + { + mMenuKeyPressed = false; + } +} + +// Obtiene el valor de la variable +Uint8 GameDirector::getGameStatus() +{ + return mGame.status; +} + +// Establece el valor de la variable +void GameDirector::setGameStatus(Uint8 status) +{ + mGame.status = status; +} + +// Pinta una transición en pantalla +void GameDirector::renderFade(Uint8 index) +{ + SDL_Rect rect1; + SDL_Rect rect2; + Uint8 R, G, B; + + // Copia el backbuffer al renderer + SDL_SetRenderTarget(mRenderer, NULL); + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + SDL_RenderPresent(mRenderer); + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + SDL_RenderPresent(mRenderer); + + switch (index) + { + case 0: + rect1 = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + R = 0x27; + G = 0x27; + B = 0x36; + + 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, R, G, B, i); + SDL_RenderFillRect(mRenderer, &rect1); + + // Vuelca el renderizador en pantalla + SDL_RenderPresent(mRenderer); + } + + // Deja todos los bufferes del mismo color + SDL_SetRenderTarget(mRenderer, mBackbuffer); + SDL_SetRenderDrawColor(mRenderer, R, G, B, 255); + SDL_RenderClear(mRenderer); + + SDL_SetRenderTarget(mRenderer, NULL); + SDL_SetRenderDrawColor(mRenderer, R, G, B, 255); + SDL_RenderClear(mRenderer); + break; + + case 1: + rect1 = {0, 0, SCREEN_WIDTH, 0}; + rect2 = {0, 0, SCREEN_WIDTH, 0}; + R = 0x27; + G = 0x27; + B = 0x36; + + SDL_SetRenderDrawColor(mRenderer, R, G, B, 64); + + for (Uint16 i = 0; i < (SCREEN_HEIGHT / 2); i += 4) + { + // Dibujamos sobre el backbuffer + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + rect1.h = rect2.h = i; + rect2.y = SCREEN_HEIGHT - (i); + + SDL_RenderFillRect(mRenderer, &rect1); + SDL_RenderFillRect(mRenderer, &rect2); + + // 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); + } + + rect1 = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + + for (Uint8 i = 0; i < 32; i++) + { + // Dibujamos sobre el backbuffer + SDL_SetRenderTarget(mRenderer, mBackbuffer); + SDL_RenderFillRect(mRenderer, &rect1); + + // 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); + } + break; + + case 2: + rect1 = {0, 0, 32, 32}; + + for (Uint16 i = 0; i < 50; i++) + { + // Crea un color al azar + R = 255 * (rand() % 2); + G = 255 * (rand() % 2); + B = 255 * (rand() % 2); + SDL_SetRenderDrawColor(mRenderer, R, G, B, 64); + + // Dibujamos sobre el backbuffer + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + rect1.x = rand() % (SCREEN_WIDTH - rect1.w); + rect1.y = rand() % (SCREEN_HEIGHT - rect1.h); + SDL_RenderFillRect(mRenderer, &rect1); + + // 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; + } +} + +// Pinta diferentes mensajes en la pantalla +void GameDirector::renderMessages() +{ + //mGetReadyBitmap->update(); + mGetReadyBitmap->render(); + if (!mGetReadyBitmap->isEnabled()) + setPlayFieldDrawOnly(false); + + if (mTimeStopped) + { + if ((mTimeStoppedTimer > 100) || (mTimeStoppedTimer % 10 > 4)) + { + mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, PLAY_AREA_FIRST_QUARTER_Y + 1, "Time Stopped: " + std::to_string(mTimeStoppedTimer / 10), 0); + mText.white->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, "Time Stopped: " + std::to_string(mTimeStoppedTimer / 10), 0); + } + } + + if (mDemo) + { + if (mDemoCounter % 30 > 14) + { + mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, PLAY_AREA_FIRST_QUARTER_Y + 1, "D E M O", 0); + mText.white->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, "D E M O", 0); + } + } + + if (mGame.stageCounter > 0) + { + mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, int(mGame.stagePath[mGame.stageCounter - 1]) + 1, "STAGE " + std::to_string(mGame.stage), 0); + mText.white->writeCentered(PLAY_AREA_CENTER_X, int(mGame.stagePath[mGame.stageCounter - 1]), "STAGE " + std::to_string(mGame.stage), 0); + } +} + +// Habilita el efecto del item de detener el tiempo +void GameDirector::enableTimeStopItem() +{ + stopAllBalloons(TIME_STOPPED_TIMER); + setTimeStopped(true); + setTimeStoppedTimer(TIME_STOPPED_TIMER); + if (JA_GetMusicState() == JA_MUSIC_PLAYING) + { + JA_PauseMusic(); + } +} + +// Deshabilita el efecto del item de detener el tiempo +void GameDirector::disableTimeStopItem() +{ + mTimeStopped = false; + mTimeStoppedTimer = TIME_STOPPED_TIMER; + startAllBalloons(); + if (JA_GetMusicState() == JA_MUSIC_PAUSED) + { + JA_ResumeMusic(); + } +} + +// Cambia el valor de la variable de modo de pantalla completa +void GameDirector::changeFullScreenMode() +{ + switch (mFullScreenMode) + { + case 0: + mFullScreenMode = SDL_WINDOW_FULLSCREEN; + break; + case SDL_WINDOW_FULLSCREEN: + mFullScreenMode = SDL_WINDOW_FULLSCREEN_DESKTOP; + break; + case SDL_WINDOW_FULLSCREEN_DESKTOP: + mFullScreenMode = 0; + break; + + default: + mFullScreenMode = 0; + break; + } +} + +// Actualiza los elementos del menu de opciones +void GameDirector::updateOptionsMenu() +{ + switch (mFullScreenMode) + { + case 0: + mMenu.options->setItemCaption(0, "WINDOWED"); + break; + case SDL_WINDOW_FULLSCREEN: + mMenu.options->setItemCaption(0, "FULLSCREEN"); + break; + case SDL_WINDOW_FULLSCREEN_DESKTOP: + mMenu.options->setItemCaption(0, "FAKE FULLSCREEN"); + break; + + default: + mMenu.options->setItemCaption(0, "WINDOWED"); + break; + } + mMenu.options->setItemCaption(1, "WINDOWS SIZE " + std::to_string(mWindowSize)); + mMenu.options->centerMenu(SCREEN_CENTER_X); + mMenu.options->centerMenuElements(); +} + +// Agita la pantalla +void GameDirector::shakeScreen() +{ + int v[] = {-1, 1, -1, 1, -1, 1, -1, 0}; + for (Uint8 n = 0; n < 8; n++) + { + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + mGameBackgroundFront->setPosX(0); + mGameBackgroundFront->setWidth(1); + mGameBackgroundFront->setSpriteClip(0, 0, 1, 192); + renderBackground(); + + mGameBackgroundFront->setPosX(255); + mGameBackgroundFront->setSpriteClip(255, 0, 1, 192); + mGameBackgroundFront->render(); + + mGameBackgroundFront->setPosX(v[n]); + mGameBackgroundFront->setWidth(256); + mGameBackgroundFront->setSpriteClip(0, 0, 256, 192); + mGameBackgroundFront->render(); + + mGrass->render(); + renderBalloons(); + renderBullets(); + renderItems(); + mPlayer->render(); + renderScoreBoard(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + SDL_Delay(50); + } +} + +// Bucle para el logo del juego +void GameDirector::runLogo() +{ + while (mGame.status == GAME_STATE_LOGO) + { + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + + // Cualquier tecla pulsada + if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN)) + { + setGameStatus(GAME_STATE_TITLE); + } + } + + // Cambia el destino donde se pinta todo + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + // Limpia el destino + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + mLogo.sprite->render(); + + // Dibuja el fade + if (mLogo.counter >= 200) + { + SDL_Rect rect = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + Uint16 alpha = mLogo.counter - 200; + if (alpha < 256) + { + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, alpha); + } + else + { + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); // alpha - 0 trans, 255 opaco + } + SDL_RenderFillRect(mRenderer, &rect); + } + + // Vuelve a usar el renderizador como destino + SDL_SetRenderTarget(mRenderer, NULL); + + // Copia el backbufer al renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba si ha terminado el logo + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + if (mLogo.counter == 0) + { + if (JA_GetMusicState() == JA_MUSIC_PLAYING) + { + JA_StopMusic(); + } + } + + if (mLogo.counter == 500) // minimo 200 + 255 + { + mLogo.counter = 0; + setGameStatus(GAME_STATE_INTRO); + } + else + { + mLogo.counter++; + } + } + } +} + +// Bucle para la intro del juego +void GameDirector::runIntro() +{ + // Si la música no está sonando + if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) + { + // Reproduce la música + JA_PlayMusic(mMusic[MUSIC_INTRO].music, false); + } + + while (mGame.status == GAME_STATE_INTRO) + { + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + + if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN)) + { + JA_StopMusic(); + setGameStatus(GAME_STATE_TITLE); + } + } + + // Actualiza los objetos + for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++) + { + mIntroBitmap[i]->update(); + } + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + mIntroText[i]->update(); + } + + // Guión de eventos + // Primera imagen - UPV + if (mIntroEvents[BITMAP0] == EVENT_WAITING) + { + mIntroBitmap[0]->setEnabled(true); + mIntroEvents[BITMAP0] = EVENT_RUNNING; + } + + // Primer texto de la primera imagen + if ((mIntroEvents[BITMAP0] == EVENT_COMPLETED) && (mIntroEvents[TEXT0] == EVENT_WAITING)) + { + mIntroText[0]->setEnabled(true); + mIntroEvents[TEXT0] = EVENT_RUNNING; + } + + // Segundo texto de la primera imagen + if ((mIntroEvents[TEXT0] == EVENT_COMPLETED) && (mIntroEvents[TEXT1] == EVENT_WAITING)) + { + mIntroText[0]->setEnabled(false); + mIntroText[1]->setEnabled(true); + mIntroEvents[TEXT1] = EVENT_RUNNING; + } + + // Tercer texto de la primera imagen + if ((mIntroEvents[TEXT1] == EVENT_COMPLETED) && (mIntroEvents[TEXT2] == EVENT_WAITING)) + { + mIntroText[1]->setEnabled(false); + mIntroText[2]->setEnabled(true); + mIntroEvents[TEXT2] = EVENT_RUNNING; + } + + // Segunda imagen - Máquina + if ((mIntroEvents[TEXT2] == EVENT_COMPLETED) && (mIntroEvents[BITMAP1] == EVENT_WAITING)) + { + mIntroBitmap[0]->setEnabled(false); + mIntroText[2]->setEnabled(false); + mIntroBitmap[1]->setEnabled(true); + mIntroEvents[BITMAP1] = EVENT_RUNNING; + } + + // Primer texto de la segunda imagen + if ((mIntroEvents[BITMAP1] == EVENT_COMPLETED) && (mIntroEvents[TEXT3] == EVENT_WAITING)) + { + mIntroText[3]->setEnabled(true); + mIntroEvents[TEXT3] = EVENT_RUNNING; + } + + // Tercera imagen junto con primer texto - GRITO + if ((mIntroEvents[TEXT3] == EVENT_COMPLETED) && (mIntroEvents[BITMAP2] == EVENT_WAITING) && (mIntroEvents[TEXT4] == EVENT_WAITING)) + { + mIntroBitmap[1]->setEnabled(false); + mIntroText[3]->setEnabled(false); + mIntroBitmap[2]->setEnabled(true); + mIntroText[4]->setEnabled(true); + mIntroEvents[BITMAP2] = EVENT_RUNNING; + mIntroEvents[TEXT4] = EVENT_RUNNING; + } + + // Cuarta imagen junto con primer texto - Reflexión + if ((mIntroEvents[TEXT4] == EVENT_COMPLETED) && (mIntroEvents[BITMAP3] == EVENT_WAITING) && (mIntroEvents[TEXT5] == EVENT_WAITING)) + { + mIntroBitmap[2]->setEnabled(false); + mIntroText[4]->setEnabled(false); + mIntroBitmap[3]->setEnabled(true); + mIntroText[5]->setEnabled(true); + mIntroEvents[BITMAP3] = EVENT_RUNNING; + mIntroEvents[TEXT5] = EVENT_RUNNING; + } + + // Segundo texto de la cuarta imagen + if ((mIntroEvents[TEXT5] == EVENT_COMPLETED) && (mIntroEvents[TEXT6] == EVENT_WAITING)) + { + mIntroText[5]->setEnabled(false); + mIntroText[6]->setEnabled(true); + mIntroEvents[TEXT6] = EVENT_RUNNING; + } + + // Quinta imagen - Patada + if ((mIntroEvents[TEXT6] == EVENT_COMPLETED) && (mIntroEvents[BITMAP4] == EVENT_WAITING)) + { + mIntroBitmap[3]->setEnabled(false); + mIntroText[6]->setEnabled(false); + mIntroBitmap[4]->setEnabled(true); + mIntroEvents[BITMAP4] = EVENT_RUNNING; + } + + // Primer texto de la quinta imagen + if ((mIntroEvents[BITMAP4] == EVENT_COMPLETED) && (mIntroEvents[TEXT7] == EVENT_WAITING)) + { + mIntroText[7]->setEnabled(true); + mIntroEvents[TEXT7] = EVENT_RUNNING; + } + + // Sexta imagen junto con texto - Globos de café + if ((mIntroEvents[TEXT7] == EVENT_COMPLETED) && (mIntroEvents[BITMAP5] == EVENT_WAITING) && (mIntroEvents[TEXT8] == EVENT_WAITING)) + { + mIntroBitmap[4]->setEnabled(false); + mIntroText[7]->setEnabled(false); + mIntroBitmap[5]->setEnabled(true); + mIntroText[8]->setEnabled(true); + mIntroEvents[BITMAP5] = EVENT_RUNNING; + mIntroEvents[TEXT8] = EVENT_RUNNING; + } + + // Acaba el último texto + if (mIntroEvents[TEXT8] == EVENT_COMPLETED) + { + mIntroText[8]->setEnabled(false); + JA_StopMusic(); + mGame.status = GAME_STATE_TITLE; + } + } + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++) + { + mIntroBitmap[i]->render(); + } + for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++) + { + mIntroText[i]->render(); + } + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + } +} + +// Bucle para el titulo del juego +void GameDirector::runTitle() +{ + Uint8 R, G, B; + R = 0x27; + G = 0x27; + B = 0x36; + + while (mGame.status == GAME_STATE_TITLE) + { + // Estado 0 - Titulo desplazandose + if (mTitleStatus == 0) + { + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + } + + // Calcula la lógica de los objetos + if (SDL_GetTicks() - mTicks > mTicksSpeed) + { + // Actualiza el contador de ticks + mTicks = SDL_GetTicks(); + + // Actualiza los objetos + mCoffeeBitmap->update(); + mCrisisBitmap->update(); + } + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, R, G, B, 255); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + mCoffeeBitmap->render(); + mCrisisBitmap->render(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + + // Si los objetos han llegado a su destino, cambiamos de estado + if ((mTitleEvents[0] == EVENT_COMPLETED) && (mTitleEvents[0] == EVENT_COMPLETED)) + { + mTitleStatus = 1; + + // Pantallazo blanco + SDL_SetRenderDrawColor(mRenderer, 0xFF, 0xFF, 0xFF, 0xFF); + SDL_RenderClear(mRenderer); + SDL_RenderPresent(mRenderer); + } + } + + // Estado 1 - Titulo vibrando + if (mTitleStatus == 1) + { + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + } + + // Reproduce el efecto sonoro + JA_PlaySound(mSound[SOUND_TITLE].sound); + + // Agita la pantalla + int v[] = {-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 0}; + int a = mCoffeeBitmap->getPosX(); + int b = mCrisisBitmap->getPosX(); + for (Uint8 n = 0; n < 11 * 3; n++) + { + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, R, G, B, 255); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + mCoffeeBitmap->setPosX(a + v[n / 3]); + mCrisisBitmap->setPosX(b + v[n / 3]); + mCoffeeBitmap->render(); + mCrisisBitmap->render(); + mDustSpriteRight->animate(0); + mDustSpriteLeft->animate(0); + mDustSpriteRight->render(); + mDustSpriteLeft->render(); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + } + + mTitleStatus = 2; + } + + // Estado 2 - La pantalla de titulo con el menú y la música + if (mTitleStatus == 2) + { + if (mTitleTimer > 0) + { + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + + if ((mEventHandler->type == SDL_KEYUP) || (mEventHandler->type == SDL_JOYBUTTONUP)) + { + mTitleMenuVisible = true; + mTitleTimer = TITLE_TIMER; + } + } + // Si la música no está sonando + if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) + { + // Reproduce la música + JA_PlayMusic(mMusic[MUSIC_TITLE].music, true); + } + + // 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 + mMenu.active->update(); + } + + // Cambia el destino donde se pinta todo + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, R, G, B, 255); + SDL_RenderClear(mRenderer); + + // Pinta el tileado de fondo + switch (mTitleBackgroundMode) + { + case 0: + mBackgroundWindow.x++; + mBackgroundWindow.x %= 64; + mBackgroundWindow.y++; + mBackgroundWindow.y %= 64; + break; + + case 1: + mTitleBackgroundTimer++; + mTitleBackgroundTimer %= 360; + mBackgroundWindow.x = 128 + (int(mSen[(mTitleBackgroundTimer + 270) % 360] * 128)); + mBackgroundWindow.y = 96 + (int(mSen[(360 - mTitleBackgroundTimer) % 360] * 96)); + break; + + default: + break; + } + + SDL_RenderCopy(mRenderer, mTitleSurface, &mBackgroundWindow, NULL); + + // Dibuja los objetos + mCoffeeBitmap->render(); + mCrisisBitmap->render(); + if (mTitleMenuVisible == true) + { + mMenu.active->render(); + } + mDustSpriteRight->animate(0); + mDustSpriteLeft->animate(0); + mDustSpriteRight->render(); + mDustSpriteLeft->render(); + + if ((mTitleTimer % 50 > 14) && (mTitleMenuVisible == false)) + { + mText.black->writeCentered(SCREEN_CENTER_X + 1, PLAY_AREA_THIRD_QUARTER_Y + BLOCK + 1, "PRESS ANY KEY!", 0); + mText.white->writeCentered(SCREEN_CENTER_X, PLAY_AREA_THIRD_QUARTER_Y + BLOCK, "PRESS ANY KEY!", 0); + } + + mText.black->writeCentered(SCREEN_CENTER_X + 1, SCREEN_HEIGHT - (BLOCK * 2) + 1, TEXT_COPYRIGHT, 0); + mText.white->writeCentered(SCREEN_CENTER_X, SCREEN_HEIGHT - (BLOCK * 2), TEXT_COPYRIGHT, 0); + + // Vuelve a usar el renderizador como destino + SDL_SetRenderTarget(mRenderer, NULL); + + // Volca el contenido de la textura en el renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba las entradas para el menu + if (mTitleMenuVisible == true) + { + checkMenuInput(mMenu.active); + } + + // Comprueba si se ha seleccionado algún item del menú + if (mMenu.active->getName() == "TITLE") + { + switch (mMenu.active->getItemSelected()) + { + case 0: + setGameStatus(GAME_STATE_PLAYING); + mMenu.active->reset(); + mMenuKeyPressed = false; + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + renderFade(1); + JA_StopMusic(); + init(true); + disableDemoMode(); + break; + case 1: + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + mMenu.active->reset(); + mMenu.active = mMenu.options; + mFullScreenModePrevious = mFullScreenMode; + mWindowSizePrevious = mWindowSize; + break; + case 2: + setGameStatus(GAME_STATE_QUIT); + mMenu.active->reset(); + mMenuKeyPressed = false; + JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound); + renderFade(1); + JA_StopMusic(); + break; + + default: + break; + } + } + + // Comprueba si se ha seleccionado algún item de opciones + if (mMenu.active->getName() == "OPTIONS") + { + switch (mMenu.active->getItemSelected()) + { + case 0: // Fullscreen mode + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + changeFullScreenMode(); + updateOptionsMenu(); + mMenu.active->deselectItem(); + break; + case 1: // Windows size + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + mWindowSize++; + if (mWindowSize == 5) + mWindowSize = 1; + updateOptionsMenu(); + mMenu.active->deselectItem(); + break; + case 2: // OK + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + SDL_SetWindowFullscreen(mWindow, mFullScreenMode); + SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mWindowSize, SCREEN_HEIGHT * mWindowSize); + mMenu.active->reset(); + mMenu.active = mMenu.title; + break; + case 3: // CANCEL + JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound); + mFullScreenMode = mFullScreenModePrevious; + mWindowSize = mWindowSizePrevious; + updateOptionsMenu(); + mMenu.active->reset(); + mMenu.active = mMenu.title; + break; + + default: + break; + } + } + + if (mMenu.active->getName() == "TITLE") + { + mTitleTimer--; + } + } + else if (mTitleTimer == 0) + { + mTitleTimer = TITLE_TIMER; + mGame.status = mTiteNextGS; + mMenu.active->reset(); + toogleTitleNextGS(); + renderFade(1); + if (mGame.status == GAME_STATE_INTRO) + { + JA_StopMusic(); + } + init(true); + enableDemoMode(); + } + } + } +} + +// Bucle para el juego +void GameDirector::runGame() +{ + while (mGame.status == GAME_STATE_PLAYING) + { + // Si la música no está sonando + if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) + { + // Reproduce la música + if (mPlayer->isAlive()) + JA_PlayMusic(mMusic[MUSIC_PLAYING].music, true); + } + + // Lógica del juego + if (mGame.paused) + runPausedGame(); + + // 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 + mGameCounter++; + + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + } + + // Actualiza la lógica del juego + updatePlayField(); + } + + // Cambia el destino donde se pinta todo + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + renderPlayField(); + + // Vuelve a usar el renderizador como destino + SDL_SetRenderTarget(mRenderer, NULL); + + // Volca el contenido de la textura en el renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Actualiza la pantalla + if (mGame.status == GAME_STATE_PLAYING) + SDL_RenderPresent(mRenderer); + } +} + +// Bucle para el menu de pausa del juego +void GameDirector::runPausedGame() +{ + while (mGame.paused) + { + // 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) + { + setGameStatus(GAME_STATE_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 + mMenu.pause->update(); + } + + // Cambia el destino donde se pinta todo + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + // Dibuja los objetos + renderBackground(); + renderBalloons(); + renderBullets(); + mPlayer->render(); + renderScoreBoard(); + mMenu.pause->render(); + + // Vuelve a usar el renderizador como destino + SDL_SetRenderTarget(mRenderer, NULL); + + // Volca el contenido de la textura en el renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Actualiza la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba las entradas para el menu + checkMenuInput(mMenu.pause); + + // Comprueba si se ha seleccionado algún item del menú + switch (mMenu.pause->getItemSelected()) + { + case 0: + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + //setGameStatus(GAME_STATE_PLAYING); + mGame.paused = false; + mMenu.pause->reset(); + mMenuKeyPressed = false; + if (JA_GetMusicState() == JA_MUSIC_PAUSED) + { + JA_ResumeMusic(); + } + break; + case 1: + JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound); + setGameStatus(GAME_STATE_TITLE); + mMenu.pause->reset(); + mMenuKeyPressed = false; + JA_StopMusic(); + renderFade(1); + init(true); + break; + default: + break; + } + } +} + +// Bucle para la pantalla de instrucciones +void GameDirector::runInstructions() +{ + SDL_Rect window = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT}; + Sprite *sprite = new Sprite(); + SDL_Rect rect1 = {60, 88, 16, 16}; + SDL_Rect rect2 = {60, 104, 16, 16}; + SDL_Rect rect3 = {60, 120, 16, 16}; + SDL_Rect rect4 = {60, 136, 16, 16}; + SDL_Rect rect5 = {60, 152, 16, 16}; + SDL_Rect rect6 = {60, 168, 16, 16}; + SDL_Rect rect = {0, 0, 16, 16}; + + sprite->init(rect1, mTexture[TEXTURE_ITEMS].texture, mRenderer); + while (mGame.status == GAME_STATE_INSTRUCTIONS) + { + int y = 0; + // 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) + { + setGameStatus(GAME_STATE_QUIT); + break; + } + + if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN)) + { + JA_StopMusic(); + setGameStatus(GAME_STATE_TITLE); + } + } + + // Pinta en la surface el texto y los sprites + SDL_SetRenderTarget(mRenderer, mInstructionsSurface); + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); + SDL_RenderClear(mRenderer); + mText.white->writeCentered(SCREEN_CENTER_X, 8, "OBJECTIVE", 0); + mText.white->writeCentered(SCREEN_CENTER_X, 24, "YOU HAVE TO POP AS MANY", 0); + mText.white->writeCentered(SCREEN_CENTER_X, 34, "BALLOONS AS YOU CAN", 0); + mText.white->writeCentered(SCREEN_CENTER_X, 48, "DIFFICULTY WILL BE INCREASED", 0); + mText.white->writeCentered(SCREEN_CENTER_X, 58, "AS YOU SCORE POINTS", 0); + mText.white->writeCentered(SCREEN_CENTER_X, 75, "ITEMS", 0); + mText.white->write(84, 92, "1.000 POINTS", 0); + mText.white->write(84, 108, "2.500 POINTS", 0); + mText.white->write(84, 124, "5.000 POINTS", 0); + mText.white->write(84, 140, "TIME STOPPER", 0); + mText.white->write(84, 156, "FOUR EXPLOSIONS", 0); + mText.white->write(84, 172, "EXTRA HIT", 0); + + sprite->init(rect1, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x += rect.w; + rect.y = 16 * (((mInstructionsCounter + 3) / 36) % 2); + sprite->render(); + sprite->init(rect2, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x += rect.w; + rect.y = 16 * (((mInstructionsCounter + 6) / 36) % 2); + sprite->render(); + sprite->init(rect3, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x += rect.w; + rect.y = 16 * (((mInstructionsCounter + 9) / 36) % 2); + sprite->render(); + sprite->init(rect4, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x += rect.w; + rect.y = 16 * (((mInstructionsCounter + 12) / 36) % 2); + sprite->render(); + sprite->init(rect5, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x += rect.w; + rect.y = 16 * (((mInstructionsCounter + 15) / 36) % 2); + sprite->render(); + sprite->init(rect6, mTexture[TEXTURE_ITEMS].texture, mRenderer); + sprite->setSpriteClip(rect); + rect.x = 0; + rect.y = 16 * (((mInstructionsCounter + 0) / 36) % 2); + sprite->render(); + + SDL_SetRenderTarget(mRenderer, nullptr); + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + y = SCREEN_HEIGHT - (INSTRUCTIONS_COUNTER - mInstructionsCounter) + 100; + if (y < 0) + { + y = 0; + } + + window.y = y; + SDL_RenderCopy(mRenderer, mInstructionsSurface, NULL, &window); + + // Muestra la pantalla + SDL_RenderPresent(mRenderer); + + mInstructionsCounter--; + + if (mInstructionsCounter == 0) + { + mInstructionsCounter = INSTRUCTIONS_COUNTER; + setGameStatus(GAME_STATE_TITLE); + } + } + delete sprite; +} + +// Bucle para la pantalla de game over +void GameDirector::runGameOverScreen() +{ + while (mGame.status == GAME_STATE_GAME_OVER_SCREEN) + { + // 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) + { + setGameStatus(GAME_STATE_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 + mMenu.gameOver->update(); + } + + // Cambia el destino donde se pinta todo + SDL_SetRenderTarget(mRenderer, mBackbuffer); + + // Limpia la pantalla + SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0xFF); + SDL_RenderClear(mRenderer); + + // Dibuja los objetos + renderScoreBoard(); + mText.white->write(PLAY_AREA_CENTER_X - (mText.white->lenght("GAME OVER", 0) / 2), PLAY_AREA_CENTER_Y - BLOCK, "GAME OVER", 0); + mText.white->write(PLAY_AREA_CENTER_X - (mText.white->lenght("RETRY?", 0) / 2), PLAY_AREA_CENTER_Y + BLOCK * 2, "RETRY?", 0); + mMenu.gameOver->render(); + + // Vuelve a usar el renderizador como destino + SDL_SetRenderTarget(mRenderer, NULL); + + // Volca el contenido de la textura en el renderizador + SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL); + + // Muestra la pantalla + SDL_RenderPresent(mRenderer); + + // Comprueba las entradas para el menu + checkMenuInput(mMenu.gameOver); + + // Comprueba si se ha seleccionado algún item del menú + switch (mMenu.gameOver->getItemSelected()) + { + case 0: + setGameStatus(GAME_STATE_PLAYING); + mMenu.gameOver->reset(); + mMenuKeyPressed = false; + JA_PlaySound(mSound[SOUND_MENU_SELECT].sound); + JA_StopMusic(); + init(true); + renderFade(1); + disableDemoMode(); + break; + case 1: + setGameStatus(GAME_STATE_TITLE); + mMenu.gameOver->reset(); + mMenuKeyPressed = false; + JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound); + JA_StopMusic(); + init(true); + renderFade(1); + mTiteNextGS = GAME_STATE_PLAYING; + enableDemoMode(); + break; + default: + break; + } + } +} + +// Dibuja la informacion de debug en pantalla +void GameDirector::renderDebugInfo() +{ + if (mDebug) + { + mText.white->write(0, 0 * BLOCK, "menace: " + std::to_string(mMenaceLevelThreshold) + "/" + std::to_string(mMenaceLevel)); + mText.white->write(0, 1 * BLOCK, "item[0].TTL: " + std::to_string(mItem[0]->mTimeToLive)); + mText.white->write(0, 2 * BLOCK, "mGame.stage: " + std::to_string(mGame.stage)); + mText.white->write(0, 3 * BLOCK, "mGameCounter : " + std::to_string(mGameCounter)); + mText.white->write(0, 4 * BLOCK, ": "); + mText.white->write(0, 5 * BLOCK, ": "); + } +} + +// Activa el modo Demo +void GameDirector::enableDemoMode() +{ + mDemo = true; + mGetReadyBitmap->setEnabled(false); +} + +// Desactiva el modo Demo +void GameDirector::disableDemoMode() +{ + mDemo = false; + mGetReadyBitmap->setEnabled(true); +} + +// Actualiza el proximo estado del juego despues del titulo +void GameDirector::toogleTitleNextGS() +{ + if (mTiteNextGS == GAME_STATE_LOGO) + { + mTiteNextGS = GAME_STATE_PLAYING; + } + else + { + mTiteNextGS = GAME_STATE_LOGO; + } +} \ No newline at end of file diff --git a/source/gamedirector.h b/source/gamedirector.h new file mode 100644 index 0000000..a2b5b43 --- /dev/null +++ b/source/gamedirector.h @@ -0,0 +1,549 @@ +#pragma once +#include "ifdefs.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 "text2.h" +#include "menu.h" +#include "const.h" +#include "jail_audio.h" +#include + +#ifndef GAMEDIRECTOR_H +#define GAMEDIRECTOR_H + +// GameDirector +class GameDirector +{ +public: + // Constructor + GameDirector(); + + // Destructor + ~GameDirector(); + + // Iniciador + void init(bool reset); + + // Arranca SDL y crea la ventana + bool initSDL(); + + // Crea el indice de ficheros + void setFileList(); + + // Comprueba que todos los ficheros existen + bool checkFileList(); + + // Carga un archivo de imagen en una textura + bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer); + + // Carga los recursos necesarios + bool loadMedia(Uint8 section); + + // Descrga los recursos necesarios + bool unLoadMedia(Uint8 section); + + // Establece el valor de la variable + void setExecutablePath(std::string path); + + // Establece el valor de la variable + void setScore(Uint32 score); + + // 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 el valor de la variable mStage + void updateStage(); + + // Actualiza el estado de muerte + void updateDeath(); + + // Renderiza el fade final cuando se acaba la partida + void renderDeathFade(); + + // Mueve todos los globos activos + void moveBalloons(); + + // Pinta en pantalla todos los globos activos + void renderBalloons(); + + // Devuelve el primer indice no activo del vector de globos + Uint8 getBallonFreeIndex(); + + // Crea un globo nuevo en el vector de globos + Uint8 createNewBalloon(float x, int y, Uint8 kind, float velx, Uint16 stoppedtimer, LTexture *texture); + + // Establece a cero todos los valores del vector de objetos globo + void resetBalloons(); + + // Explosiona un globo. Lo destruye y crea otros dos si es el caso + void popBalloon(Uint8 index); + + // Explosiona todos los globos + void popAllBallons(); + + // 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 checkPlayerBallonCollision(); + + // Comprueba la colisión entre el jugador y los items + void checkPlayerItemCollision(); + + // Comprueba la colisión entre las balas y los globos + void checkBulletBallonCollision(); + + // 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); + + // 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); + + // 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); + + // 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(); + + // Calcula y establece el valor de amenaza en funcion de los globos activos + void calculateMenaceLevel(); + + // Obtiene el valor de la variable + Uint8 getMenaceLevel(); + + // Obtiene el valor de la variable + bool isPlayFieldDrawOnly(); + + // Establece el valor de la variable + void setPlayFieldDrawOnly(bool state); + + // 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 setTimeStoppedTimer(Uint16 value); + + // Actualiza y comprueba el valor de la variable + void updateTimeStoppedTimer(); + + // 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 updateRemainingExplosionsTimer(); + + // Gestiona el nivel de amenaza + void checkMenaceLevel(); + + // 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(); + + // Gestiona la entrada de teclado y mando durante el menu + void checkMenuInput(Menu *menu); + + // Obtiene el valor de la variable + Uint8 getGameStatus(); + + // Establece el valor de la variable + void setGameStatus(Uint8 status); + + // Pinta una transición en pantalla + void renderFade(Uint8 index); + + // 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(); + + // Cambia el valor de la variable de modo de pantalla completa + void changeFullScreenMode(); + + // Actualiza los elementos del menu de opciones + void updateOptionsMenu(); + + // Agita la pantalla + void shakeScreen(); + + // Bucle para el logo del juego + void runLogo(); + + // Bucle para la intro del juego + void runIntro(); + + // Bucle para el titulo del juego + void runTitle(); + + // Bucle para el juego + void runGame(); + + // Bucle para el menu de pausa del juego + void runPausedGame(); + + // Bucle para la pantalla de instrucciones + void runInstructions(); + + // Bucle para la pantalla de game over + void runGameOverScreen(); + + // Dibuja la informacion de debug en pantalla + void renderDebugInfo(); + + // Activa el modo Demo + void enableDemoMode(); + + // Desactiva el modo Demo + void disableDemoMode(); + + // Intercambia el proximo estado del juego despues del titulo + void toogleTitleNextGS(); + +private: + // La ventana donde dibujamos + SDL_Window *mWindow; + + // El renderizador de la ventana + SDL_Renderer *mRenderer; + + // Texturas donde dibujar + SDL_Texture *mBackbuffer; + SDL_Texture *mTitleSurface; + SDL_Texture *mInstructionsSurface; + + // Manejador para el mando 1 + SDL_Joystick *mGameController; + bool mGameControllerFound; + SDL_Haptic *mControllerHaptic; + + // Datos del fichero + Uint32 mScoreDataFile[TOTAL_SCORE_DATA]; + DemoKeys mDemoDataFile[TOTAL_DEMO_DATA]; + + // Manejador de eventos + SDL_Event *mEventHandler; + + // El jugador + Player *mPlayer; + + // Vector con los objetos globo + Balloon *mBalloon[MAX_BALLOONS]; + + // Vector con los objetos bala + Bullet *mBullet[MAX_BULLETS]; + + // Vector con los objetos item + Item *mItem[MAX_ITEMS]; + + // Fondo del juego + Sprite *mGameBackgroundFront; + Sprite *mGameBackgroundSky; + MovingSprite *mGBClouds1; + MovingSprite *mGBClouds1b; + MovingSprite *mGBClouds2; + MovingSprite *mGBClouds2b; + Sprite *mGrass; + + // Instrucciones + Sprite *mInstructions; + + // Fondo de la pantalla de titulo + Sprite *mTitleTile; + + // Ventana visible de la textura de fondo del titulo + SDL_Rect mBackgroundWindow; + + // Vector con los valores del seno para 360 grados + double mSen[360]; + + // Texto + struct text + { + Text *white; + Text *black; + Text *nokia; + }; + + text mText; + + // Variable con lkos menus del juego + struct menu + { + Menu *title; // Menu de la pantalla de título + Menu *pause; // Menú de la pantalla de pausa + Menu *gameOver; // Menú de la pantalla de game over + Menu *options; // Menú de la pantalla de opciones + Menu *active; // Menu activo (de momento para la pantalla del titulo) + }; + + menu mMenu; + + // Notificación GetReady! + SmartSprite *mGetReadyBitmap; + + // Dibujos de la intro + SmartSprite *mIntroBitmap[INTRO_TOTAL_BITMAPS]; + + // Sprites con el titulo del juego para la pantalla de titulo + SmartSprite *mCoffeeBitmap; + SmartSprite *mCrisisBitmap; + AnimatedSprite *mDustSpriteLeft; + AnimatedSprite *mDustSpriteRight; + + // Sprites con los puntos de algunos objetos + SmartSprite *m1000Bitmap; + SmartSprite *m2500Bitmap; + SmartSprite *m5000Bitmap; + + // Vector para almacenar y gestionar SmartSprites + SmartSprite *mSmartSprite[MAX_SMART_SPRITES]; + + // Textos de la intro + Text2 *mIntroText[INTRO_TOTAL_TEXTS]; + + // Vector para coordinar los eventos de la intro + Uint8 mIntroEvents[INTRO_TOTAL_EVENTS]; + + // Vector para coordinar los eventos de la pantalla de titulo + Uint8 mTitleEvents[TITLE_TOTAL_EVENTS]; + + // Indicador para el bucle del titulo + Uint8 mTitleStatus; + + struct game + { + Uint32 score; // Puntuación actual + Uint32 hiScore; // Puntuación máxima + Uint8 status; // Indicador para el bucle principal + bool paused; // Idica si el juego está en pausa + bool hiScoreAchieved; // Indica si se ha superado la puntuación máxima + Uint8 stage; // Pantalla actual + Uint8 stageCounter; // Contador para el tiempo visible del texto de Stage + double stagePath[STAGE_COUNTER]; // Vector con los puntos Y por donde pasará la etiqueta + Uint16 deathCounter; // Contador para la animación de muerte del jugador + Uint8 deathIndex; // Indice del vector de smartsprites que contiene el sprite del jugador + }; + + game mGame; + + // Contador de ticks para ajustar la velocidad del juego + Uint32 mTicks; + + // Velocidad a la que se repite el bucle de juego + Uint8 mTicksSpeed; + + // Nivel de amenaza actual + Uint8 mMenaceLevel; + + // 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 + Uint8 mMenaceLevelThreshold; + + // Indica si el bucle de juego avanza o solo pinta + bool mPlayFieldDrawOnly; + + // Indica si se va a mostrar la información de debug + bool mDebug; + + // Almacena los códigos de teclado correspondientes + Input mKeyboard; + + // Buffer para teclas pulsadas + Input mKeyboardBuffer; + + // Indica si el tiempo está detenido + bool mTimeStopped; + + // Temporizador para llevar la cuenta del tiempo detenido + Uint16 mTimeStoppedTimer; + + // Cantidad de explosiones restantes + Uint8 mRemainingExplosions; + + // Temporizador para la cantidad de explosiones restantes + Uint16 mRemainingExplosionsTimer; + + // Indica si las explosiones estan en marcha + bool mExplosionTime; + + // Contador para las instrucciones + Uint16 mInstructionsCounter; + + // Temporizador para la pantalla de titulo + Uint16 mTitleTimer; + + // Temporizador para el fondo de tiles de la pantalla de titulo + Uint16 mTitleBackgroundTimer; + + // Variable para almacenar el tipo de efecto que hará el foindo del titulo + Uint8 mTitleBackgroundMode; + + // Indicador para saber si se muestra el menu del titulo o la frase intermitente + bool mTitleMenuVisible; + + // Indica si está activo el modo demo + bool mDemo; + + // Indica si está activado el modo para grabar la demo + bool mDemoRecording; + + // Contador para el modo demo + Uint16 mDemoCounter; + DemoKeys mDemoKeys; + + // Indica a que estado pasara el juego cuando acabe el temporizador del titulo + Uint8 mTiteNextGS; + + // Contador para el juego + Uint32 mGameCounter; + + // Variable para evitar la repetición de teclas en los menus + bool mMenuKeyPressed; + + // Variables para el tamaño y modo de la ventana y variables para almacenar el valor si cancelamos en el menu de opciones + Uint32 mFullScreenMode; + Uint32 mFullScreenModePrevious; + Uint8 mWindowSize; + Uint8 mWindowSizePrevious; + + // Variables para el logo + struct logo + { + Uint16 counter; + Sprite *sprite; + }; + logo mLogo; + + // Path del ejecutable + std::string mExecutablePath; + + // Recursos + struct resourceBinFile + { + std::string file; + bool loaded; + }; + + resourceBinFile mBinFile[TOTAL_BINFILE]; + + struct resourceSound + { + std::string file; + bool loaded; + JA_Sound sound; + }; + + resourceSound mSound[TOTAL_SOUND]; + + struct resourceMusic + { + std::string file; + bool loaded; + JA_Music music; + }; + + resourceMusic mMusic[TOTAL_MUSIC]; + + struct resourceTexture + { + std::string file; + bool loaded; + LTexture *texture; + }; + + resourceTexture mTexture[TOTAL_TEXTURE]; +}; + +#endif diff --git a/source/ifdefs.h b/source/ifdefs.h new file mode 100644 index 0000000..c0a80c0 --- /dev/null +++ b/source/ifdefs.h @@ -0,0 +1,15 @@ +#ifdef _WIN64 +#include "C:\mingw_dev_lib\include\SDL2\SDL.h" +#endif + +#ifdef _WIN32 +#include "C:\mingw_dev_lib\include\SDL2\SDL.h" +#endif + +#ifdef __APPLE__ +#include "/Library/Frameworks/SDL2.framework/Versions/A/Headers/SDL.h" +#endif + +#ifdef __linux__ +#include "/usr/include/SDL2/SDL.h" +#endif \ No newline at end of file diff --git a/source/item.cpp b/source/item.cpp new file mode 100644 index 0000000..427620f --- /dev/null +++ b/source/item.cpp @@ -0,0 +1,264 @@ +#include "const.h" +#include "item.h" + +// Constructor +Item::Item() +{ + mSprite = new AnimatedSprite(); + init(NO_KIND, 0, 0, nullptr, nullptr); +} + +// Destructor +Item::~Item() +{ + init(NO_KIND, 0, 0, nullptr, nullptr); + delete mSprite; +} + +// Iniciador +void Item::init(Uint8 value, float x, float y, LTexture *texture, SDL_Renderer *renderer) +{ + mClass = value; + mEnabled = true; + mTimeToLive = 600; + mPosX = x; + mPosY = y; + mWidth = 16; + mHeight = 16; + mVelX = -1.0f + ((rand() % 5) * 0.5f); + mVelY = -4.0f; + mAccelX = 0.0f; + mAccelY = 0.2f; + mCollider.r = mWidth / 2; + shiftColliders(); + + mSprite->init(texture, renderer); + mSprite->setAnimationFrames(0, 0, 0, 48, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 0, 64, mWidth, mHeight); + mSprite->setCurrentFrame(0); + mSprite->setAnimationCounter(0); + mSprite->setAnimationNumFrames(0, 2); + mSprite->setAnimationSpeed(0, 10); + mSprite->setAnimationLoop(0, true); + mSprite->setSpriteClip(mSprite->getAnimationClip(0, 0)); + + switch (value) + { + case NO_KIND: + mEnabled = false; + mTimeToLive = 0; + mPosX = 0; + mPosY = 0; + mWidth = 0; + mHeight = 0; + mVelX = 0; + mVelY = 0; + break; + case ITEM_POINTS_1_DISK: + mSprite->setAnimationFrames(0, 0, 16 * 0, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 0, 16 * 1, mWidth, mHeight); + break; + case ITEM_POINTS_2_GAVINA: + mSprite->setAnimationFrames(0, 0, 16 * 1, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 1, 16 * 1, mWidth, mHeight); + break; + case ITEM_POINTS_3_PACMAR: + mSprite->setAnimationFrames(0, 0, 16 * 2, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 2, 16 * 1, mWidth, mHeight); + break; + case ITEM_CLOCK: + mSprite->setAnimationFrames(0, 0, 16 * 3, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 3, 16 * 1, mWidth, mHeight); + break; + case ITEM_TNT: + mSprite->setAnimationFrames(0, 0, 16 * 4, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 4, 16 * 1, mWidth, mHeight); + break; + case ITEM_COFFEE: + mSprite->setAnimationFrames(0, 0, 16 * 5, 16 * 0, mWidth, mHeight); + mSprite->setAnimationFrames(0, 1, 16 * 5, 16 * 1, mWidth, mHeight); + break; + default: + break; + } +} + +// Centra el globo en la posición X +void Item::allignTo(int x) +{ + mPosX = float(x - (mWidth / 2)); + + if (mPosX < PLAY_AREA_LEFT) + { + mPosX = PLAY_AREA_LEFT + 1; + } + else if ((mPosX + mWidth) > PLAY_AREA_RIGHT) + { + mPosX = float(PLAY_AREA_RIGHT - mWidth - 1); + } + + // Posición X,Y del sprite + mSprite->setPosX(int(mPosX)); + mSprite->setPosY(int(mPosY)); + + // Alinea el circulo de colisión con el objeto + shiftColliders(); +} + +// Pinta el globo en la pantalla +void Item::render() +{ + if (mEnabled) + { + if (mTimeToLive > 200) + { + mSprite->render(); + } + else if (mTimeToLive % 20 > 10) + { + mSprite->render(); + } + } +} + +// Actualiza la posición y estados del globo +void Item::move() +{ + // Calcula la nueva posición + mPosX += mVelX; + mPosY += mVelY; + + // Aplica las aceleraciones a la velocidad + mVelX += mAccelX; + mVelY += mAccelY; + + // Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido + if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT)) + { + // Corregir posición + mPosX -= mVelX; + + // Invertir sentido + mVelX = -mVelX; + } + + // Si se sale por arriba + if (mPosY < PLAY_AREA_TOP) + { + // Corrige + mPosY = PLAY_AREA_TOP; + + // Invierte el sentido + mVelY = -mVelY; + } + + // Si el objeto se sale por la parte inferior + if (mPosY + mHeight > PLAY_AREA_BOTTOM) + { + // Corrige + mPosY -= mVelY; + + // Detiene el objeto + mVelY = 0; + mVelX = 0; + mAccelX = 0; + mAccelY = 0; + mPosY = PLAY_AREA_BOTTOM - mHeight; + } + + // Actualiza la posición del sprite + mSprite->setPosX(int(mPosX)); + mSprite->setPosY(int(mPosY)); +} + +// Pone a cero todos los valores del objeto +void Item::erase() +{ + init(NO_KIND, 0, 0, nullptr, nullptr); +} + +// Actualiza el objeto a su posicion, animación y controla los contadores +void Item::update() +{ + if (mEnabled) + { + move(); + shiftColliders(); + mSprite->animate(0); + updateTimeToLive(); + checkTimeToLive(); + } +} + +// Actualiza el contador +void Item::updateTimeToLive() +{ + if (mTimeToLive > 0) + { + --mTimeToLive; + } +} + +// Comprueba si el objeto sigue vivo +void Item::checkTimeToLive() +{ + if (mTimeToLive == 0) + { + erase(); + } +} + +// Obtiene del valor de la variable +float Item::getPosX() +{ + return mPosX; +} + +// Obtiene del valor de la variable +float Item::getPosY() +{ + return mPosY; +} + +// Obtiene del valor de la variable +int Item::getWidth() +{ + return mWidth; +} + +// Obtiene del valor de la variable +int Item::getHeight() +{ + return mHeight; +} + +// Obtiene del valor de la variable +int Item::getClass() +{ + return mClass; +} + +// Obtiene el valor de la variable +bool Item::isEnabled() +{ + return mEnabled; +} + +// Establece el valor de la variable +void Item::setEnabled(bool value) +{ + mEnabled = value; +} + +// Obtiene el circulo de colisión +Circle &Item::getCollider() +{ + return mCollider; +} + +// Alinea el circulo de colisión con la posición del objeto +void Item::shiftColliders() +{ + mCollider.x = Uint16(mPosX + mCollider.r); + mCollider.y = Uint16(mPosY + mCollider.r); +} \ No newline at end of file diff --git a/source/item.h b/source/item.h new file mode 100644 index 0000000..2f0706a --- /dev/null +++ b/source/item.h @@ -0,0 +1,105 @@ +#pragma once +#include "ifdefs.h" +#include "animatedsprite.h" +#include "struct.h" + +#ifndef ITEM_H +#define ITEM_H + +// Clase AnimatedSprite +class Item +{ +public: + // Constructor + Item(); + + // Destructor + ~Item(); + + // Iniciador + void init(Uint8 value, float x, float y, LTexture* texture, SDL_Renderer *renderer); + + // Centra el objeto en la posición X + void allignTo(int x); + + // Pinta el objeto en la pantalla + void render(); + + // Actualiza la posición y estados del objeto + void move(); + + // Pone a cero todos los valores del objeto + void erase(); + + // Actualiza al objeto a su posicion, animación y controla los contadores + void update(); + + // Actualiza el contador + void updateTimeToLive(); + + // Comprueba si el objeto sigue vivo + void checkTimeToLive(); + + // Obtiene del valor de la variable + float getPosX(); + + // Obtiene del valor de la variable + float getPosY(); + + // Obtiene del valor de la variable + int getWidth(); + + // Obtiene del valor de la variable + int getHeight(); + + // Obtiene del valor de la variable + int getClass(); + + // Obtiene el valor de la variable + bool isEnabled(); + + // Establece el valor de la variable + void setEnabled(bool value); + + // Obtiene el circulo de colisión + Circle &getCollider(); + + // Temporizador con el tiempo que el objeto está presente + Uint16 mTimeToLive; + +private: + // Posición X,Y del objeto + float mPosX; + float mPosY; + + // Alto y ancho del objeto + Uint8 mWidth; + Uint8 mHeight; + + // Variables para controlar la velocidad del objeto + float mVelX; + float mVelY; + + // Aceleración + float mAccelX; + float mAccelY; + + // Sprite con los graficos del objeto + AnimatedSprite *mSprite; + + // Especifica el tipo de objeto que es + Uint8 mClass; + + // Especifica si está habilitado el objeto + bool mEnabled; + + + + // Circulo de colisión del objeto + Circle mCollider; + + // Alinea el circulo de colisión con la posición del objeto + void shiftColliders(); +}; + +#endif diff --git a/source/jail_audio.cpp b/source/jail_audio.cpp new file mode 100644 index 0000000..a4d379f --- /dev/null +++ b/source/jail_audio.cpp @@ -0,0 +1,213 @@ +#include "jail_audio.h" +#include "stb_vorbis.c" +//#include + +#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; +} + 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/ltexture.cpp b/source/ltexture.cpp new file mode 100644 index 0000000..3b44063 --- /dev/null +++ b/source/ltexture.cpp @@ -0,0 +1,165 @@ +#include +#include +#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 + free(); +} + +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 + free(); + + // 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::free() +{ + // 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, 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; + } + + // 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..3321666 --- /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 free(); + + // 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, 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..4d42b08 --- /dev/null +++ b/source/main.cpp @@ -0,0 +1,130 @@ +/* +This source code copyrighted by JailDesigner (2020) +started on Castalla 15-07-2020. +Using some sample source code from Lazy Foo' Productions +*/ + +/*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 +gamedirector es la que realiza toda la lógica y se encarga de hacer interactuar +al resto de objetos entre si. + +El objeto gamedirector tiene tres estados: titulo, juego y pausa. Segun su estado +el bucle que recorre es distinto. En el bucle juego, el objeto gamedirector +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 "ifdefs.h" +#include +#include +#include +#include "const.h" +#include "gamedirector.h" + +int main(int argc, char *args[]) +{ + // Inicia el generador de numeros aleatorios + srand(time(nullptr)); + + // Crea el objeto gameDirector + GameDirector *gameDirector = new GameDirector(); + + // Establece el valor de la variable con el path del ejecutable + gameDirector->setExecutablePath(args[0]); + + // Inicializa la lista de ficheros + gameDirector->setFileList(); + + // Comprueba que existen todos los ficheros + if (!gameDirector->checkFileList()) + { + return -1; + } + + // Arranca SDL y crea la ventana + if (!gameDirector->initSDL()) + { + printf("Failed to initialize!\n"); + return -1; + } + else + { + // Carga los recursos + if (!gameDirector->loadMedia(GAME_STATE_INIT)) + { + printf("Failed to load media!\n"); + } + else + { + // Inicializa el objeto gameDirector + gameDirector->init(false); + printf("Starting the game...\n\n"); + + // Mientras no se quiera salir del juego + while (!(gameDirector->getGameStatus() == GAME_STATE_QUIT)) + { + switch (gameDirector->getGameStatus()) + { + case GAME_STATE_LOGO: + gameDirector->loadMedia(GAME_STATE_LOGO); + gameDirector->runLogo(); + gameDirector->unLoadMedia(GAME_STATE_LOGO); + break; + case GAME_STATE_INTRO: + gameDirector->loadMedia(GAME_STATE_INTRO); + gameDirector->runIntro(); + gameDirector->unLoadMedia(GAME_STATE_INTRO); + break; + case GAME_STATE_TITLE: + gameDirector->loadMedia(GAME_STATE_TITLE); + gameDirector->runTitle(); + gameDirector->unLoadMedia(GAME_STATE_TITLE); + break; + case GAME_STATE_PLAYING: + gameDirector->loadMedia(GAME_STATE_PLAYING); + gameDirector->runGame(); + gameDirector->unLoadMedia(GAME_STATE_PLAYING); + break; + case GAME_STATE_GAME_OVER_SCREEN: + gameDirector->loadMedia(GAME_STATE_GAME_OVER_SCREEN); + gameDirector->runGameOverScreen(); + gameDirector->unLoadMedia(GAME_STATE_GAME_OVER_SCREEN); + break; + case GAME_STATE_INSTRUCTIONS: + gameDirector->loadMedia(GAME_STATE_INSTRUCTIONS); + gameDirector->runInstructions(); + gameDirector->unLoadMedia(GAME_STATE_INSTRUCTIONS); + break; + } + } + } + + // Libera todos los recursos y cierra SDL + delete gameDirector; + printf("Shutting down the game...\n"); + + return 0; + } +} diff --git a/source/menu.cpp b/source/menu.cpp new file mode 100644 index 0000000..a7eefc2 --- /dev/null +++ b/source/menu.cpp @@ -0,0 +1,455 @@ +#include "ifdefs.h" +#include "const.h" +#include "text.h" +#include "menu.h" + +// Constructor +Menu::Menu() +{ + init("", 0, 0, 0, nullptr, nullptr, nullptr); +} + +Menu::~Menu() +{ + mRenderer = nullptr; + mText = nullptr; +} + +// Inicializador +void Menu::init(std::string name, int x, int y, int backgroundType, LTexture *texture, SDL_Renderer *renderer, Text *text) +{ + // Inicia variables + mName = name; + mSelector.index = 0; + mTotalItems = 0; + mItemSelected = MENU_NO_OPTION; + mVerticalPadding = 1; + 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; + mSelector.rect.x = 0; + mSelector.rect.y = 0; + mSelector.rect.w = 0; + mSelector.rect.h = 0; + mSelector.r = 0; + mSelector.g = 0; + mSelector.b = 0; + mSelector.a = 255; + mBackgroundType = backgroundType; + mText = text; + mRenderer = renderer; + mIsCentered = false; + mAreElementsCentered = false; + mCenter = x + ((SCREEN_WIDTH - x) / 2); + mWidestItem = 0; + + // Selector + mSelector.origin = 0; + mSelector.target = 0; + mSelector.y = 0; + mSelector.numJumps = 4; + mSelector.despY = 0; + mSelector.moving = false; + + // Sprite con los graficos del selector + //mSelectorSprite.setWidth(8); + //mSelectorSprite.setHeight(8); + //mSelectorSprite.setPosX(0); + //mSelectorSprite.setPosY(0); + //mSelectorSprite.setTexture(texture); + //mSelectorSprite.setRenderer(renderer); + //mSelectorSprite.setSpriteClip(0, 0, mSelectorSprite.getWidth(), mSelectorSprite.getHeight()); + + // Elementos del menu + for (int i = 0; i < 10; i++) + { + mItem[i].label = ""; + mItem[i].w = 0; + mItem[i].h = 0; + mItem[i].x = 0; + mItem[i].y = 0; + mItem[i].hPaddingUp = 0; + mItem[i].hPaddingDown = 0; + } + + // Mueve el grafico del selector al elemento seleccionado + //moveSelectorSprite(mSelector.index); +} + +// Obtiene el nombre del menu +std::string Menu::getName() +{ + return mName; +} + +// Obtiene el valor de la variable +Uint8 Menu::getItemSelected() +{ + return mItemSelected; +} + +// Mueve el grafico del selector al elemento seleccionado +/*void Menu::moveSelectorSprite(int pos) +{ + mSelector.rect.y = mItem[pos].y - 1; +}*/ + +// Actualiza la posicion y el estado del selector +void Menu::updateSelector() +{ + if (mSelector.moving) + { + mSelector.y += mSelector.despY; + if (mSelector.despY > 0) // Va hacia abajo + { + if (mSelector.y > mSelector.target) // Ha llegado al destino + { + mSelector.origin = mSelector.y = mSelector.target; + mSelector.moving = false; + } + } + if (mSelector.despY < 0) // Va hacia abajo + { + if (mSelector.y < mSelector.target) // Ha llegado al destino + { + mSelector.origin = mSelector.y = mSelector.target; + mSelector.moving = false; + } + } + mSelector.rect.y = int(mSelector.y) - 1; + } + else + { + mSelector.rect.y = int(mSelector.y) - 1; + } +} + +// Establece el origen del selector +void Menu::setSelectorOrigin(int value) +{ + mSelector.origin = value; +} + +// Establece el destino del selector +void Menu::setSelectorTarget(int value) +{ + mSelector.target = value; +} + +// Coloca el selector en una posición específica +void Menu::setSelectorPos(Uint8 index) +{ + if (index < mTotalItems) + { + mSelector.index = index; + mSelector.y = mSelector.origin = mSelector.target = mItem[mSelector.index].y; + mSelector.moving = 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 (Uint8 i = 0; i < mTotalItems; i++) + { + if (mItem[i].w > result) + { + result = mItem[i].w; + } + } + + return result; +} + +// Deja el menu apuntando al primer elemento +void Menu::reset() +{ + mItemSelected = MENU_NO_OPTION; + mSelector.index = 0; + //moveSelectorSprite(mSelector.index); + mSelector.origin = mSelector.target = mSelector.y = mItem[0].y; + mSelector.moving = false; +} + +// Deja el menu sin elemento seleccionado +void Menu::deselectItem() +{ + mItemSelected = MENU_NO_OPTION; +} + +// Actualiza el menu para recolocarlo correctamente y establecer el tamaño +void Menu::reorganize() +{ + setRectSize(); + if (mIsCentered) + centerMenu(mCenter); + if (mAreElementsCentered) + centerMenuElements(); +} + +// Deja el menu apuntando al siguiente elemento +bool Menu::increaseSelectorIndex() +{ + bool success = false; + mSelector.y = mSelector.origin = mItem[mSelector.index].y; + + if (mSelector.index < (mTotalItems - 1)) + { + mSelector.index++; + success = true; + } + + mSelector.target = mItem[mSelector.index].y; + mSelector.despY = (mSelector.target - mSelector.origin) / mSelector.numJumps; + mSelector.moving = true; + return success; +} + +// Deja el menu apuntando al elemento anterior +bool Menu::decreaseSelectorIndex() +{ + bool success = false; + mSelector.y = mSelector.origin = mItem[mSelector.index].y; + + if (mSelector.index > 0) + { + mSelector.index--; + success = true; + } + + mSelector.target = mItem[mSelector.index].y; + mSelector.despY = (mSelector.target - mSelector.origin) / mSelector.numJumps; + mSelector.moving = true; + return success; +} + +// Comprueba la entrada (teclado, gamepad) y actua en consecuencia +bool Menu::checkInput(Uint8 input) +{ + bool success = false; + switch (input) + { + case INPUT_UP: + success = decreaseSelectorIndex(); + //moveSelectorSprite(mSelector.index); + break; + case INPUT_DOWN: + success = increaseSelectorIndex(); + //moveSelectorSprite(mSelector.index); + break; + case INPUT_ACCEPT: + mItemSelected = mSelector.index; + break; + case INPUT_CANCEL: + mItemSelected = mDefaultActionWhenCancel; + break; + } + 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_SetRenderDrawColor(mRenderer, mSelector.r, mSelector.g, mSelector.b, mSelector.a); + SDL_RenderFillRect(mRenderer, &mSelector.rect); + + // Renderiza el sprite del selector + //mSelectorSprite.render(); + + // Renderitza el text + for (Uint8 i = 0; i < mTotalItems; i++) + { + if (i == mSelector.index) + { + mText->writeColored(mItem[i].x, mItem[i].y, mItem[i].label, mSelector.itemR, mSelector.itemG, mSelector.itemB); + } + else + { + mText->write(mItem[i].x, mItem[i].y, mItem[i].label, 0); + } + } +} + +// Establece el rectangulo de fondo del menu y el selector +void Menu::setRectSize() +{ + Uint8 i = 0; + mRectBG.rect.w = 0; + mRectBG.rect.h = 0; + mSelector.rect.w = 0; + mSelector.rect.h = 0; + + // Obtenemos la anchura del item mas ancho y la altura de la suma de alturas de los items + for (i = 0; i < mTotalItems; i++) + { + if (mItem[i].w > mRectBG.rect.w) + { + mRectBG.rect.w = mItem[i].w; + } + mRectBG.rect.h += mItem[i].h + mItem[i].hPaddingDown; + } + + // La anchura de la cadena más larga, mas un caracter, mas la anchura del sprite del selector + mRectBG.rect.w += (mText->getSize() * 1); // + mSelectorSprite.getWidth(); + + // La altura de la suma de los items mas un caracter y menos un pixel (porque el texto en realidad es de 7 pixeles) + mRectBG.rect.h += (mText->getSize() * 1) - 1; + + // La posición X es la del menú menos la anchura del sprite del selector y menos medio caracter + mRectBG.rect.x = mPosX - (mText->getSize() / 2); // - mSelectorSprite.getWidth(); + + // La posición Y es la del menu menos la altura de medio caracter i el padding + mRectBG.rect.y = mPosY - (mText->getSize() / 2) - mVerticalPadding; + + // Establecemos los valores del rectangulo del selector a partir de los valores del rectangulo de fondo + mSelector.rect.h = (mText->getSize() * 1) + 1; + mSelector.rect.w = mRectBG.rect.w; + mSelector.rect.x = mRectBG.rect.x; +} + +// Establece el valor de la variable +void Menu::setTotalItems(int num) +{ + mTotalItems = num; +} + +// 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 +void Menu::centerMenu(int value) +{ + mIsCentered = true; + mCenter = value; + + // Actualiza el rectangulo de fondo para recalcular las dimensiones + setRectSize(); + + // Obten el acho del menu + mWidestItem = getWidestItem(); + + // Establece la nueva posición centrada en funcion del elemento más ancho + mPosX = (value) - (mWidestItem / 2); + + // Reposiciona los elementos del menu + for (Uint8 i = 0; i < 10; i++) + { + mItem[i].x = mPosX; + } + + // Recalcula el rectangulo de fondo + setRectSize(); + + // Recoloca el selector + mSelector.origin = mSelector.target = mSelector.y = mItem[mSelector.index].y; + mSelector.moving = false; + //moveSelectorSprite(mSelector.index); +} + +// Centra los elementos del menu +void Menu::centerMenuElements() +{ + mAreElementsCentered = true; + + for (Uint8 i = 0; i < mTotalItems; i++) + { + //mItem[i].x = (mCenter - ((mText->lenght(mItem[i].label, 0)) / 2)); + mItem[i].x = (mCenter - (mItem[i].w / 2)); + } + + // Mueve el grafico del selector al elemento seleccionado + //moveSelectorSprite(mSelector.index); +} + +// Añade un item al menu +void Menu::addItem(std::string text, const Uint8 hPaddingUp, const Uint8 hPaddingDown) +{ + // Si es el primer item coge la posición y del propio menu + if (mTotalItems == 0) + { + mItem[mTotalItems].label = text; + mItem[mTotalItems].w = mText->lenght(mItem[mTotalItems].label, 0); + mItem[mTotalItems].h = mText->getSize() + (mVerticalPadding * 2); + mItem[mTotalItems].x = mPosX; + mItem[mTotalItems].y = mPosY; + mItem[mTotalItems].hPaddingUp = hPaddingUp; + mItem[mTotalItems].hPaddingDown = hPaddingDown; + } + else + { + // En caso contrario, coge la posición y a partir del elemento anterior + if (mTotalItems < 10) + { + mItem[mTotalItems].label = text; + mItem[mTotalItems].w = mText->lenght(mItem[mTotalItems].label, 0); + mItem[mTotalItems].h = mText->getSize() + (mVerticalPadding * 2); + mItem[mTotalItems].x = mPosX; + mItem[mTotalItems].y = mItem[mTotalItems - 1].y + mItem[mTotalItems - 1].h + mItem[mTotalItems - 1].hPaddingDown; + mItem[mTotalItems].hPaddingUp = hPaddingUp; + mItem[mTotalItems].hPaddingDown = hPaddingDown; + } + } + setTotalItems(mTotalItems + 1); + reorganize(); + setSelectorPos(0); +} + +// Cambia el texto de un item +void Menu::setItemCaption(Uint8 index, std::string text) +{ + mItem[index].label = text; + mItem[index].w = mText->lenght(mItem[index].label, 0); + reorganize(); +} + +// Establece el indice del itemm que se usará por defecto al cancelar el menu +void Menu::setDefaultActionWhenCancel(Uint8 item) +{ + mDefaultActionWhenCancel = item; +} diff --git a/source/menu.h b/source/menu.h new file mode 100644 index 0000000..3201c54 --- /dev/null +++ b/source/menu.h @@ -0,0 +1,190 @@ +#pragma once +#include "sprite.h" +#include "text.h" + +#ifndef MENU_H +#define MENU_H + +// Clase menu +class Menu +{ +public: + // Constructor + Menu(); + + // Destructor + ~Menu(); + + // Inicializador + void init(std::string name, int x, int y, int backgroundType, LTexture *texture, SDL_Renderer *renderer, Text *text); + + // 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(); + + // Deja el menu sin elemento seleccionado + void deselectItem(); + + // Comprueba la entrada (teclado, gamepad) y actua en consecuencia + bool checkInput(Uint8 input); + + // 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 + void centerMenu(int value); + + // Centra los elementos del menu + void centerMenuElements(); + + // Añade un item al menu + void addItem(std::string text, const Uint8 hPaddingUp = 0, const Uint8 hPaddingDown = 0); + + // 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); + +private: + // 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(); + + // Mueve el grafico del selector al elemento seleccionado + //void moveSelectorSprite(int pos); + + // Actualiza la posicion y el estado del selector + void updateSelector(); + + // Establece el origen del selector + void setSelectorOrigin(int value); + + // Establece el destino del selector + void setSelectorTarget(int value); + + // Coloca el selector en una posición específica + void setSelectorPos(Uint8 index); + + // Obtiene la anchura del elemento más ancho del menu + Uint16 getWidestItem(); + + // Posicion X/Y del texto del primer elemento del menu + int mPosX; // En esta posición se pinta la primera letra del primer elemento + int mPosY; + + // Nombre del menu + std::string mName; + + // Numero de items del menu + Uint8 mTotalItems; + + // Item del menu que ha sido seleccionado + Uint8 mItemSelected; + + // Item del menu seleccionado cuando se cancela el menu + Uint8 mDefaultActionWhenCancel; + + // Espacio de separacion entre items + Uint8 mVerticalPadding; + + // Tipo de fondo para el menu + Uint8 mBackgroundType; + + // Sprite con los graficos del selector + //Sprite mSelectorSprite; + + struct rectangle + { + SDL_Rect rect; + Uint8 r; // Rojo + Uint8 g; // Verde + Uint8 b; // Azul + Uint8 a; // Transparencia + }; + + rectangle mRectBG; // Rectangulo de fondo del menu + + // Estructura para cada elemento del menu + struct item + { + std::string label; + int x; + int y; + Uint8 w; + Uint8 h; + Uint8 hPaddingUp; + Uint8 hPaddingDown; + }; + + item mItem[10]; + + // Texto para poder escribir los items del menu + Text *mText; + + // Puntero al renderizador de la ventana + SDL_Renderer *mRenderer; + + // Variable para saber si el menu debe estar centrado respecto a un punto + bool mIsCentered; + + // Centro del menu + int mCenter; + + // Variable para saber si los elementos van centrados + bool mAreElementsCentered; + + // Anchura del elemento más ancho + Uint16 mWidestItem; + + struct selector + { + double origin; // Coordenada de origen + double target; // Coordenada de destino + double y; // Coordenada actual + Uint8 numJumps; // Numero de pasos preestablecido para llegar al destino + double despY; // (target - origin) / numJumps + bool moving; // Indica si el selector está avanzando hacia el destino + Uint8 index; // Elemento del menu que tiene el foco + SDL_Rect rect; + Uint8 r; // Rojo + Uint8 g; // Verde + Uint8 b; // Azul + Uint8 a; // Transparencia + Uint8 itemR; // Rojo + Uint8 itemG; // Verde + Uint8 itemB; // Azul + }; + + selector mSelector; +}; + +#endif diff --git a/source/movingsprite.cpp b/source/movingsprite.cpp new file mode 100644 index 0000000..8954677 --- /dev/null +++ b/source/movingsprite.cpp @@ -0,0 +1,132 @@ +#include "const.h" +#include "movingsprite.h" +#include + +// Constructor +MovingSprite::MovingSprite() +{ + init(0, 0, 0, 0, 0, 0, 0, 0, nullptr, nullptr); +} + +// Destructor +MovingSprite::~MovingSprite() +{ + init(0, 0, 0, 0, 0, 0, 0, 0, nullptr, nullptr); +} + +// 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 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() +{ + mPosX += mVelX; + mPosY += mVelY; + + mVelX += mAccelX; + mVelY += mAccelY; +} + +// Muestra el sprite por pantalla +void MovingSprite::render() +{ + mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip); +} + +// Establece el valor de la variable +float MovingSprite::getPosX() +{ + return mPosX; +} + +// Establece el valor de la variable +float MovingSprite::getPosY() +{ + return mPosY; +} + +// Establece el valor de la variable +float MovingSprite::getVelX() +{ + return mVelX; +} + +// Establece el valor de la variable +float MovingSprite::getVelY() +{ + return mVelY; +} + +// Establece el valor de la variable +float MovingSprite::getAccelX() +{ + return mAccelX; +} + +// Establece el valor de la variable +float MovingSprite::getAccelY() +{ + return mAccelY; +} + +// 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; +} \ No newline at end of file diff --git a/source/movingsprite.h b/source/movingsprite.h new file mode 100644 index 0000000..f4bdcd6 --- /dev/null +++ b/source/movingsprite.h @@ -0,0 +1,77 @@ +#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 +{ +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(); + + // 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(); + + // 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); + +private: + // Posición + float mPosX; + float mPosY; + + // Velocidad + float mVelX; + float mVelY; + + // Aceleración + float mAccelX; + float mAccelY; +}; + +#endif diff --git a/source/player.cpp b/source/player.cpp new file mode 100644 index 0000000..a0f86d4 --- /dev/null +++ b/source/player.cpp @@ -0,0 +1,751 @@ +#include "const.h" +#include "player.h" + +// Constructor +Player::Player() +{ + mSpriteLegs = new AnimatedSprite(); + mSpriteBody = new AnimatedSprite(); + init(0, 0, nullptr, nullptr, nullptr); +} + +// Destructor +Player::~Player() +{ + init(0, 0, nullptr, nullptr, nullptr); + mSpriteLegs = nullptr; + mSpriteBody = nullptr; + delete mSpriteLegs; + delete mSpriteBody; +} + +// Iniciador +void Player::init(float x, int y, LTexture *textureLegs, LTexture *textureBody, SDL_Renderer *renderer) +{ + // Inicializa variables de estado + mAlive = true; + mStatusWalking = PLAYER_STATUS_WALKING_STOP; + mStatusFiring = PLAYER_STATUS_FIRING_NO; + mInvulnerable = false; + mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER; + mExtraHit = false; + + // Establece la altura y el ancho del jugador + mWidth = 3 * BLOCK; + mHeight = 3 * BLOCK; + + // Establece la posición inicial del jugador + mPosX = x; + mPosY = y; + + // Establece el tamaño del circulo de colisión + mCollider.r = 7; + + // Actualiza la posición del circulo de colisión + shiftColliders(); + + // Establece la velocidad inicial + mVelX = 0; + mVelY = 0; + + // Establece la velocidad base + mBaseSpeed = 1.5; + + // Establece el numero inicial de vidas + mStartingLives = 3; + mLives = mStartingLives; + + // Establece la puntuación inicial + mScore = 0; + + // Establece el multiplicador de puntos inicial + mScoreMultiplier = 1.0f; + + // Inicia el contador para la cadencia de disparo + mCooldown = 10; + + // Inicia el sprite + mSpriteLegs->init(textureLegs, renderer); + mSpriteBody->init(textureBody, renderer); + + // Establece el alto y ancho del sprite + mSpriteLegs->setWidth(mWidth); + mSpriteLegs->setHeight(mHeight); + + mSpriteBody->setWidth(mWidth); + mSpriteBody->setHeight(mHeight); + + // Establece la posición del sprite + mSpriteLegs->setPosX(int(mPosX)); + mSpriteLegs->setPosY(mPosY); + + mSpriteBody->setPosX(int(mPosX)); + mSpriteBody->setPosY(mPosY); + + // Inicializa las variables para la animación + mSpriteLegs->setCurrentFrame(0); + mSpriteLegs->setAnimationCounter(0); + + mSpriteBody->setCurrentFrame(0); + mSpriteBody->setAnimationCounter(0); + + // Establece el numero de frames de cada animacion + mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 4); + mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 4); + mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 4); + + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 4); + mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 4); + + // Establece la velocidad de cada animación + mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_STOP, 10); + mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 5); + mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 5); + + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_LEFT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_LEFT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_STOP, 10); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_UP, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 5); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 10); + mSpriteBody->setAnimationSpeed(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 5); + + // Establece si la animación se reproduce en bucle + mSpriteLegs->setAnimationLoop(PLAYER_ANIMATION_LEGS_WALKING_STOP, true); + mSpriteLegs->setAnimationLoop(PLAYER_ANIMATION_LEGS_WALKING_LEFT, true); + mSpriteLegs->setAnimationLoop(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, true); + + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_LEFT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_LEFT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_RIGHT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_RIGHT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_STOP, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_UP, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, true); + mSpriteBody->setAnimationLoop(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, true); + + // Establece los frames de cada animación + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 0, mWidth * 0, mHeight * 0, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 1, mWidth * 1, mHeight * 0, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 2, mWidth * 2, mHeight * 0, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 3, mWidth * 3, mHeight * 0, mWidth, mHeight); + + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 0, mWidth * 0, mHeight * 1, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 1, mWidth * 1, mHeight * 1, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 2, mWidth * 2, mHeight * 1, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 3, mWidth * 3, mHeight * 1, mWidth, mHeight); + + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 0, mWidth * 0, mHeight * 2, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 1, mWidth * 1, mHeight * 2, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 2, mWidth * 2, mHeight * 2, mWidth, mHeight); + mSpriteLegs->setAnimationFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 3, mWidth * 3, mHeight * 2, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 0, mWidth * 0, mHeight * 0, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 1, mWidth * 1, mHeight * 0, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 2, mWidth * 2, mHeight * 0, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 3, mWidth * 3, mHeight * 0, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 0, mWidth * 0, mHeight * 1, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 1, mWidth * 1, mHeight * 1, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 2, mWidth * 2, mHeight * 1, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 3, mWidth * 3, mHeight * 1, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 0, mWidth * 0, mHeight * 2, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 1, mWidth * 1, mHeight * 2, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 2, mWidth * 2, mHeight * 2, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 3, mWidth * 3, mHeight * 2, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 0, mWidth * 0, mHeight * 3, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 1, mWidth * 1, mHeight * 3, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 2, mWidth * 2, mHeight * 3, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 3, mWidth * 3, mHeight * 3, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 0, mWidth * 0, mHeight * 4, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 1, mWidth * 1, mHeight * 4, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 2, mWidth * 2, mHeight * 4, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 3, mWidth * 3, mHeight * 4, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 0, mWidth * 0, mHeight * 5, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 1, mWidth * 1, mHeight * 5, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 2, mWidth * 2, mHeight * 5, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 3, mWidth * 3, mHeight * 5, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 0, mWidth * 0, mHeight * 6, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 1, mWidth * 1, mHeight * 6, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 2, mWidth * 2, mHeight * 6, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT, 3, mWidth * 3, mHeight * 6, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 0, mWidth * 0, mHeight * 7, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 1, mWidth * 1, mHeight * 7, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 2, mWidth * 2, mHeight * 7, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT, 3, mWidth * 3, mHeight * 7, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 0, mWidth * 0, mHeight * 8, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 1, mWidth * 1, mHeight * 8, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 2, mWidth * 2, mHeight * 8, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT, 3, mWidth * 3, mHeight * 8, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 0, mWidth * 0, mHeight * 9, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 1, mWidth * 1, mHeight * 9, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 2, mWidth * 2, mHeight * 9, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT, 3, mWidth * 3, mHeight * 9, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 0, mWidth * 0, mHeight * 10, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 1, mWidth * 1, mHeight * 10, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 2, mWidth * 2, mHeight * 10, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT, 3, mWidth * 3, mHeight * 10, mWidth, mHeight); + + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 0, mWidth * 0, mHeight * 11, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 1, mWidth * 1, mHeight * 11, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 2, mWidth * 2, mHeight * 11, mWidth, mHeight); + mSpriteBody->setAnimationFrames(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT, 3, mWidth * 3, mHeight * 11, mWidth, mHeight); + + // Selecciona un frame para pintar + mSpriteLegs->setSpriteClip(mSpriteLegs->getAnimationClip(PLAYER_ANIMATION_LEGS_WALKING_STOP, 0)); + mSpriteBody->setSpriteClip(mSpriteBody->getAnimationClip(PLAYER_ANIMATION_BODY_WALKING_STOP, 0)); +} + +// Actua en consecuencia de la entrada recibida +void Player::setInput(Uint8 input) +{ + switch (input) + { + case INPUT_LEFT: + mVelX = -mBaseSpeed; + if (mExtraHit) + { + setWalkingStatus(PLAYER_STATUS_WALKING_LEFT); + } + else + { + setWalkingStatus(PLAYER_STATUS_WALKING_LEFT); + } + break; + + case INPUT_RIGHT: + mVelX = mBaseSpeed; + if (mExtraHit) + { + setWalkingStatus(PLAYER_STATUS_WALKING_RIGHT); + } + else + { + setWalkingStatus(PLAYER_STATUS_WALKING_RIGHT); + } + break; + + case INPUT_FIRE_UP: + if (mExtraHit) + { + setFiringStatus(PLAYER_STATUS_FIRING_UP); + } + else + { + setFiringStatus(PLAYER_STATUS_FIRING_UP); + } + break; + + case INPUT_FIRE_LEFT: + if (mExtraHit) + { + setFiringStatus(PLAYER_STATUS_FIRING_LEFT); + } + else + { + setFiringStatus(PLAYER_STATUS_FIRING_LEFT); + } + break; + + case INPUT_FIRE_RIGHT: + if (mExtraHit) + { + setFiringStatus(PLAYER_STATUS_FIRING_RIGHT); + } + else + { + setFiringStatus(PLAYER_STATUS_FIRING_RIGHT); + } + break; + + default: + mVelX = 0; + if (mExtraHit) + { + setWalkingStatus(PLAYER_STATUS_WALKING_STOP); + } + else + { + setWalkingStatus(PLAYER_STATUS_WALKING_STOP); + } + break; + } +} + +// Mueve el jugador a la posición y animación que le corresponde +void Player::move() +{ + if (isAlive()) + { + // Mueve el jugador a derecha o izquierda + mPosX += mVelX; + + // Si el jugador abandona el area de juego por los laterales + if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT)) + { + // Restaura su posición + mPosX -= mVelX; + } + + // Actualiza la posición del sprite + mSpriteLegs->setPosX(getPosX()); + mSpriteLegs->setPosY(mPosY); + + mSpriteBody->setPosX(getPosX()); + mSpriteBody->setPosY(mPosY); + } +} + +// Pinta el jugador en pantalla +void Player::render() +{ + if (isAlive()) + { + if (mInvulnerable) + { + if ((mInvulnerableTimer % 10) > 4) + { + mSpriteLegs->render(); + mSpriteBody->render(); + } + } + else + { + mSpriteLegs->render(); + mSpriteBody->render(); + } + } +} + +// Establece el estado del jugador cuando camina +void Player::setWalkingStatus(Uint8 status) +{ + // Si cambiamos de estado, reiniciamos la animación + if (mStatusWalking != status) + { + mStatusWalking = status; + mSpriteLegs->setCurrentFrame(0); + } +} + +// Establece el estado del jugador cuando dispara +void Player::setFiringStatus(Uint8 status) +{ + // Si cambiamos de estado, reiniciamos la animación + if (mStatusFiring != status) + { + mStatusFiring = status; + mSpriteBody->setCurrentFrame(0); + } +} + +// Establece la animación correspondiente al estado +void Player::setAnimation() +{ + switch (mStatusWalking) + { + case PLAYER_STATUS_WALKING_LEFT: + mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_LEFT); + switch (mStatusFiring) + { + case PLAYER_STATUS_FIRING_UP: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP); + } + + break; + + case PLAYER_STATUS_FIRING_LEFT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT); + } + + break; + + case PLAYER_STATUS_FIRING_RIGHT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT); + } + + break; + + case PLAYER_STATUS_FIRING_NO: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_LEFT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_LEFT); + } + + break; + + default: + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP); + break; + } + break; + + case PLAYER_STATUS_WALKING_RIGHT: + mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_RIGHT); + switch (mStatusFiring) + { + case PLAYER_STATUS_FIRING_UP: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP); + } + + break; + + case PLAYER_STATUS_FIRING_LEFT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT); + } + + break; + + case PLAYER_STATUS_FIRING_RIGHT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT); + } + + break; + + case PLAYER_STATUS_FIRING_NO: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_RIGHT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_RIGHT); + } + + break; + + default: + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP); + break; + } + break; + + case PLAYER_STATUS_WALKING_STOP: + mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP); + switch (mStatusFiring) + { + case PLAYER_STATUS_FIRING_UP: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP); + } + + break; + + case PLAYER_STATUS_FIRING_LEFT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT); + } + + break; + + case PLAYER_STATUS_FIRING_RIGHT: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT); + } + + break; + + case PLAYER_STATUS_FIRING_NO: + if (mExtraHit) + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP_EXTRA_HIT); + } + else + { + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP); + } + + break; + + default: + mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP); + break; + } + break; + + default: + mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP); + break; + } +} + +// Obtiene el valor de la variable +int Player::getPosX() +{ + return int(mPosX); +} + +// Obtiene el valor de la variable +int Player::getPosY() +{ + return mPosY; +} + +// Obtiene el valor de la variable +int Player::getWidth() +{ + return mWidth; +} + +// Obtiene el valor de la variable +int Player::getHeight() +{ + return mHeight; +} + +// Indica si el jugador puede disparar +bool Player::canFire() +{ + // Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador + if (mCooldown > 0) + { + return false; + } + else + { + return true; + } +} + +// Establece el valor de la variable +void Player::setFireCooldown(int time) +{ + mCooldown = time; +} + +// Actualiza el valor de la variable +void Player::updateCooldown() +{ + if (mCooldown > 0) + { + --mCooldown; + } + else + { + setFiringStatus(PLAYER_STATUS_FIRING_NO); + } +} + +// Actualiza al jugador a su posicion, animación y controla los contadores +void Player::update() +{ + move(); + setAnimation(); + shiftColliders(); + updateCooldown(); + updateInvulnerableTimer(); +} + +// Obtiene la puntuación del jugador +int Player::getScore() +{ + return mScore; +} + +// Asigna un valor a la puntuación del jugador +void Player::setScore(int score) +{ + mScore = score; +} + +// Incrementa la puntuación del jugador +void Player::addScore(int score) +{ + mScore += score; +} + +// Obtiene el valor de la variable +bool Player::isAlive() +{ + return mAlive; +} + +// Establece el valor de la variable +void Player::setAlive(bool value) +{ + mAlive = value; +} + +// Obtiene el valor de la variable +float Player::getScoreMultiplier() +{ + return mScoreMultiplier; +} + +// Establece el valor de la variable +void Player::setScoreMultiplier(float value) +{ + mScoreMultiplier = value; +} + +// Aumenta el valor de la variable hasta un máximo +void Player::incScoreMultiplier() +{ + if (mScoreMultiplier < 5.0f) + { + mScoreMultiplier += 0.1f; + } +} + +// Decrementa el valor de la variable hasta un mínimo +void Player::decScoreMultiplier() +{ + if (mScoreMultiplier > 1.0f) + { + mScoreMultiplier -= 0.1f; + } +} + +// Obtiene el valor de la variable +bool Player::isInvulnerable() +{ + return mInvulnerable; +} + +// Establece el valor de la variable +void Player::setInvulnerable(bool value) +{ + mInvulnerable = value; +} + +// Obtiene el valor de la variable +bool Player::getInvulnerableTimer() +{ + return mInvulnerableTimer; +} + +// Establece el valor de la variable +void Player::setInvulnerableTimer(Uint16 value) +{ + mInvulnerableTimer = value; +} + +// Actualiza el valor de la variable +void Player::updateInvulnerableTimer() +{ + if (mInvulnerableTimer > 0) + { + --mInvulnerableTimer; + } + else + { + mInvulnerable = false; + mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER; + } +} + +// Obtiene el valor de la variable +bool Player::hasExtraHit() +{ + return mExtraHit; +} + +// Concede un toque extra al jugador +void Player::giveExtraHit() +{ + mExtraHit = true; +} + +// Quita el toque extra al jugador +void Player::removeExtraHit() +{ + mExtraHit = false; + mInvulnerable = true; + mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER; +} + +// Obtiene el circulo de colisión +Circle &Player::getCollider() +{ + return mCollider; +} + +// Actualiza el circulo de colisión a la posición del jugador +void Player::shiftColliders() +{ + mCollider.x = Uint16(mPosX + (mWidth / 2)); + mCollider.y = mPosY + (mHeight / 2); +} \ No newline at end of file diff --git a/source/player.h b/source/player.h new file mode 100644 index 0000000..0a9148c --- /dev/null +++ b/source/player.h @@ -0,0 +1,173 @@ +#pragma once +#include "struct.h" +#include "animatedsprite.h" + +#ifndef PLAYER_H +#define PLAYER_H + +// The player +class Player +{ +public: + // Constructor + Player(); + + // Destructor + ~Player(); + + // Iniciador + void init(float x, int y, LTexture *textureLegs, LTexture *textureBody, SDL_Renderer *renderer); + + // Actua en consecuencia de la entrada recibida + void setInput(Uint8 input); + + // Mueve el jugador a la posición y animación que le corresponde + void move(); + + // Pinta el jugador en pantalla + void render(); + + // Establece el estado del jugador + void setWalkingStatus(Uint8 status); + void setFiringStatus(Uint8 status); + + // Establece la animación correspondiente al estado + void setAnimation(); + + // Obtiene el valor de la variable + int getPosX(); + + // Obtiene el valor de la variable + int getPosY(); + + // Obtiene el valor de la variable + int getWidth(); + + // Obtiene el valor de la variable + int getHeight(); + + // Indica si el jugador puede disparar + bool canFire(); + + // Establece el valor de la variable + void setFireCooldown(int time); + + // Actualiza el valor de la variable + void updateCooldown(); + + // Actualiza al jugador a su posicion, animación y controla los contadores + void update(); + + // Obtiene la puntuación del jugador + int getScore(); + + // Asigna un valor a la puntuación del jugador + void setScore(int score); + + // Incrementa la puntuación del jugador + void addScore(int score); + + // Obtiene el valor de la variable + bool isAlive(); + + // Establece el valor de la variable + void setAlive(bool value); + + // Obtiene el valor de la variable + float getScoreMultiplier(); + + // Establece el valor de la variable + void setScoreMultiplier(float value); + + // Aumenta el valor de la variable hasta un máximo + void incScoreMultiplier(); + + // Decrementa el valor de la variable hasta un mínimo + void decScoreMultiplier(); + + // Obtiene el valor de la variable + bool isInvulnerable(); + + // Establece el valor de la variable + void setInvulnerable(bool value); + + // Obtiene el valor de la variable + bool getInvulnerableTimer(); + + // Establece el valor de la variable + void setInvulnerableTimer(Uint16 value); + + // Actualiza el valor de la variable + void updateInvulnerableTimer(); + + // Obtiene el valor de la variable + bool hasExtraHit(); + + // Concede un toque extra al jugador + void giveExtraHit(); + + // Quita el toque extra al jugador + void removeExtraHit(); + + // Obtiene el circulo de colisión + Circle &getCollider(); + +private: + // Posición X, Y del jugador + float mPosX; + int mPosY; + + // Altura y anchura del jugador + Uint8 mWidth; + Uint8 mHeight; + + // Velocidad X, Y del jugador + float mVelX; + int mVelY; + + // Velocidad base del jugador + float mBaseSpeed; + + // Contador durante el cual no puede disparar + int mCooldown; + + // Vidas actuales del jugador + Uint8 mLives; + + // Vidas iniciales del jugador + Uint8 mStartingLives; + + // Puntos del jugador + Uint32 mScore; + + // Multiplicador de puntos + float mScoreMultiplier; + + // Estado del jugador + Uint8 mStatusWalking; + Uint8 mStatusFiring; + + // Indica si el jugador está vivo + bool mAlive; + + // Indica si el jugador es invulnerable + bool mInvulnerable; + + // Temporizador para la invulnerabilidad + Uint16 mInvulnerableTimer; + + // Indica si el jugador tiene un toque extra + bool mExtraHit; + + // Sprite para dibujar al jugador en pantalla + AnimatedSprite *mSpriteLegs; + AnimatedSprite *mSpriteBody; + + // Circulo de colisión del jugador + Circle mCollider; + + // Actualiza el circulo de colisión a la posición del jugador + void shiftColliders(); +}; + +#endif diff --git a/source/smartsprite.cpp b/source/smartsprite.cpp new file mode 100644 index 0000000..5b68a17 --- /dev/null +++ b/source/smartsprite.cpp @@ -0,0 +1,228 @@ +#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; + + // 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 mEnabledTimer; +} + +// Establece el valor de la variable +void SmartSprite::setEnabledTimer(Uint16 time) +{ + mEnabledTimer = 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) + { + move(); + + // 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 (mEnabledTimer > 0) + { + --mEnabledTimer; + } + // Si ha llegado a cero, deshabilita el objeto o manda el aviso en función de si tiene Id + else if (mEnabledTimer == 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..8061960 --- /dev/null +++ b/source/smartsprite.h @@ -0,0 +1,84 @@ +#pragma once +#include "struct.h" +#include "animatedsprite.h" + +#ifndef SMARTSPRITE_H +#define SMARTSPRITE_H + +// Clase SmartSprite +class SmartSprite : public AnimatedSprite +{ +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); + +private: + // Indica si esta habilitado + bool mEnabled; + + // Contador + Uint16 mEnabledTimer; + + // Indica si está en el destino + bool mIsOnDestination; + + // Posicion de destino + int mDestX; + int mDestY; + + // Identificador + int mId; + + // Dirección del array de eventos donde notificar el estado + Uint8 *mIntroEvents; +}; + +#endif diff --git a/source/sprite.cpp b/source/sprite.cpp new file mode 100644 index 0000000..23df471 --- /dev/null +++ b/source/sprite.cpp @@ -0,0 +1,149 @@ +#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 el alto y el ancho del sprite + setWidth(w); + setHeight(h); + + // Establece la posición X,Y del sprite + setPosX(x); + setPosY(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(0, 0, w, h); +} + +// 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() +{ + 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; +} \ No newline at end of file diff --git a/source/sprite.h b/source/sprite.h new file mode 100644 index 0000000..9654ed8 --- /dev/null +++ b/source/sprite.h @@ -0,0 +1,87 @@ +#pragma once +#include "ifdefs.h" +#include "ltexture.h" + +#ifndef SPRITE_H +#define SPRITE_H + +// Clase sprite +class Sprite +{ +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); + + +protected: + // Posición X,Y donde dibujar el sprite + int mPosX; + int mPosY; + + // Alto y ancho del sprite + Uint16 mWidth; + Uint16 mHeight; + + // Puntero al renderizador de la ventana + SDL_Renderer *mRenderer; + + // Textura donde estan todos los dibujos del sprite + LTexture *mTexture; + + // Rectangulo de la textura que se dibujará en pantalla + SDL_Rect mSpriteClip; +}; + +#endif diff --git a/source/stb_image.h b/source/stb_image.h new file mode 100644 index 0000000..accef48 --- /dev/null +++ b/source/stb_image.h @@ -0,0 +1,7762 @@ +/* stb_image - v2.26 - 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.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 + 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 + 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 [reserved] + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + 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. +// +// =========================================================================== +// +// 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: +// +// By default we convert iphone-formatted PNGs back to RGB, even though +// they are internally encoded differently. You can disable this conversion +// by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through (which +// is BGR stored in RGB). +// +// 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_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) >> (32 - (y)))) +#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 +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#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); +#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) +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) +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; + + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #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 + #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(_MSC_VER) && 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(_MSC_VER) && 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(_MSC_VER) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode))) + return 0; + +#if _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); + return z + (stbi__get16le(s) << 16); +} +#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 = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB + k = stbi_lrot(j->code_buffer, n); + if (n < 0 || n >= (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))) return 0; + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & ~sgn); +} + +// 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) 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 == -1) 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 << 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) << 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) << 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; + } + + // 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; + + // 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)); + 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)); + 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))); + 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) + +// 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[288]; + stbi__uint16 value[288]; +} 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 >= sizeof (z->size)) 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[288] = +{ + 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 , 288)) 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); + 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 = 0; +static int stbi__de_iphone_flag = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag = flag_true_if_should_convert; +} + +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 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"); + 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) { + 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 { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } + } 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 { + 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); + 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) { + STBI_ASSERT(info.offset == s->callback_already_read + (int) (s->img_buffer - s->img_buffer_original)); + if (info.offset != s->callback_already_read + (s->img_buffer - s->buffer_start)) { + 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); + 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 (!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(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; + 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 (NULL == tmp) { + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + return stbi__errpuc("outofmem", "Out of memory"); + } + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + *delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + 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); + stbi__rewind( s ); + if (p == NULL) + 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; + } + (void) stbi__get32be(s); + (void) 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) +// Does not support 16-bit-per-channel + +#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); + + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + 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__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + 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 > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#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 + + 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/struct.h b/source/struct.h new file mode 100644 index 0000000..bfde6fc --- /dev/null +++ b/source/struct.h @@ -0,0 +1,42 @@ +#pragma once +#include "ifdefs.h" + +#ifndef STRUCT_H +#define STRUCT_H + +// Estructura para definir un circulo +struct Circle +{ + Uint16 x; + Uint16 y; + Uint8 r; +}; + +// Estructura para definir todas las entradas que aceptará el programa +struct Input +{ + Uint8 up; + Uint8 down; + Uint8 left; + Uint8 right; + Uint8 escape; + Uint8 pause; + Uint8 fire; + Uint8 fireLeft; + Uint8 fireRight; + Uint8 accept; + Uint8 cancel; +}; + +// Estructura para mapear el teclado usado en la demo +struct DemoKeys +{ + Uint8 left; + Uint8 right; + Uint8 noInput; + Uint8 fire; + Uint8 fireLeft; + Uint8 fireRight; +}; + +#endif diff --git a/source/text.cpp b/source/text.cpp new file mode 100644 index 0000000..b4b8cce --- /dev/null +++ b/source/text.cpp @@ -0,0 +1,244 @@ +#include "const.h" +#include "text.h" + +// Constructor +Text::Text() +{ + mSprite = new Sprite(); + init(nullptr, nullptr, 0, 0); +} + +// Destructor +Text::~Text() +{ + delete mSprite; +} + +// Inicializador +void Text::init(LTexture *texture, SDL_Renderer *renderer, Uint8 type, Uint8 size) +{ + // Inicializa variables + mType = type; + mSize = size; + + // Inicia los valores del sprite que dibuja las letras + mSprite->setWidth(size); + mSprite->setHeight(size); + mSprite->setPosX(0); + mSprite->setPosY(0); + mSprite->setTexture(texture); + mSprite->setRenderer(renderer); + mSprite->setSpriteClip(0, 0, mSprite->getWidth(), mSprite->getHeight()); + + // Cadena con los caracteres ascii que se van a inicializar + // std::string text = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-/().:#!"; + std::string text = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ{\\[]]^_`abcdefghijklmnopqrstuvwxyz"; + + // Inicializa a cero el vector con las coordenadas + for (Uint8 i = 0; i < 255; i++) + { + mOffset[i].x = 0; + mOffset[i].y = 0; + mOffset[i].w = 0; + } + + // Establece las coordenadas para cada caracter ascii de la cadena y su ancho + for (Uint8 i = 0; i < text.length(); ++i) + { + mOffset[int(text[i])].x = ((int(text[i]) - 32) % 15) * mSprite->getWidth(); + mOffset[int(text[i])].y = ((int(text[i]) - 32) / 15) * mSprite->getHeight(); + if (type == TEXT_FIXED) + { + mOffset[int(text[i])].w = size; + } + } + + // Establece el ancho de cada caracter + if (type == TEXT_VARIABLE) + { + mOffset[int(' ')].w = 7; + mOffset[int('-')].w = 6; + mOffset[int('/')].w = 5; + mOffset[int('(')].w = 5; + mOffset[int(')')].w = 5; + mOffset[int('.')].w = 4; + mOffset[int(':')].w = 4; + mOffset[int('#')].w = 7; + mOffset[int('!')].w = 7; + mOffset[int('\'')].w = 3; + + mOffset[int('0')].w = 7; + mOffset[int('1')].w = 5; + mOffset[int('2')].w = 7; + mOffset[int('3')].w = 7; + mOffset[int('4')].w = 7; + mOffset[int('5')].w = 7; + mOffset[int('6')].w = 7; + mOffset[int('7')].w = 7; + mOffset[int('8')].w = 7; + mOffset[int('9')].w = 7; + + mOffset[int('A')].w = 7; + mOffset[int('B')].w = 7; + mOffset[int('C')].w = 7; + mOffset[int('D')].w = 7; + mOffset[int('E')].w = 7; + mOffset[int('F')].w = 7; + mOffset[int('G')].w = 7; + mOffset[int('H')].w = 7; + mOffset[int('I')].w = 4; + mOffset[int('J')].w = 6; + mOffset[int('K')].w = 8; + mOffset[int('L')].w = 6; + mOffset[int('M')].w = 9; + mOffset[int('N')].w = 8; + mOffset[int('O')].w = 8; + mOffset[int('P')].w = 7; + mOffset[int('Q')].w = 8; + mOffset[int('R')].w = 7; + mOffset[int('S')].w = 6; + mOffset[int('T')].w = 8; + mOffset[int('U')].w = 7; + mOffset[int('V')].w = 8; + mOffset[int('W')].w = 9; + mOffset[int('X')].w = 8; + mOffset[int('Y')].w = 8; + mOffset[int('Z')].w = 7; + + mOffset[int('a')].w = 7; + mOffset[int('b')].w = 7; + mOffset[int('c')].w = 6; + mOffset[int('d')].w = 7; + mOffset[int('e')].w = 7; + mOffset[int('f')].w = 5; + mOffset[int('g')].w = 7; + mOffset[int('h')].w = 7; + mOffset[int('i')].w = 4; + mOffset[int('j')].w = 5; + mOffset[int('k')].w = 7; + mOffset[int('l')].w = 4; + mOffset[int('m')].w = 10; + mOffset[int('n')].w = 7; + mOffset[int('o')].w = 7; + mOffset[int('p')].w = 7; + mOffset[int('q')].w = 7; + mOffset[int('r')].w = 6; + mOffset[int('s')].w = 6; + mOffset[int('t')].w = 5; + mOffset[int('u')].w = 7; + mOffset[int('v')].w = 7; + mOffset[int('w')].w = 9; + mOffset[int('x')].w = 7; + mOffset[int('y')].w = 7; + mOffset[int('z')].w = 7; + } +} + +// Escribe el texto en pantalla +void Text::write(int x, int y, std::string text) +{ + Uint16 shift = 0; + for (Uint8 i = 0; i < text.length(); ++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); + } +} + +// Escribe el texto en pantalla con kerning +void Text::write(int x, int y, std::string text, int kerning) +{ + Uint16 shift = 0; + for (Uint8 i = 0; i < text.length(); ++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 una cantidad determinada de caracteres del texto en pantalla +void Text::write(int x, int y, std::string text, int kerning, Uint8 lenght) +{ + Uint16 shift = 0; + for (Uint8 i = 0; i < lenght; ++i) + { + if (text[i] == '*') + { + shift = 0; + y += mSize; + } + else + { + 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, Uint8 R, Uint8 G, Uint8 B) +{ + mSprite->getTexture()->setColor(R, G, B); + write(x, y, text); + mSprite->getTexture()->setColor(255, 255, 255); +} + +// Escribe el texto centrado en un punto x y con kerning +void Text::writeCentered(int x, int y, std::string text, int kerning) +{ + // Uint16 lenght = Text::lenght(text, kerning); + x = x - (Text::lenght(text, kerning) / 2); + Uint16 shift = 0; + for (Uint8 i = 0; i < text.length(); ++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); + } +} + +// Obtiene la longitud en pixels de una cadena +Uint16 Text::lenght(std::string text, int kerning) +{ + Uint16 shift = 0; + for (Uint8 i = 0; i < text.length(); ++i) + { + shift += (mOffset[int(text[i])].w + kerning); + } + return shift; +} + +// Obtiene el valor de la variable +Uint8 Text::getType() +{ + return mType; +} + +// Establece el valor de la variable +void Text::setType(Uint8 type) +{ + mType = type; +} + +// Obtiene el valor de la variable +Uint8 Text::getSize() +{ + return mSize; +} + +// Establece el valor de la variable +void Text::setSize(Uint8 size) +{ + mSize = size; +} \ No newline at end of file diff --git a/source/text.h b/source/text.h new file mode 100644 index 0000000..f651c59 --- /dev/null +++ b/source/text.h @@ -0,0 +1,66 @@ +#pragma once +#include "sprite.h" + +#ifndef TEXT_H +#define TEXT_H + +// Clase texto. Pinta texto en pantalla a partir de un bitmap +class Text +{ +public: + // Constructor + Text(); + + // Destructor + ~Text(); + + // Inicializador + void init(LTexture *texture, SDL_Renderer *renderer, Uint8 type, Uint8 size); + + // Escribe el texto en pantalla + void write(int x, int y, std::string text); + void write(int x, int y, std::string text, int kerning); + void write(int x, int y, std::string text, int kerning, Uint8 lenght); + + // Escribe el texto con colores + void writeColored(int x, int y, std::string text, Uint8 R, Uint8 G, Uint8 B); + + // Escribe el texto centrado en un punto x y con kerning + void writeCentered(int x, int y, std::string text, int kerning); + + // Obtiene la longitud en pixels de una cadena + Uint16 lenght(std::string text, int kerning); + + // Obtiene el valor de la variable + Uint8 getType(); + + // Establece el valor de la variable + void setType(Uint8 type); + + // Obtiene el valor de la variable + Uint8 getSize(); + + // Establece el valor de la variable + void setSize(Uint8 size); + +private: + // Objeto con los graficos para el texto + Sprite *mSprite; + + // Coordenadas dentro del PNG para cada código ascii y su anchura + struct Offset + { + int x; + int y; + Uint8 w; + }; + + // Vector con las posiciones y ancho de cada letra + Offset mOffset[255]; + + // Indica si el texto es de anchura fija o variable + Uint8 mType; + Uint8 mSize; +}; + +#endif diff --git a/source/text2.cpp b/source/text2.cpp new file mode 100644 index 0000000..6b9586c --- /dev/null +++ b/source/text2.cpp @@ -0,0 +1,158 @@ +#include "const.h" +#include "text2.h" + +// Constructor +Text2::Text2() +{ + init(nullptr, nullptr, 0, 0); +} + +// Destructor +Text2::~Text2() +{ + init(nullptr, nullptr, 0, 0); +} + +// Inicializador +void Text2::init(LTexture *texture, SDL_Renderer *renderer, Uint8 type, Uint8 size) +{ + Text::init(texture, renderer, type, size); + mPosX = 0; + mPosY = 0; + mKerning = 0; + mCaption = ""; + mWrittingSpeed = 0; + mWrittingTimer = 0; + mIndex = 0; + mLenght = 0; + mWrittingCompleted = false; + mEnabled = false; + mEnabledTimer = 0; + mId = -1; + mIntroEvents = nullptr; +} + +// Establece el valor de la variable +void Text2::setPosX(int value) +{ + mPosX = value; +} + +// Establece el valor de la variable +void Text2::setPosY(int value) +{ + mPosY = value; +} + +// Establece el valor de la variable +void Text2::setKerning(int value) +{ + mKerning = value; +} + +// Establece el valor de la variable +void Text2::setCaption(std::string text) +{ + mCaption = text; + mLenght = text.length(); +} + +// Establece el valor de la variable +void Text2::setWrittingSpeed(Uint16 value) +{ + mWrittingSpeed = value; + mWrittingTimer = value; +} + +// Establece el valor de la variable +void Text2::setEnabled(bool value) +{ + mEnabled = value; +} + +// Obtiene el valor de la variable +bool Text2::IsEnabled() +{ + return mEnabled; +} + +// Establece el valor de la variable +void Text2::setEnabledTimer(Uint16 value) +{ + mEnabledTimer = value; +} + +// Obtiene el valor de la variable +Uint16 Text2::getEnabledTimer() +{ + return mEnabledTimer; +} + +// Actualiza el objeto +void Text2::update() +{ + if (mEnabled) + { + if (mWrittingCompleted == false) + { + if (mWrittingTimer > 0) + { + --mWrittingTimer; + } + if (mWrittingTimer == 0) + { + ++mIndex; + mWrittingTimer = mWrittingSpeed; + } + if (mIndex == mLenght) + { + mWrittingCompleted = true; + } + } + if (mWrittingCompleted) + { + if (mEnabledTimer > 0) + { + --mEnabledTimer; + } + else if (mEnabledTimer == 0) + { + if (mId < 0) + { + mEnabled = false; + } + else + { + mIntroEvents[mId] = EVENT_COMPLETED; + } + } + } + } +} + +// Dibuja el objeto en pantalla +void Text2::render() +{ + if (mEnabled) + { + Text::write(mPosX, mPosY, mCaption, mKerning, mIndex); + } +} + +// Centra la cadena de texto a un punto X +void Text2::center(int x) +{ + setPosX(x - (lenght(mCaption, mKerning) / 2)); +} + +// Establece el valor de la variable +void Text2::setId(int id) +{ + mId = id; +} + +// Establece el valor de la variable +void Text2::setIntroEvents(Uint8 *value) +{ + mIntroEvents = value; +} diff --git a/source/text2.h b/source/text2.h new file mode 100644 index 0000000..9366d61 --- /dev/null +++ b/source/text2.h @@ -0,0 +1,102 @@ +#pragma once +#include "sprite.h" +#include "text.h" + +#ifndef TEXT2_H +#define TEXT2_H + +// Clase texto. Pinta texto en pantalla a partir de un bitmap +class Text2 : public Text +{ +public: + // Constructor + Text2(); + + // Destructor + ~Text2(); + + // Inicializador + void init(LTexture *texture, SDL_Renderer *renderer, Uint8 type, Uint8 size); + + // 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 setWrittingSpeed(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); + +private: + // Posicion X/Y donde empezar a escribir el texto + int mPosX; + int mPosY; + + // Kerning del texto + int mKerning; + + // Texto para escribir + std::string mCaption; + + // Velocidad de escritura + Uint16 mWrittingSpeed; + + // Temporizador de escritura para cada caracter + Uint16 mWrittingTimer; + + // Posición del texto que se está escribiendo + Uint16 mIndex; + + // Longitud de la cadena a escribir + Uint16 mLenght; + + // Indica si se ha escrito todo el texto + bool mWrittingCompleted; + + // Indica si el objeto está habilitado + bool mEnabled; + + // Temporizador para deshabilitar el objeto + Uint16 mEnabledTimer; + + // Identificador + int mId; + + // Dirección del array de eventos donde notificar el estado + Uint8 *mIntroEvents; +}; + +#endif diff --git a/sync.sh b/sync.sh new file mode 100755 index 0000000..b4cd006 --- /dev/null +++ b/sync.sh @@ -0,0 +1,36 @@ +#!/bin/bash +readonly PROJECT=coffee_crisis + +readonly USAGE=" +USAGE: +$(basename "$0") [UPLOAD or DOWNLOAD]" + +function help_message() { + echo "$USAGE" +} + +PARAMETERS="UPLOAD DOWNLOAD upload download" + +# check if there are all the parameters +if [ "$#" -ne 1 ]; then + help_message + exit 0 +fi + +# check if the systems parameter is valid +if ! echo "$PARAMETERS" | grep -w "$1" >/dev/null; then + help_message + exit 0 +fi + +# UPLOAD +if [ "$1" = upload ] || [ "$1" = UPLOAD ]; then + printf "\n%s\n" "uploading $PROJECT" + rsync -azmPu --delete -e 'ssh -p 4545' . sergio@sustancia.synology.me:/home/sergio/backup/code/$PROJECT/ + rsync -azmPu -e 'ssh -p 4545' . sergio@sustancia.synology.me:/home/sergio/backup/code/$PROJECT.all/ +fi + +if [ "$1" = download ] || [ "$1" = DOWNLOAD ]; then + printf "%s\n" "downloading $PROJECT" + rsync -azmP --delete -e 'ssh -p 4545' sergio@sustancia.synology.me:/home/sergio/backup/code/$PROJECT/* . +fi \ No newline at end of file