#include "video/qt_decoder.h"

#include "video/qt_data.h"

#include "audio/audiostream.h"

#include "common/archive.h"

#include "common/config-manager.h"

#include "common/debug.h"

#include "common/events.h"

#include "common/file.h"

#include "common/keyboard.h"

#include "common/memstream.h"

#include "common/system.h"

#include "common/textconsole.h"

#include "common/timer.h"

#include "common/util.h"

#include "common/compression/unzip.h"

#include "graphics/cursorman.h"

#include "image/icocur.h"

#include "image/png.h"

#include "image/codecs/codec.h"

namespace Video {

static const char * const MACGUI_DATA_BUNDLE = "macgui.dat";

static float readAppleFloatField(Common::SeekableReadStream *stream) {

}

QuickTimeDecoder::PanoSampleDesc::PanoSampleDesc(Common::QuickTimeParser::Track *parentTrack, uint32 codecTag) : Common::QuickTimeParser::SampleDesc(parentTrack, codecTag) {

}

QuickTimeDecoder::PanoSampleDesc::~PanoSampleDesc() {

}

Common::QuickTimeParser::SampleDesc *QuickTimeDecoder::readPanoSampleDesc(Common::QuickTimeParser::Track *track, uint32 format, uint32 descSize) {

PanoSampleDesc *entry = new PanoSampleDesc(track, format);

entry->_majorVersion = _fd->readSint16BE(); // must be zero, also observed to be 1

entry->_minorVersion = _fd->readSint16BE();

entry->_sceneTrackID = _fd->readSint32BE();

entry->_loResSceneTrackID = _fd->readSint32BE();

_fd->read(entry->_reserved3, 4 * 6);

entry->_hotSpotTrackID = _fd->readSint32BE();

_fd->read(entry->_reserved4, 4 * 9);

entry->_hPanStart = readAppleFloatField(_fd);

entry->_hPanEnd = readAppleFloatField(_fd);

entry->_vPanTop = readAppleFloatField(_fd);

entry->_vPanBottom = readAppleFloatField(_fd);

entry->_minimumZoom = readAppleFloatField(_fd);

entry->_maximumZoom = readAppleFloatField(_fd);

// info for the highest res version of scene track

entry->_sceneSizeX = _fd->readUint32BE();

entry->_sceneSizeY = _fd->readUint32BE();

entry->_numFrames = _fd->readUint32BE();

entry->_reserved5 = _fd->readSint16BE();

entry->_sceneNumFramesX = _fd->readSint16BE();

entry->_sceneNumFramesY = _fd->readSint16BE();

entry->_sceneColorDepth = _fd->readSint16BE();

// info for the highest rest version of hotSpot track

entry->_hotSpotSizeX = _fd->readSint32BE(); // pixel width of the hot spot panorama

entry->_hotSpotSizeY = _fd->readSint32BE(); // pixel height of the hot spot panorama

entry->_reserved6 = _fd->readSint16BE();

entry->_hotSpotNumFramesX = _fd->readSint16BE(); // diced frames wide

entry->_hotSpotNumFramesY = _fd->readSint16BE(); // dices frame high

entry->_hotSpotColorDepth = _fd->readSint16BE(); // must be 8

if (entry->_minimumZoom == 0.0)

entry->_minimumZoom = 2.0;

if (entry->_maximumZoom == 0.0)

entry->_maximumZoom = abs(entry->_vPanTop - entry->_vPanBottom);

debugC(2, kDebugLevelGVideo, " version: %d.%d sceneTrackID: %d loResSceneTrackID: %d hotSpotTrackID: %d",

entry->_majorVersion, entry->_minorVersion, entry->_sceneTrackID, entry->_loResSceneTrackID, entry->_hotSpotTrackID);

debugC(2, kDebugLevelGVideo, " hpan: [%f - %f] vpan: [%f - %f] zoom: [%f - %f]",

entry->_hPanStart, entry->_hPanEnd, entry->_vPanTop, entry->_vPanBottom, entry->_minimumZoom, entry->_maximumZoom);

debugC(2, kDebugLevelGVideo, " sceneDims: [%d x %d] frames: %d sceneFrm: [%d x %d] bpp: %d",

entry->_sceneSizeX, entry->_sceneSizeY, entry->_numFrames, entry->_sceneNumFramesX,

entry->_sceneNumFramesY, entry->_sceneColorDepth);

debugC(2, kDebugLevelGVideo, " hotspotDims: [%d x %d] hotspotFrm: [%d x %d] bpp: %d",

entry->_hotSpotSizeX, entry->_hotSpotSizeY, entry->_hotSpotNumFramesX, entry->_hotSpotNumFramesY,

entry->_hotSpotColorDepth);

return entry;

}

void QuickTimeDecoder::closeQTVR() {

}

void QuickTimeDecoder::renderHotspots(bool mode) {

}

void QuickTimeDecoder::setQuality(float quality) {

}

void QuickTimeDecoder::setWarpMode(int warpMode) {

}

void QuickTimeDecoder::setTransitionMode(Common::String mode) {

}

void QuickTimeDecoder::setTransitionSpeed(float speed) {

}

Common::String QuickTimeDecoder::getUpdateMode() const {

}

void QuickTimeDecoder::setUpdateMode(Common::String mode) {

}

void QuickTimeDecoder::setTargetSize(uint16 w, uint16 h) {

}

void QuickTimeDecoder::setPanAngle(float angle) {

}

void QuickTimeDecoder::setTiltAngle(float angle) {

}

bool QuickTimeDecoder::setFOV(float fov) {

}

Common::String QuickTimeDecoder::getCurrentNodeName() {

}

void QuickTimeDecoder::updateAngles() {

}

void QuickTimeDecoder::setCurrentRow(int row) {

}

void QuickTimeDecoder::setCurrentColumn(int column) {

}

void QuickTimeDecoder::nudge(const Common::String &direction) {

}

QuickTimeDecoder::NodeData QuickTimeDecoder::getNodeData(uint32 nodeID) {

}

void QuickTimeDecoder::goToNode(uint32 nodeID) {

}

QuickTimeDecoder::PanoTrackHandler::PanoTrackHandler(QuickTimeDecoder *decoder, Common::QuickTimeParser::Track *parent) : _decoder(decoder), _parent(parent) {

if (decoder->_qtvrType != QTVRType::PANORAMA)

error("QuickTimeDecoder::PanoTrackHandler: Incorrect track passed");

_isPanoConstructed = false;

_constructedPano = nullptr;

_constructedHotspots = nullptr;

_upscaledConstructedPano = nullptr;

_projectedPano = nullptr;

_planarProjection = nullptr;

_dirty = true;

_decoder->updateQTVRCursor(0, 0); // Initialize all things for cursor

}

QuickTimeDecoder::PanoTrackHandler::~PanoTrackHandler() {

if (_isPanoConstructed) {

_constructedPano->free();

delete _constructedPano;

_upscaledConstructedPano->free();

delete _upscaledConstructedPano;

if (_constructedHotspots) {

_constructedHotspots->free();

delete _constructedHotspots;

}

}

if (_projectedPano) {

_projectedPano->free();

delete _projectedPano;

_planarProjection->free();

delete _planarProjection;

}

}

uint16 QuickTimeDecoder::PanoTrackHandler::getWidth() const {

return getScaledWidth().toInt();

}

uint16 QuickTimeDecoder::PanoTrackHandler::getHeight() const {

return getScaledHeight().toInt();

}

Graphics::PixelFormat QuickTimeDecoder::PanoTrackHandler::getPixelFormat() const {

PanoSampleDesc *desc = (PanoSampleDesc *)_parent->sampleDescs[0];

VideoTrackHandler *track = (VideoTrackHandler *)(_decoder->getTrack(_decoder->Common::QuickTimeParser::_tracks[desc->_sceneTrackID - 1]->targetTrack));

return track->getPixelFormat();

}

Common::Rational QuickTimeDecoder::PanoTrackHandler::getScaledWidth() const {

return Common::Rational(_parent->width) / _parent->scaleFactorX;

}

Common::Rational QuickTimeDecoder::PanoTrackHandler::getScaledHeight() const {

return Common::Rational(_parent->height) / _parent->scaleFactorY;

}

void QuickTimeDecoder::PanoTrackHandler::swingTransitionHandler() {

// The number of steps (the speed) of the transition is decided by the _transitionSpeed

const int NUM_STEPS = 300 / _decoder->_transitionSpeed;

// Calculate the step

float stepFOV = (_decoder->_fov - _currentFOV) / NUM_STEPS;

float stepHFOV = (_decoder->_hfov - _currentHFOV) / NUM_STEPS;

float stepTiltAngle = (_decoder->_tiltAngle - _currentTiltAngle) / NUM_STEPS;

float targetPanAngle = _decoder->_panAngle;

float difference = ABS(_currentPanAngle - targetPanAngle);

float stepPanAngle;

// All of this is just because the panorama is supposed to take the smallest path

if (targetPanAngle > _currentPanAngle) {

if (difference <= 180) {

stepPanAngle = difference / NUM_STEPS;

} else {

stepPanAngle = (- (360 - difference)) / NUM_STEPS;

}

} else {

if (difference <= 180) {

stepPanAngle = (- difference) / NUM_STEPS;

} else {

stepPanAngle = (360 - difference) / NUM_STEPS;

}

}

int16 rectLeft = _decoder->_origin.x;

int16 rectRight = _decoder->_origin.y;

Common::Point mouse;

int mw = _decoder->_width, mh = _decoder->_height;

for (int i = 0; i < NUM_STEPS; i++) {

projectPanorama(1,

_currentFOV + i * stepFOV,

_currentHFOV + i * stepHFOV,

_currentTiltAngle + i * stepTiltAngle,

_currentPanAngle + i * stepPanAngle);

g_system->copyRectToScreen(_projectedPano->getPixels(),

_projectedPano->pitch,

rectLeft,

rectRight,

_projectedPano->w,

_projectedPano->h);

Common::Event event;

while (g_system->getEventManager()->pollEvent(event)) {

if (event.type == Common::EVENT_QUIT) {

debugC(1, kDebugLevelGVideo, "EVENT_QUIT passed during the Swing Transition.");

g_system->quit();

return;

}

if (Common::isMouseEvent(event)) {

mouse = event.mouse;

}

// Referenced from video.cpp in testbed engine

if (mouse.x >= _decoder->_prevMouse.x &&

mouse.x < _decoder->_prevMouse.x + mw &&

mouse.y >= _decoder->_prevMouse.y &&

mouse.y < _decoder->_prevMouse.y + mh) {

switch (event.type) {

case Common::EVENT_MOUSEMOVE:

_decoder->handleMouseMove(event.mouse.x - _decoder->_prevMouse.x, event.mouse.y - _decoder->_prevMouse.y);

break;

default:

break;

}

}

}

g_system->updateScreen();

g_system->delayMillis(10);

}

// This is so if we call swingTransitionHandler() twice

// The second time there will be no transition

_currentFOV = _decoder->_fov;

_currentPanAngle = _decoder->_panAngle;

_currentHFOV = _decoder->_hfov;

_currentTiltAngle = _decoder->_tiltAngle;

// Due to floating point errors, we may end a few degrees here and there

// Make sure we reach the destination at the end of this loop

// Also we have to go back to our original quality

projectPanorama(3, _decoder->_fov, _decoder->_hfov, _decoder->_tiltAngle, _decoder->_panAngle);

}

const Graphics::Surface *QuickTimeDecoder::PanoTrackHandler::decodeNextFrame() {

if (!_isPanoConstructed)

return nullptr;

// inject fake key/mouse events if button is held down

if (_decoder->_isKeyDown)

_decoder->handleKey(_decoder->_lastKey, true, true);

if (_decoder->_isMouseButtonDown)

_decoder->handleMouseButton(true, _decoder->_prevMouse.x, _decoder->_prevMouse.y, true);

if (_dirty && _decoder->_transitionMode == kTransitionModeNormal) {

float quality = _decoder->getQuality();

float fov = _decoder->_fov;

float hfov = _decoder->_hfov;

float tiltAngle = _decoder->_tiltAngle;

float panAngle = _decoder->_panAngle;

switch ((int)quality) {

case 1:

projectPanorama(1, fov, hfov, tiltAngle, panAngle);

break;

case 2:

projectPanorama(2, fov, hfov, tiltAngle, panAngle);

break;

case 4:

projectPanorama(3, fov, hfov, tiltAngle, panAngle);

break;

case 0:

if (_decoder->_isMouseButtonDown || _decoder->_isKeyDown) {

projectPanorama(1, fov, hfov, tiltAngle, panAngle);

} else {

projectPanorama(3, fov, hfov, tiltAngle, panAngle);

}

break;

default:

projectPanorama(3, fov, hfov, tiltAngle, panAngle);

break;

}

} else if (_decoder->_transitionMode == kTransitionModeSwing) {

swingTransitionHandler();

}

if (_decoder->_cursorDirty) {

_decoder->_cursorDirty = false;

_decoder->updateQTVRCursor(_decoder->_cursorPos.x, _decoder->_cursorPos.y);

}

return _projectedPano;

}

const Graphics::Surface *QuickTimeDecoder::PanoTrackHandler::bufferNextFrame() {

return nullptr;

}

Graphics::Surface *QuickTimeDecoder::PanoTrackHandler::constructMosaic(VideoTrackHandler *track, uint w, uint h, Common::String fname) {

int16 framew = track->getWidth();

int16 frameh = track->getHeight();

Graphics::Surface *target = new Graphics::Surface();

target->create(w * framew, h * frameh, track->getPixelFormat());

debugC(1, kDebugLevelGVideo, "Pixel format: %s", track->getPixelFormat().toString().c_str());

Common::Rect srcRect(0, 0, framew, frameh);

for (uint y = 0; y < h; y++) {

for (uint x = 0; x < w; x++) {

const Graphics::Surface *frame = track->bufferNextFrame();

if (!frame) {

warning("QuickTimeDecoder::PanoTrackHandler::constructMosaic(): Out of frames at: %d, %d", x, y);

break;

}

target->copyRectToSurface(*frame, x * framew, y * frameh, srcRect);

}

}

if (ConfMan.getBool("dump_scripts")) {

Common::Path path = Common::Path(fname);

Common::DumpFile bitmapFile;

if (!bitmapFile.open(path, true)) {

warning("Cannot dump panorama into file '%s'", path.toString().c_str());

target->free();

delete target;

return nullptr;

}

Image::writePNG(bitmapFile, *target, track->getPalette());

bitmapFile.close();

debug(0, "Dumped panorama %s of %d x %d", path.toString().c_str(), target->w, target->h);

}

return target;

}

void QuickTimeDecoder::PanoTrackHandler::initPanorama() {

if (_decoder->_panoTrack->panoInfo.nodes.size() == 0) {

// This is a single node panorama

// We add one node to the list, so the rest of our code

// is happy

PanoTrackSample *sample = &_parent->panoSamples[0];

_decoder->_panoTrack->panoInfo.nodes.resize(1);

_decoder->_panoTrack->panoInfo.nodes[0].nodeID = sample->hdr.nodeID;

_decoder->_panoTrack->panoInfo.nodes[0].timestamp = 0;

_decoder->_panoTrack->panoInfo.defNodeID = sample->hdr.nodeID;

}

_decoder->goToNode(_decoder->_panoTrack->panoInfo.defNodeID);

}

Graphics::Surface *QuickTimeDecoder::PanoTrackHandler::upscalePanorama(Graphics::Surface *sourceSurface, int8 level) {

// This algorithm (bilinear upscaling) takes quite some time to complete

//

// upscaling method

//

// for level 1 upscaling

// a | b a | avg(a, b) | b

// ----- => -----------------

// c | d c | avg(c, d) | d

//

// for level 2 upscaling

// a | avg(a, b) | b

// a | b -----------------------------------------

// ----- => avg(a, c) [e] | avg(e, f) | avg(b, d) [f]

// c | d -----------------------------------------

// c | avg(c, d) | d

uint w = sourceSurface->w;

uint h = sourceSurface->h;

Graphics::Surface *target = new Graphics::Surface();

if (level == 2) {

target->create(w * 2, h * 2, sourceSurface->format);

for (uint y = 0; y < h; ++y) {

for (uint x = 0; x < w; ++x) {

// For the row x==w and column y==h, wrap around the panorama

// and average these pixels with row x==0 and column y==0 respectively

uint x1 = (x + 1) % w;

uint y1 = (y + 1) % h;

// Couldn't find a better way to do this

// Should I write a function in the Surface or PixelFormat class?

int32 p00 = sourceSurface->getPixel(x, y);

int32 p01 = sourceSurface->getPixel(x, y1);

int32 p10 = sourceSurface->getPixel(x1, y);

int32 p11 = sourceSurface->getPixel(x1, y1);

uint8 a00, r00, g00, b00;

uint8 a01, r01, g01, b01;

uint8 a10, r10, g10, b10;

uint8 a11, r11, g11, b11;

sourceSurface->format.colorToARGB(p00, a00, r00, g00, b00);

sourceSurface->format.colorToARGB(p01, a01, r01, g01, b01);

sourceSurface->format.colorToARGB(p10, a10, r10, g10, b10);

sourceSurface->format.colorToARGB(p11, a11, r11, g11, b11);

int32 avgPixel00 = p00;

int32 avgPixel01 = sourceSurface->format.ARGBToColor((a00 + a01) >> 1, (r00 + r01) >> 1, (g00 + g01) >> 1, (b00 + b01) >> 1);

int32 avgPixel10 = sourceSurface->format.ARGBToColor((a00 + a10) >> 1, (r00 + r10) >> 1, (g00 + g10) >> 1, (b00 + b10) >> 1);

int32 avgPixel11 = sourceSurface->format.ARGBToColor(

(a00 + a01 + a10 + a11) >> 2,

(r00 + r01 + r10 + r11) >> 2,

(g00 + g01 + g10 + g11) >> 2,

(b00 + b01 + b10 + b11) >> 2);

target->setPixel(x * 2, y * 2, avgPixel00);

target->setPixel(x * 2, y * 2 + 1, avgPixel01);

target->setPixel(x * 2 + 1, y * 2, avgPixel10);

target->setPixel(x * 2 + 1, y * 2 + 1,avgPixel11);

}

}

} else {

target->create(w * 2, h, sourceSurface->format);

for (uint y = 0; y < h; ++y) {

for (uint x = 0; x < w; ++x) {

uint x1 = (x + 1) % w;

int32 p00 = sourceSurface->getPixel(x, y);

int32 p01 = sourceSurface->getPixel(x1, y);

uint8 a00, r00, g00, b00;

uint8 a01, r01, g01, b01;

sourceSurface->format.colorToARGB(p00, a00, r00, g00, b00);

sourceSurface->format.colorToARGB(p01, a01, r01, g01, b01);

int32 avgPixel00 = p00;

int32 avgPixel01 = sourceSurface->format.ARGBToColor((a00 + a01) >> 1, (r00 + r01) >> 1, (g00 + g01) >> 1, (b00 + b01) >> 1);

target->setPixel(x * 2, y, avgPixel00);

target->setPixel(x * 2 + 1, y, avgPixel01);

}

}

}

return target;

}

void QuickTimeDecoder::PanoTrackHandler::boxAverage(Graphics::Surface *sourceSurface, uint8 scaleFactor) {

uint16 h = sourceSurface->h;

uint16 w = sourceSurface->w;

// Apply box average if quality is higher than 1

// Otherwise it'll be quicker to just copy the _planarProjection onto _projectedPano

if (scaleFactor == 1) {

_projectedPano->copyFrom(*sourceSurface);

return;

}

uint8 scaleSquare = scaleFactor * scaleFactor;

// Average out the pixels from the larger image

for (uint16 y = 0; y < h / scaleFactor; y++) {

for (uint16 x = 0; x < w / scaleFactor; x++) {

uint16 avgA = 0, avgR = 0, avgG = 0, avgB = 0;

for (uint8 row = 0; row < scaleFactor; row++) {

for (uint8 column = 0; column < scaleFactor; column++) {

uint8 a00, r00, g00, b00;

uint32 pixel00 = sourceSurface->getPixel(MIN((x * scaleFactor + row), w - 1), MIN((y * scaleFactor + column), h - 1));

_projectedPano->format.colorToARGB(pixel00, a00, r00, g00, b00);

avgA += a00;

avgR += r00;

avgG += g00;

avgB += b00;

}

}

avgA /= scaleSquare;

avgR /= scaleSquare;

avgG /= scaleSquare;

avgB /= scaleSquare;

uint32 avgPixel = _projectedPano->format.ARGBToColor(avgA, avgR, avgG, avgB);

_projectedPano->setPixel(x, y, avgPixel);

}

}

}

void QuickTimeDecoder::PanoTrackHandler::constructPanorama() {

PanoSampleDesc *desc = (PanoSampleDesc *)_parent->sampleDescs[0];

PanoTrackSample *sample = &_parent->panoSamples[_decoder->_currentSample];

if (_constructedPano) {

_constructedPano->free();

delete _constructedPano;

if (_constructedHotspots) {

_constructedHotspots->free();

delete _constructedHotspots;

}

}

debugC(1, kDebugLevelGVideo, "scene: %d (%d x %d) hotspots: %d (%d x %d)", desc->_sceneTrackID, desc->_sceneSizeX, desc->_sceneSizeY,

desc->_hotSpotTrackID, desc->_hotSpotSizeX, desc->_hotSpotSizeY);

debugC(1, kDebugLevelGVideo, "sceneNumFrames: %d x %d sceneColorDepth: %d", desc->_sceneNumFramesX, desc->_sceneNumFramesY, desc->_sceneColorDepth);

debugC(1, kDebugLevelGVideo, "Node idx: %d", sample->hdr.nodeID);

int nodeidx = -1;

for (int i = 0; i < (int)_parent->panoInfo.nodes.size(); i++)

if (_parent->panoInfo.nodes[i].nodeID == sample->hdr.nodeID) {

nodeidx = i;

break;

}

if (nodeidx == -1) {

warning("constructPanorama(): Missing node %d in panoInfo", sample->hdr.nodeID);

nodeidx = 0;

}

uint32 timestamp = _parent->panoInfo.nodes[nodeidx].timestamp;

debugC(1, kDebugLevelGVideo, "Timestamp: %d", timestamp);

VideoTrackHandler *track = (VideoTrackHandler *)(_decoder->getTrack(_decoder->Common::QuickTimeParser::_tracks[desc->_sceneTrackID - 1]->targetTrack));

track->seek(Audio::Timestamp(0, timestamp, _decoder->_timeScale));

_constructedPano = constructMosaic(track, desc->_sceneNumFramesX, desc->_sceneNumFramesY, "dumps/pano-full.png");

// _upscaleLevel = 0 means _contructedPano has just been constructed, hasn't been upscaled yet

// or that the upscaledConstructedPanorama has upscaled a different panorama, not the current constructedPano

_upscaleLevel = 0;

if (desc->_hotSpotTrackID) {

track = (VideoTrackHandler *)(_decoder->getTrack(_decoder->Common::QuickTimeParser::_tracks[desc->_hotSpotTrackID - 1]->targetTrack));

track->seek(Audio::Timestamp(0, timestamp, _decoder->_timeScale));

_constructedHotspots = constructMosaic(track, desc->_hotSpotNumFramesX, desc->_hotSpotNumFramesY, "dumps/pano-hotspot.png");

}

_isPanoConstructed = true;

}

Common::Point QuickTimeDecoder::PanoTrackHandler::projectPoint(int16 mx, int16 my) {

if (!_isPanoConstructed || !_constructedHotspots)

return Common::Point(-1, -1);

uint16 w = _decoder->getWidth(), h = _decoder->getHeight();

uint16 hotWidth = _constructedHotspots->w, hotHeight = _constructedHotspots->h;

PanoSampleDesc *desc = (PanoSampleDesc *)_parent->sampleDescs[0];

float cornerVectors[3][3];

float *topRightVector = cornerVectors[0];

float *bottomRightVector = cornerVectors[1];

float *mousePixelVector = cornerVectors[2];

bottomRightVector[1] = tan(_decoder->_fov * M_PI / 360.0);

bottomRightVector[0] = bottomRightVector[1] * (float)w / (float)h;

bottomRightVector[2] = 1.0f;

topRightVector[0] = bottomRightVector[0];

topRightVector[1] = -bottomRightVector[1];

topRightVector[2] = bottomRightVector[2];

// Apply pitch (tilt) rotation

float cosTilt = cos(-_decoder->_tiltAngle * M_PI / 180.0);

float sinTilt = sin(-_decoder->_tiltAngle * M_PI / 180.0);

for (int v = 0; v < 2; v++) {

float y = cornerVectors[v][1];

float z = cornerVectors[v][2];

float newZ = z * cosTilt - y * sinTilt;

float newY = y * cosTilt + z * sinTilt;

cornerVectors[v][1] = newY;