#include "video/smk_decoder.h"

#include "common/endian.h"

#include "common/util.h"

#include "common/stream.h"

#include "common/bitarray.h"

#include "common/bitstream.h"

#include "common/system.h"

#include "common/textconsole.h"

#include "audio/audiostream.h"

#include "audio/mixer.h"

#include "audio/decoders/raw.h"

namespace Video {

enum SmkBlockTypes {

};

class SmallHuffmanTree {

};

SmallHuffmanTree::SmallHuffmanTree(SmackerBitStream &bs)

}

uint16 SmallHuffmanTree::decodeTree(uint32 prefix, int length) {

}

uint16 SmallHuffmanTree::getCode(SmackerBitStream &bs) {

}

class BigHuffmanTree {

};

BigHuffmanTree::BigHuffmanTree(SmackerBitStream &bs, int allocSize)

}

BigHuffmanTree::~BigHuffmanTree() {

delete[] _tree;

}

void BigHuffmanTree::reset() {

_tree[_last[0]] = _tree[_last[1]] = _tree[_last[2]] = 0;

}

uint32 BigHuffmanTree::decodeTree(uint32 prefix, int length) {

}

uint32 BigHuffmanTree::getCode(SmackerBitStream &bs) {

}

SmackerDecoder::SmackerDecoder() {

}

SmackerDecoder::~SmackerDecoder() {

close();

}

uint32 SmackerDecoder::getSignatureVersion(uint32 signature) const {

}

bool SmackerDecoder::loadStream(Common::SeekableReadStream *stream) {

}

void SmackerDecoder::close() {

}

bool SmackerDecoder::rewind() {

}

const Graphics::Surface *SmackerDecoder::forceSeekToFrame(uint frame) {

uint seekFrame;

if (frame >= 10)

seekFrame = MAX<uint>(frame - 10, 0);

else

seekFrame = 0;

if (!isVideoLoaded())

return nullptr;

if (seekFrame >= getFrameCount())

return nullptr;

if (!rewind())

return nullptr;

stopAudio();

SmackerVideoTrack *videoTrack = (SmackerVideoTrack *)getTrack(0);

uint32 startPos = _fileStream->pos();

uint32 offset = 0;

for (uint32 i = 0; i < seekFrame; i++) {

videoTrack->increaseCurFrame();

// Frames with palette data contain palette entries which use

// the previous palette as their base. Therefore, we need to

// parse all palette entries up to the requested frame

if (_frameTypes[videoTrack->getCurFrame()] & 1) {

_fileStream->seek(startPos + offset, SEEK_SET);

videoTrack->unpackPalette(_fileStream);

}

offset += _frameSizes[i] & ~3;

}

if (!_fileStream->seek(startPos + offset, SEEK_SET))

return nullptr;

const Graphics::Surface *surface = nullptr;

while (getCurFrame() < (int)frame) {

surface = decodeNextFrame();

}

_lastTimeChange = videoTrack->getFrameTime(frame);

if (isPlaying()) {

_startTime = g_system->getMillis() - (_lastTimeChange.msecs() / getRate()).toInt();

}

resetPauseStartTime();

return surface;

}

void SmackerDecoder::readNextPacket() {

}

void SmackerDecoder::handleAudioTrack(byte track, uint32 chunkSize, uint32 unpackedSize) {

}

VideoDecoder::AudioTrack *SmackerDecoder::getAudioTrack(int index) {

// Smacker audio track indexes are relative to the first audio track

Track *track = getTrack(index + 1);

if (!track || track->getTrackType() != Track::kTrackTypeAudio)

return 0;

return (AudioTrack *)track;

}

SmackerDecoder::SmackerVideoTrack::SmackerVideoTrack(uint32 width, uint32 height, uint32 frameCount, const Common::Rational &frameRate, uint32 flags, uint32 version) : _palette(256) {

_surface = new Graphics::Surface();

_surface->create(width, height * ((flags & 6) ? 2 : 1), Graphics::PixelFormat::createFormatCLUT8());

_dirtyBlocks.set_size(width * height / 16);

_frameCount = frameCount;

_frameRate = frameRate;

_flags = flags;

_version = version;

_curFrame = -1;

_dirtyPalette = false;

_MMapTree = _MClrTree = _FullTree = _TypeTree = 0;

}

SmackerDecoder::SmackerVideoTrack::~SmackerVideoTrack() {

_surface->free();

delete _surface;

delete _MMapTree;

delete _MClrTree;

delete _FullTree;

delete _TypeTree;

}

uint16 SmackerDecoder::SmackerVideoTrack::getWidth() const {

return _surface->w;

}

uint16 SmackerDecoder::SmackerVideoTrack::getHeight() const {

return _surface->h;

}

Graphics::PixelFormat SmackerDecoder::SmackerVideoTrack::getPixelFormat() const {

return _surface->format;

}

void SmackerDecoder::SmackerVideoTrack::readTrees(SmackerBitStream &bs, uint32 mMapSize, uint32 mClrSize, uint32 fullSize, uint32 typeSize) {

_MMapTree = new BigHuffmanTree(bs, mMapSize);

_MClrTree = new BigHuffmanTree(bs, mClrSize);

_FullTree = new BigHuffmanTree(bs, fullSize);

_TypeTree = new BigHuffmanTree(bs, typeSize);

}

void SmackerDecoder::SmackerVideoTrack::decodeFrame(SmackerBitStream &bs) {

_MMapTree->reset();

_MClrTree->reset();

_FullTree->reset();

_TypeTree->reset();

_dirtyBlocks.clear();

// Height needs to be doubled if we have flags (Y-interlaced or Y-doubled)

uint doubleY = (_flags & 6) ? 2 : 1;

uint bw = getWidth() / 4;

uint bh = getHeight() / doubleY / 4;

uint stride = getWidth();

uint block = 0, blocks = bw*bh;

byte *out;

uint type, run, j, mode;

uint32 p1, p2, clr, map;

byte hi, lo;

uint i;

while (block < blocks) {

type = _TypeTree->getCode(bs);

run = getBlockRun((type >> 2) & 0x3f);

switch (type & 3) {

case SMK_BLOCK_MONO:

while (run-- && block < blocks) {

clr = _MClrTree->getCode(bs);

map = _MMapTree->getCode(bs);

out = (byte *)_surface->getPixels() + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;

hi = clr >> 8;

lo = clr & 0xff;

for (i = 0; i < 4; i++) {

for (j = 0; j < doubleY; j++) {

out[0] = (map & 1) ? hi : lo;

out[1] = (map & 2) ? hi : lo;

out[2] = (map & 4) ? hi : lo;

out[3] = (map & 8) ? hi : lo;

out += stride;

}

map >>= 4;

}

_dirtyBlocks.set(block);

++block;

}

break;

case SMK_BLOCK_FULL:

// Smacker v2 has one mode, Smacker v4 has three

if (_version == 2) {

mode = 0;

} else {

// 00 - mode 0

// 10 - mode 1

// 01 - mode 2

mode = 0;

if (bs.getBit()) {

mode = 1;

} else if (bs.getBit()) {

mode = 2;

}

}

while (run-- && block < blocks) {

out = (byte *)_surface->getPixels() + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;

switch (mode) {

case 0:

for (i = 0; i < 4; ++i) {

p1 = _FullTree->getCode(bs);

p2 = _FullTree->getCode(bs);

for (j = 0; j < doubleY; ++j) {

out[2] = p1 & 0xff;

out[3] = p1 >> 8;

out[0] = p2 & 0xff;

out[1] = p2 >> 8;

out += stride;

}

}

break;

case 1:

p1 = _FullTree->getCode(bs);

out[0] = out[1] = p1 & 0xFF;

out[2] = out[3] = p1 >> 8;

out += stride;

out[0] = out[1] = p1 & 0xFF;

out[2] = out[3] = p1 >> 8;

out += stride;

p2 = _FullTree->getCode(bs);

out[0] = out[1] = p2 & 0xFF;

out[2] = out[3] = p2 >> 8;

out += stride;

out[0] = out[1] = p2 & 0xFF;

out[2] = out[3] = p2 >> 8;

out += stride;

break;

case 2:

for (i = 0; i < 2; i++) {

// We first get p2 and then p1

// Check ffmpeg thread "[PATCH] Smacker video decoder bug fix"

// https://ffmpeg.org/pipermail/ffmpeg-devel/2008-December/044246.html

p2 = _FullTree->getCode(bs);

p1 = _FullTree->getCode(bs);

for (j = 0; j < doubleY; ++j) {

out[0] = p1 & 0xff;

out[1] = p1 >> 8;

out[2] = p2 & 0xff;

out[3] = p2 >> 8;

out += stride;

}

for (j = 0; j < doubleY; ++j) {

out[0] = p1 & 0xff;

out[1] = p1 >> 8;

out[2] = p2 & 0xff;

out[3] = p2 >> 8;

out += stride;

}

}

break;

default:

break;

}

_dirtyBlocks.set(block);

++block;

}

break;

case SMK_BLOCK_SKIP:

while (run-- && block < blocks)

block++;

break;

case SMK_BLOCK_FILL:

uint32 col;

mode = type >> 8;

while (run-- && block < blocks) {

out = (byte *)_surface->getPixels() + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;

col = mode * 0x01010101;

for (i = 0; i < 4 * doubleY; ++i) {

out[0] = out[1] = out[2] = out[3] = col;

out += stride;

}

_dirtyBlocks.set(block);

++block;

}

break;

default:

break;

}

}

}

void SmackerDecoder::SmackerVideoTrack::unpackPalette(Common::SeekableReadStream *stream) {

uint startPos = stream->pos();

uint32 len = 4 * stream->readByte();

byte *chunk = (byte *)malloc(len);

stream->read(chunk, len);

byte *p = chunk;

const byte *oldPalette = _palette.data();

byte newPalette[3 * 256];

_palette.grab(newPalette, 0, 256);

byte *pal = newPalette;

int sz = 0;

byte b0;

while (sz < 256) {

b0 = *p++;

if (b0 & 0x80) { // if top bit is 1 (0x80 = 10000000)

sz += (b0 & 0x7f) + 1; // get lower 7 bits + 1 (0x7f = 01111111)

pal += 3 * ((b0 & 0x7f) + 1);

} else if (b0 & 0x40) { // if top 2 bits are 01 (0x40 = 01000000)

byte c = (b0 & 0x3f) + 1; // get lower 6 bits + 1 (0x3f = 00111111)

uint s = 3 * *p++;

sz += c;

while (c--) {

*pal++ = oldPalette[s + 0];

*pal++ = oldPalette[s + 1];

*pal++ = oldPalette[s + 2];

s += 3;

}

} else { // top 2 bits are 00

sz++;

// get the lower 6 bits for each component (0x3f = 00111111)

byte r = b0 & 0x3f;

byte g = (*p++) & 0x3f;

byte b = (*p++) & 0x3f;

// upscale to full 8-bit color values. The Multimedia Wiki suggests

// a lookup table for this, but this should produce the same result.

*pal++ = (r * 4 + r / 16);

*pal++ = (g * 4 + g / 16);

*pal++ = (b * 4 + b / 16);

}

}

stream->seek(startPos + len);

free(chunk);

_palette.set(newPalette, 0, 256);

_dirtyPalette = true;

}

SmackerDecoder::SmackerAudioTrack::SmackerAudioTrack(const AudioInfo &audioInfo, Audio::Mixer::SoundType soundType) :

AudioTrack(soundType),

_audioInfo(audioInfo) {

_audioStream = Audio::makeQueuingAudioStream(_audioInfo.sampleRate, _audioInfo.isStereo);

}

SmackerDecoder::SmackerAudioTrack::~SmackerAudioTrack() {

delete _audioStream;

}

bool SmackerDecoder::SmackerAudioTrack::rewind() {

delete _audioStream;

_audioStream = Audio::makeQueuingAudioStream(_audioInfo.sampleRate, _audioInfo.isStereo);

return true;

}

Audio::AudioStream *SmackerDecoder::SmackerAudioTrack::getAudioStream() const {

return _audioStream;

}

void SmackerDecoder::SmackerAudioTrack::queueCompressedBuffer(byte *buffer, uint32 bufferSize, uint32 unpackedSize) {

SmackerBitStream audioBS(new Common::BitStreamMemoryStream(buffer, bufferSize), DisposeAfterUse::YES);

bool dataPresent = audioBS.getBit();

if (!dataPresent)

return;

bool isStereo = audioBS.getBit();

assert(isStereo == _audioInfo.isStereo);

bool is16Bits = audioBS.getBit();

assert(is16Bits == _audioInfo.is16Bits);

int numBytes = 1 * (isStereo ? 2 : 1) * (is16Bits ? 2 : 1);

byte *unpackedBuffer = (byte *)malloc(unpackedSize);

byte *curPointer = unpackedBuffer;

uint32 curPos = 0;

SmallHuffmanTree *audioTrees[4];

for (int k = 0; k < numBytes; k++)

audioTrees[k] = new SmallHuffmanTree(audioBS);

// Base values, stored as big endian

int32 bases[2];

if (isStereo) {

if (is16Bits) {

bases[1] = SWAP_BYTES_16(audioBS.getBits<16>());

} else {

bases[1] = audioBS.getBits<8>();

}

}

if (is16Bits) {

bases[0] = SWAP_BYTES_16(audioBS.getBits<16>());

} else {

bases[0] = audioBS.getBits<8>();

}

// The bases are the first samples, too

for (int i = 0; i < (isStereo ? 2 : 1); i++, curPointer += (is16Bits ? 2 : 1), curPos += (is16Bits ? 2 : 1)) {

if (is16Bits)

WRITE_BE_UINT16(curPointer, bases[i]);

else

*curPointer = (bases[i] & 0xFF) ^ 0x80;

}

// Next follow the deltas, which are added to the corresponding base values and

// are stored as little endian

// We store the unpacked bytes in big endian format

while (curPos < unpackedSize) {

// If the sample is stereo, the data is stored for the left and right channel, respectively

// (the exact opposite to the base values)

if (!is16Bits) {

for (int k = 0; k < (isStereo ? 2 : 1); k++) {

int8 delta = (int8) ((int16) audioTrees[k]->getCode(audioBS));

bases[k] = (bases[k] + delta) & 0xFF;

*curPointer++ = bases[k] ^ 0x80;

curPos++;

}

} else {

for (int k = 0; k < (isStereo ? 2 : 1); k++) {

byte lo = audioTrees[k * 2]->getCode(audioBS);

byte hi = audioTrees[k * 2 + 1]->getCode(audioBS);

bases[k] += (int16) (lo | (hi << 8));

WRITE_BE_UINT16(curPointer, bases[k]);

curPointer += 2;

curPos += 2;

}

}

}

for (int k = 0; k < numBytes; k++)

delete audioTrees[k];

queuePCM(unpackedBuffer, unpackedSize);

}

void SmackerDecoder::SmackerAudioTrack::queuePCM(byte *buffer, uint32 bufferSize) {

byte flags = 0;

if (_audioInfo.is16Bits)

flags |= Audio::FLAG_16BITS;

if (_audioInfo.isStereo)

flags |= Audio::FLAG_STEREO;

_audioStream->queueBuffer(buffer, bufferSize, DisposeAfterUse::YES, flags);

}

SmackerDecoder::SmackerVideoTrack *SmackerDecoder::createVideoTrack(uint32 width, uint32 height, uint32 frameCount, const Common::Rational &frameRate, uint32 flags, uint32 version) const {

return new SmackerVideoTrack(width, height, frameCount, frameRate, flags, version);

}

Common::Rational SmackerDecoder::getFrameRate() const {

}

const Common::Rect *SmackerDecoder::getNextDirtyRect() {

SmackerVideoTrack *videoTrack = (SmackerVideoTrack *)getTrack(0);

return videoTrack->getNextDirtyRect();

}

const Common::Rect *SmackerDecoder::SmackerVideoTrack::getNextDirtyRect() {

uint doubleY = (_flags & 6) ? 2 : 1;

uint bw = getWidth() / 4;

uint bh = getHeight() / 4;

uint blocks = bw*bh;

// Scan forward in dirty blocks bitarray for next dirty rect

uint block_idx = (_lastDirtyRect.left) / 4 + (_lastDirtyRect.top / 4 / doubleY) * bw;

while (block_idx < blocks && !_dirtyBlocks.get(block_idx)) {

++block_idx;

}

if (block_idx == blocks) {

_lastDirtyRect = Common::Rect();

return nullptr;

}

uint block_x0 = block_idx % bw;

uint block_y0 = block_idx / bw;

// Find the width of the dirty rect

uint block_x1 = block_x0 + 1;

while (block_x1 < bw && _dirtyBlocks.get(block_x1 + block_y0 * bw)) {

++block_x1;

}