2011-10-10 01:28:14 +00:00
|
|
|
/* ScummVM - Graphic Adventure Engine
|
|
|
|
*
|
|
|
|
* ScummVM is the legal property of its developers, whose names
|
|
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
|
|
* file distributed with this source distribution.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2014-02-18 01:34:27 +00:00
|
|
|
*
|
2011-10-10 01:28:14 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2014-02-18 01:34:27 +00:00
|
|
|
*
|
2011-10-10 01:28:14 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Sorenson Video 1 Codec
|
2012-04-07 23:35:45 +00:00
|
|
|
// Based off FFmpeg's SVQ1 decoder (written by Arpi and Nick Kurshev)
|
2011-10-10 01:28:14 +00:00
|
|
|
|
2014-02-28 02:27:23 +00:00
|
|
|
#include "image/codecs/svq1.h"
|
|
|
|
#include "image/codecs/svq1_cb.h"
|
|
|
|
#include "image/codecs/svq1_vlc.h"
|
2011-10-10 01:28:14 +00:00
|
|
|
|
|
|
|
#include "common/stream.h"
|
2012-03-30 03:27:09 +00:00
|
|
|
#include "common/bitstream.h"
|
2012-04-04 07:32:17 +00:00
|
|
|
#include "common/rect.h"
|
2011-10-10 01:28:14 +00:00
|
|
|
#include "common/system.h"
|
|
|
|
#include "common/debug.h"
|
|
|
|
#include "common/textconsole.h"
|
2012-04-05 01:15:15 +00:00
|
|
|
#include "common/huffman.h"
|
2011-10-10 01:28:14 +00:00
|
|
|
|
|
|
|
#include "graphics/yuv_to_rgb.h"
|
|
|
|
|
2014-02-28 02:27:23 +00:00
|
|
|
namespace Image {
|
2011-10-10 01:28:14 +00:00
|
|
|
|
2012-04-04 07:32:17 +00:00
|
|
|
#define SVQ1_BLOCK_SKIP 0
|
|
|
|
#define SVQ1_BLOCK_INTER 1
|
|
|
|
#define SVQ1_BLOCK_INTER_4V 2
|
|
|
|
#define SVQ1_BLOCK_INTRA 3
|
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
SVQ1Decoder::SVQ1Decoder(uint16 width, uint16 height) {
|
2012-04-05 04:08:08 +00:00
|
|
|
debug(1, "SVQ1Decoder::SVQ1Decoder(width:%d, height:%d)", width, height);
|
|
|
|
_width = width;
|
|
|
|
_height = height;
|
2012-04-06 03:12:19 +00:00
|
|
|
_frameWidth = _frameHeight = 0;
|
|
|
|
_surface = 0;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
_last[0] = 0;
|
|
|
|
_last[1] = 0;
|
|
|
|
_last[2] = 0;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// Setup Variable Length Code Tables
|
|
|
|
_blockType = new Common::Huffman(0, 4, s_svq1BlockTypeCodes, s_svq1BlockTypeLengths);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
for (int i = 0; i < 6; i++) {
|
|
|
|
_intraMultistage[i] = new Common::Huffman(0, 8, s_svq1IntraMultistageCodes[i], s_svq1IntraMultistageLengths[i]);
|
|
|
|
_interMultistage[i] = new Common::Huffman(0, 8, s_svq1InterMultistageCodes[i], s_svq1InterMultistageLengths[i]);
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
_intraMean = new Common::Huffman(0, 256, s_svq1IntraMeanCodes, s_svq1IntraMeanLengths);
|
|
|
|
_interMean = new Common::Huffman(0, 512, s_svq1InterMeanCodes, s_svq1InterMeanLengths);
|
|
|
|
_motionComponent = new Common::Huffman(0, 33, s_svq1MotionComponentCodes, s_svq1MotionComponentLengths);
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
SVQ1Decoder::~SVQ1Decoder() {
|
2012-04-06 03:12:19 +00:00
|
|
|
if (_surface) {
|
|
|
|
_surface->free();
|
|
|
|
delete _surface;
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
delete[] _last[0];
|
|
|
|
delete[] _last[1];
|
|
|
|
delete[] _last[2];
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
delete _blockType;
|
|
|
|
delete _intraMean;
|
|
|
|
delete _interMean;
|
|
|
|
delete _motionComponent;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
for (int i = 0; i < 6; i++) {
|
|
|
|
delete _intraMultistage[i];
|
|
|
|
delete _interMultistage[i];
|
|
|
|
}
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
#define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
|
2012-04-07 04:36:19 +00:00
|
|
|
|
2014-02-28 02:27:24 +00:00
|
|
|
const Graphics::Surface *SVQ1Decoder::decodeFrame(Common::SeekableReadStream &stream) {
|
2012-04-05 01:15:15 +00:00
|
|
|
debug(1, "SVQ1Decoder::decodeImage()");
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2014-02-28 02:27:24 +00:00
|
|
|
Common::BitStream32BEMSB frameData(stream);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
uint32 frameCode = frameData.getBits(22);
|
|
|
|
debug(1, " frameCode: %d", frameCode);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
if ((frameCode & ~0x70) || !(frameCode & 0x60)) { // Invalid
|
|
|
|
warning("Invalid Image at frameCode");
|
|
|
|
return _surface;
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
byte temporalReference = frameData.getBits(8);
|
|
|
|
debug(1, " temporalReference: %d", temporalReference);
|
2012-04-07 23:35:45 +00:00
|
|
|
static const char *const types[4] = { "I (Key)", "P (Delta from Previous)", "B (Delta from Next)", "Invalid" };
|
2012-04-05 01:15:15 +00:00
|
|
|
byte frameType = frameData.getBits(2);
|
|
|
|
debug(1, " frameType: %d = %s Frame", frameType, types[frameType]);
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
if (frameType == 0) { // I Frame
|
|
|
|
// TODO: Validate checksum if present
|
|
|
|
if (frameCode == 0x50 || frameCode == 0x60) {
|
|
|
|
uint32 checksum = frameData.getBits(16);
|
|
|
|
debug(1, " checksum:0x%02x", checksum);
|
2012-04-07 23:35:45 +00:00
|
|
|
// We're currently just ignoring the checksum
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
2012-04-05 04:08:08 +00:00
|
|
|
|
|
|
|
if ((frameCode ^ 0x10) >= 0x50) {
|
2012-04-06 05:25:01 +00:00
|
|
|
// Skip embedded string
|
2012-04-07 23:35:45 +00:00
|
|
|
byte stringLen = frameData.getBits(8);
|
2012-04-06 05:25:01 +00:00
|
|
|
for (uint16 i = 0; i < stringLen-1; i++)
|
|
|
|
frameData.skip(8);
|
2012-04-05 04:08:08 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
frameData.skip(5); // Unknown
|
2012-04-05 04:08:08 +00:00
|
|
|
|
|
|
|
static const struct { uint w, h; } standardFrameSizes[7] = {
|
|
|
|
{ 160, 120 }, // 0
|
|
|
|
{ 128, 96 }, // 1
|
|
|
|
{ 176, 144 }, // 2
|
|
|
|
{ 352, 288 }, // 3
|
|
|
|
{ 704, 576 }, // 4
|
|
|
|
{ 240, 180 }, // 5
|
|
|
|
{ 320, 240 } // 6
|
|
|
|
};
|
|
|
|
|
|
|
|
byte frameSizeCode = frameData.getBits(3);
|
|
|
|
debug(1, " frameSizeCode: %d", frameSizeCode);
|
2012-04-06 03:12:19 +00:00
|
|
|
|
2012-04-05 04:08:08 +00:00
|
|
|
if (frameSizeCode == 7) {
|
2012-04-06 03:12:19 +00:00
|
|
|
_frameWidth = frameData.getBits(12);
|
|
|
|
_frameHeight = frameData.getBits(12);
|
2012-04-05 04:08:08 +00:00
|
|
|
} else {
|
2012-04-06 03:12:19 +00:00
|
|
|
_frameWidth = standardFrameSizes[frameSizeCode].w;
|
|
|
|
_frameHeight = standardFrameSizes[frameSizeCode].h;
|
2012-04-05 04:08:08 +00:00
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-06 03:12:19 +00:00
|
|
|
debug(1, " frameWidth: %d", _frameWidth);
|
|
|
|
debug(1, " frameHeight: %d", _frameHeight);
|
2012-04-05 01:15:15 +00:00
|
|
|
} else if (frameType == 2) { // B Frame
|
2012-04-07 23:35:45 +00:00
|
|
|
warning("B Frames not supported by SVQ1 decoder (yet)");
|
2012-04-05 01:15:15 +00:00
|
|
|
return _surface;
|
|
|
|
} else if (frameType == 3) { // Invalid
|
|
|
|
warning("Invalid Frame Type");
|
|
|
|
return _surface;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
bool checksumPresent = frameData.getBit() != 0;
|
2012-04-05 01:15:15 +00:00
|
|
|
debug(1, " checksumPresent: %d", checksumPresent);
|
|
|
|
if (checksumPresent) {
|
2012-04-07 23:35:45 +00:00
|
|
|
bool usePacketChecksum = frameData.getBit() != 0;
|
2012-04-05 01:15:15 +00:00
|
|
|
debug(1, " usePacketChecksum: %d", usePacketChecksum);
|
2012-04-07 23:35:45 +00:00
|
|
|
bool componentChecksumsAfterImageData = frameData.getBit() != 0;
|
2012-04-05 01:15:15 +00:00
|
|
|
debug(1, " componentChecksumsAfterImageData: %d", componentChecksumsAfterImageData);
|
|
|
|
byte unk4 = frameData.getBits(2);
|
|
|
|
debug(1, " unk4: %d", unk4);
|
|
|
|
if (unk4 != 0)
|
|
|
|
warning("Invalid Frame Header in SVQ1 Frame Decode");
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
// Some more unknown data
|
|
|
|
bool unk5 = frameData.getBit() != 0;
|
2012-04-05 01:15:15 +00:00
|
|
|
if (unk5) {
|
2012-04-07 23:35:45 +00:00
|
|
|
frameData.skip(8);
|
|
|
|
|
|
|
|
while (frameData.getBit() != 0)
|
|
|
|
frameData.skip(8);
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
2012-09-19 19:58:18 +00:00
|
|
|
uint yWidth = ALIGN(_frameWidth, 16);
|
|
|
|
uint yHeight = ALIGN(_frameHeight, 16);
|
|
|
|
uint uvWidth = ALIGN(yWidth / 4, 16);
|
|
|
|
uint uvHeight = ALIGN(yHeight / 4, 16);
|
|
|
|
uint uvPitch = uvWidth + 4; // we need at least one extra column and pitch must be divisible by 4
|
2012-04-07 04:36:19 +00:00
|
|
|
|
2012-04-05 04:08:08 +00:00
|
|
|
byte *current[3];
|
|
|
|
|
|
|
|
// Decode Y, U and V component planes
|
|
|
|
for (int i = 0; i < 3; i++) {
|
2012-09-19 19:58:18 +00:00
|
|
|
uint width, height, pitch;
|
2012-04-05 04:08:08 +00:00
|
|
|
if (i == 0) {
|
2012-04-14 21:06:31 +00:00
|
|
|
width = yWidth;
|
2012-04-07 04:36:19 +00:00
|
|
|
height = yHeight;
|
2012-09-19 19:58:18 +00:00
|
|
|
pitch = width;
|
2012-04-14 21:06:31 +00:00
|
|
|
current[i] = new byte[width * height];
|
2012-04-05 04:08:08 +00:00
|
|
|
} else {
|
2012-04-14 21:06:31 +00:00
|
|
|
width = uvWidth;
|
2012-04-07 04:36:19 +00:00
|
|
|
height = uvHeight;
|
2012-09-19 19:58:18 +00:00
|
|
|
pitch = uvPitch;
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-09-19 19:58:18 +00:00
|
|
|
// Add an extra row here. See below for more information.
|
|
|
|
current[i] = new byte[pitch * (height + 1)];
|
2012-04-14 21:06:31 +00:00
|
|
|
}
|
2012-04-07 04:36:19 +00:00
|
|
|
|
2012-04-05 04:08:08 +00:00
|
|
|
if (frameType == 0) { // I Frame
|
|
|
|
// Keyframe (I)
|
|
|
|
byte *currentP = current[i];
|
|
|
|
for (uint16 y = 0; y < height; y += 16) {
|
|
|
|
for (uint16 x = 0; x < width; x += 16) {
|
2012-09-19 19:58:18 +00:00
|
|
|
if (!svq1DecodeBlockIntra(&frameData, ¤tP[x], pitch)) {
|
2012-04-07 01:56:39 +00:00
|
|
|
warning("svq1DecodeBlockIntra decode failure");
|
2012-04-05 04:08:08 +00:00
|
|
|
return _surface;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
}
|
2012-09-19 19:58:18 +00:00
|
|
|
currentP += 16 * pitch;
|
2012-04-05 04:08:08 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Delta frame (P or B)
|
|
|
|
|
|
|
|
// Prediction Motion Vector
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *pmv = new Common::Point[(width / 8) + 3];
|
2012-04-05 04:08:08 +00:00
|
|
|
|
2012-11-18 20:52:47 +00:00
|
|
|
byte *previous = 0;
|
2012-04-07 23:35:45 +00:00
|
|
|
if (frameType == 2) { // B Frame
|
2012-11-18 21:00:07 +00:00
|
|
|
error("SVQ1 Video: B Frames not supported");
|
2012-04-05 04:08:08 +00:00
|
|
|
//previous = _next[i];
|
2012-04-07 23:35:45 +00:00
|
|
|
} else {
|
2012-04-05 04:08:08 +00:00
|
|
|
previous = _last[i];
|
2012-04-07 23:35:45 +00:00
|
|
|
}
|
2012-04-05 04:08:08 +00:00
|
|
|
|
|
|
|
byte *currentP = current[i];
|
|
|
|
for (uint16 y = 0; y < height; y += 16) {
|
|
|
|
for (uint16 x = 0; x < width; x += 16) {
|
2012-09-19 19:58:18 +00:00
|
|
|
if (!svq1DecodeDeltaBlock(&frameData, ¤tP[x], previous, pitch, pmv, x, y)) {
|
2012-04-07 01:56:39 +00:00
|
|
|
warning("svq1DecodeDeltaBlock decode failure");
|
2012-04-05 04:08:08 +00:00
|
|
|
return _surface;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-05 04:08:08 +00:00
|
|
|
}
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-04-05 04:08:08 +00:00
|
|
|
pmv[0].x = pmv[0].y = 0;
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-09-19 19:58:18 +00:00
|
|
|
currentP += 16 * pitch;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-05 04:08:08 +00:00
|
|
|
delete[] pmv;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-05 04:08:08 +00:00
|
|
|
}
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-04-07 04:36:19 +00:00
|
|
|
// Now we'll create the surface
|
|
|
|
if (!_surface) {
|
|
|
|
_surface = new Graphics::Surface();
|
|
|
|
_surface->create(yWidth, yHeight, g_system->getScreenFormat());
|
|
|
|
_surface->w = _width;
|
|
|
|
_surface->h = _height;
|
|
|
|
}
|
|
|
|
|
2012-09-19 19:58:18 +00:00
|
|
|
// We need to massage the chrominance data a bit to be able to be used by the converter
|
|
|
|
// Since the thing peeks at values one column and one row beyond the data, we need to fill it in
|
|
|
|
|
|
|
|
// First, fill in the column-after-last with the last column's value
|
|
|
|
for (uint i = 0; i < uvHeight; i++) {
|
|
|
|
current[1][i * uvPitch + uvWidth] = current[1][i * uvPitch + uvWidth - 1];
|
|
|
|
current[2][i * uvPitch + uvWidth] = current[2][i * uvPitch + uvWidth - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Then, copy the last row to the one after the last row
|
|
|
|
memcpy(current[1] + uvHeight * uvPitch, current[1] + (uvHeight - 1) * uvPitch, uvWidth + 1);
|
|
|
|
memcpy(current[2] + uvHeight * uvPitch, current[2] + (uvHeight - 1) * uvPitch, uvWidth + 1);
|
|
|
|
|
|
|
|
// Finally, actually do the conversion ;)
|
|
|
|
YUVToRGBMan.convert410(_surface, Graphics::YUVToRGBManager::kScaleFull, current[0], current[1], current[2], yWidth, yHeight, yWidth, uvPitch);
|
2012-04-05 04:08:08 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
// Store the current surfaces for later and free the old ones
|
2012-04-05 04:08:08 +00:00
|
|
|
for (int i = 0; i < 3; i++) {
|
2012-04-05 10:37:09 +00:00
|
|
|
delete[] _last[i];
|
2012-04-05 04:08:08 +00:00
|
|
|
_last[i] = current[i];
|
|
|
|
}
|
2012-04-05 01:15:15 +00:00
|
|
|
|
|
|
|
return _surface;
|
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1DecodeBlockIntra(Common::BitStream32BEMSB *s, byte *pixels, int pitch) {
|
2012-04-05 01:15:15 +00:00
|
|
|
// initialize list for breadth first processing of vectors
|
2012-04-07 23:35:45 +00:00
|
|
|
byte *list[63];
|
2012-04-05 01:15:15 +00:00
|
|
|
list[0] = pixels;
|
|
|
|
|
|
|
|
// recursively process vector
|
2012-04-07 23:35:45 +00:00
|
|
|
for (int i = 0, m = 1, n = 1, level = 5; i < n; i++) {
|
2012-04-05 01:15:15 +00:00
|
|
|
for (; level > 0; i++) {
|
|
|
|
// process next depth
|
|
|
|
if (i == m) {
|
|
|
|
m = n;
|
|
|
|
if (--level == 0)
|
|
|
|
break;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-04 07:32:17 +00:00
|
|
|
// divide block if next bit set
|
|
|
|
if (s->getBit() == 0)
|
|
|
|
break;
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-04 07:32:17 +00:00
|
|
|
// add child nodes
|
|
|
|
list[n++] = list[i];
|
|
|
|
list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
// destination address and vector size
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 *dst = (uint32 *)list[i];
|
|
|
|
uint width = 1 << ((level + 4) / 2);
|
|
|
|
uint height = 1 << ((level + 3) / 2);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// get number of stages (-1 skips vector, 0 for mean only)
|
2012-04-07 23:35:45 +00:00
|
|
|
int stages = _intraMultistage[level]->getSymbol(*s) - 1;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
if (stages == -1) {
|
2012-04-07 23:35:45 +00:00
|
|
|
for (uint y = 0; y < height; y++)
|
|
|
|
memset(&dst[y * (pitch / 4)], 0, width);
|
|
|
|
|
|
|
|
continue; // skip vector
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
if (stages > 0 && level >= 4) {
|
|
|
|
warning("Error (svq1_decode_block_intra): invalid vector: stages = %d, level = %d", stages, level);
|
2012-04-07 05:22:16 +00:00
|
|
|
return false; // error - invalid vector
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
int mean = _intraMean->getSymbol(*s);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
if (stages == 0) {
|
2012-04-07 23:35:45 +00:00
|
|
|
for (uint y = 0; y < height; y++)
|
|
|
|
memset(&dst[y * (pitch / 4)], mean, width);
|
2012-04-05 01:15:15 +00:00
|
|
|
} else {
|
2012-08-27 17:19:53 +00:00
|
|
|
const uint32 *codebook = (const uint32 *)s_svq1IntraCodebooks[level];
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 bitCache = s->getBits(stages * 4);
|
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// calculate codebook entries for this vector
|
2012-04-07 23:35:45 +00:00
|
|
|
int entries[6];
|
|
|
|
for (int j = 0; j < stages; j++)
|
|
|
|
entries[j] = (((bitCache >> ((stages - j - 1) * 4)) & 0xF) + j * 16) << (level + 1);
|
|
|
|
|
|
|
|
mean -= stages * 128;
|
|
|
|
uint32 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
|
|
|
|
|
|
|
|
for (uint y = 0; y < height; y++) {
|
|
|
|
for (uint x = 0; x < (width / 4); x++, codebook++) {
|
|
|
|
uint32 n1 = n4;
|
|
|
|
uint32 n2 = n4;
|
|
|
|
uint32 n3;
|
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// add codebook entries to vector
|
2012-04-07 23:35:45 +00:00
|
|
|
for (int j = 0; j < stages; j++) {
|
2012-08-27 17:19:53 +00:00
|
|
|
n3 = READ_UINT32(&codebook[entries[j]]) ^ 0x80808080;
|
2012-04-07 23:35:45 +00:00
|
|
|
n1 += (n3 & 0xFF00FF00) >> 8;
|
|
|
|
n2 += n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// clip to [0..255]
|
|
|
|
if (n1 & 0xFF00FF00) {
|
2012-04-07 23:35:45 +00:00
|
|
|
n3 = (((n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-05 01:15:15 +00:00
|
|
|
n1 += 0x7F007F00;
|
|
|
|
n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-07 23:35:45 +00:00
|
|
|
n1 &= n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
if (n2 & 0xFF00FF00) {
|
2012-04-07 23:35:45 +00:00
|
|
|
n3 = (((n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-05 01:15:15 +00:00
|
|
|
n2 += 0x7F007F00;
|
|
|
|
n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-07 23:35:45 +00:00
|
|
|
n2 &= n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// store result
|
|
|
|
dst[x] = (n1 << 8) | n2;
|
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
|
|
|
dst += pitch / 4;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return true;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1DecodeBlockNonIntra(Common::BitStream32BEMSB *s, byte *pixels, int pitch) {
|
2012-04-05 01:15:15 +00:00
|
|
|
// initialize list for breadth first processing of vectors
|
2012-04-07 23:35:45 +00:00
|
|
|
byte *list[63];
|
2012-04-05 01:15:15 +00:00
|
|
|
list[0] = pixels;
|
|
|
|
|
|
|
|
// recursively process vector
|
2012-04-07 23:35:45 +00:00
|
|
|
for (int i = 0, m = 1, n = 1, level = 5; i < n; i++) {
|
2012-04-05 01:15:15 +00:00
|
|
|
for (; level > 0; i++) {
|
|
|
|
// process next depth
|
|
|
|
if (i == m) {
|
|
|
|
m = n;
|
|
|
|
if (--level == 0)
|
|
|
|
break;
|
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// divide block if next bit set
|
|
|
|
if (s->getBit() == 0)
|
|
|
|
break;
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// add child nodes
|
|
|
|
list[n++] = list[i];
|
|
|
|
list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
// destination address and vector size
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 *dst = (uint32 *)list[i];
|
|
|
|
int width = 1 << ((level + 4) / 2);
|
|
|
|
int height = 1 << ((level + 3) / 2);
|
2012-04-05 01:15:15 +00:00
|
|
|
|
|
|
|
// get number of stages (-1 skips vector, 0 for mean only)
|
2012-04-07 23:35:45 +00:00
|
|
|
int stages = _interMultistage[level]->getSymbol(*s) - 1;
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
if (stages == -1)
|
|
|
|
continue; // skip vector
|
2012-04-05 01:15:15 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
if (stages > 0 && level >= 4) {
|
|
|
|
warning("Error (svq1_decode_block_non_intra): invalid vector: stages = %d, level = %d", stages, level);
|
2012-04-07 05:22:16 +00:00
|
|
|
return false; // error - invalid vector
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
int mean = _interMean->getSymbol(*s) - 256;
|
2012-08-27 17:19:53 +00:00
|
|
|
const uint32 *codebook = (const uint32 *)s_svq1InterCodebooks[level];
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 bitCache = s->getBits(stages * 4);
|
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// calculate codebook entries for this vector
|
2012-04-07 23:35:45 +00:00
|
|
|
int entries[6];
|
|
|
|
for (int j = 0; j < stages; j++)
|
|
|
|
entries[j] = (((bitCache >> ((stages - j - 1) * 4)) & 0xF) + j * 16) << (level + 1);
|
|
|
|
|
|
|
|
mean -= stages * 128;
|
|
|
|
uint32 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
|
|
|
|
|
|
|
|
for (int y = 0; y < height; y++) {
|
|
|
|
for (int x = 0; x < (width / 4); x++, codebook++) {
|
|
|
|
uint32 n3 = dst[x];
|
2012-04-05 01:15:15 +00:00
|
|
|
|
|
|
|
// add mean value to vector
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;
|
|
|
|
uint32 n2 = (n3 & 0x00FF00FF) + n4;
|
|
|
|
|
2012-04-05 01:15:15 +00:00
|
|
|
// add codebook entries to vector
|
2012-04-07 23:35:45 +00:00
|
|
|
for (int j = 0; j < stages; j++) {
|
2012-08-27 17:19:53 +00:00
|
|
|
n3 = READ_UINT32(&codebook[entries[j]]) ^ 0x80808080;
|
2012-04-07 23:35:45 +00:00
|
|
|
n1 += (n3 & 0xFF00FF00) >> 8;
|
|
|
|
n2 += n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// clip to [0..255]
|
|
|
|
if (n1 & 0xFF00FF00) {
|
2012-04-07 23:35:45 +00:00
|
|
|
n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-05 01:15:15 +00:00
|
|
|
n1 += 0x7F007F00;
|
|
|
|
n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-07 23:35:45 +00:00
|
|
|
n1 &= n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (n2 & 0xFF00FF00) {
|
|
|
|
n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
|
|
|
n2 += 0x7F007F00;
|
|
|
|
n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;
|
2012-04-07 23:35:45 +00:00
|
|
|
n2 &= n3 & 0x00FF00FF;
|
2012-04-05 01:15:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// store result
|
|
|
|
dst[x] = (n1 << 8) | n2;
|
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
|
|
|
dst += pitch / 4;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return true;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// median of 3
|
2012-04-07 23:35:45 +00:00
|
|
|
static inline int midPred(int a, int b, int c) {
|
2012-04-04 07:32:17 +00:00
|
|
|
if (a > b) {
|
|
|
|
if (c > b) {
|
2012-04-07 23:35:45 +00:00
|
|
|
if (c > a)
|
|
|
|
b = a;
|
|
|
|
else
|
|
|
|
b = c;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (b > c) {
|
2012-04-07 23:35:45 +00:00
|
|
|
if (c > a)
|
|
|
|
b = c;
|
|
|
|
else
|
|
|
|
b = a;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
2012-04-04 07:32:17 +00:00
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1DecodeMotionVector(Common::BitStream32BEMSB *s, Common::Point *mv, Common::Point **pmv) {
|
2012-04-07 01:56:39 +00:00
|
|
|
for (int i = 0; i < 2; i++) {
|
2012-04-04 07:32:17 +00:00
|
|
|
// get motion code
|
2012-04-05 01:15:15 +00:00
|
|
|
int diff = _motionComponent->getSymbol(*s);
|
2012-04-04 07:32:17 +00:00
|
|
|
if (diff < 0)
|
2012-04-07 05:22:16 +00:00
|
|
|
return false; // error - invalid motion code
|
2012-04-07 23:35:45 +00:00
|
|
|
else if (diff && s->getBit() != 0)
|
|
|
|
diff = -diff;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// add median of motion vector predictors and clip result
|
|
|
|
if (i == 1)
|
2012-04-07 23:35:45 +00:00
|
|
|
mv->y = ((diff + midPred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
|
2012-04-04 07:32:17 +00:00
|
|
|
else
|
2012-04-07 23:35:45 +00:00
|
|
|
mv->x = ((diff + midPred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return true;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::svq1SkipBlock(byte *current, byte *previous, int pitch, int x, int y) {
|
|
|
|
const byte *src = &previous[x + y * pitch];
|
|
|
|
byte *dst = current;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
|
|
memcpy(dst, src, 16);
|
|
|
|
src += pitch;
|
|
|
|
dst += pitch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels8C(byte *block, const byte *pixels, int lineSize, int h) {
|
2012-04-06 01:00:24 +00:00
|
|
|
for (int i = 0; i < h; i++) {
|
2012-04-07 23:35:45 +00:00
|
|
|
*((uint32 *)block) = READ_UINT32(pixels);
|
|
|
|
*((uint32 *)(block + 4)) = READ_UINT32(pixels + 4);
|
|
|
|
pixels += lineSize;
|
|
|
|
block += lineSize;
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
static inline uint32 rndAvg32(uint32 a, uint32 b) {
|
|
|
|
return (a | b) - (((a ^ b) & ~0x01010101) >> 1);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels8L2(byte *dst, const byte *src1, const byte *src2,
|
|
|
|
int dstStride, int srcStride1, int srcStride2, int h) {
|
|
|
|
for (int i = 0; i < h; i++) {
|
|
|
|
uint32 a = READ_UINT32(&src1[srcStride1 * i]);
|
|
|
|
uint32 b = READ_UINT32(&src2[srcStride2 * i]);
|
|
|
|
*((uint32 *)&dst[dstStride * i]) = rndAvg32(a, b);
|
|
|
|
a = READ_UINT32(&src1[srcStride1 * i + 4]);
|
|
|
|
b = READ_UINT32(&src2[srcStride2 * i + 4]);
|
|
|
|
*((uint32 *)&dst[dstStride * i + 4]) = rndAvg32(a, b);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels8X2C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8L2(block, pixels, pixels + 1, lineSize, lineSize, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels8Y2C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8L2(block, pixels, pixels + lineSize, lineSize, lineSize, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels8XY2C(byte *block, const byte *pixels, int lineSize, int h) {
|
2012-04-06 01:00:24 +00:00
|
|
|
for (int j = 0; j < 2; j++) {
|
2012-04-06 01:17:33 +00:00
|
|
|
uint32 a = READ_UINT32(pixels);
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 b = READ_UINT32(pixels + 1);
|
2012-04-06 01:00:24 +00:00
|
|
|
uint32 l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL;
|
|
|
|
uint32 h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2);
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
pixels += lineSize;
|
|
|
|
|
2012-04-06 01:00:24 +00:00
|
|
|
for (int i = 0; i < h; i += 2) {
|
2012-04-06 01:17:33 +00:00
|
|
|
a = READ_UINT32(pixels);
|
2012-04-07 23:35:45 +00:00
|
|
|
b = READ_UINT32(pixels + 1);
|
|
|
|
uint32 l1 = (a & 0x03030303UL) + (b & 0x03030303UL);
|
|
|
|
uint32 h1 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2);
|
|
|
|
*((uint32 *)block) = h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL);
|
|
|
|
pixels += lineSize;
|
|
|
|
block += lineSize;
|
2012-04-06 01:17:33 +00:00
|
|
|
a = READ_UINT32(pixels);
|
2012-04-07 23:35:45 +00:00
|
|
|
b = READ_UINT32(pixels + 1);
|
2012-04-06 01:00:24 +00:00
|
|
|
l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL;
|
|
|
|
h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2);
|
2012-04-07 23:35:45 +00:00
|
|
|
*((uint32 *)block) = h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL);
|
|
|
|
pixels += lineSize;
|
|
|
|
block += lineSize;
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
2012-04-07 23:35:45 +00:00
|
|
|
|
|
|
|
pixels += 4 - lineSize * (h + 1);
|
|
|
|
block += 4 - lineSize * h;
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels16C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8C(block, pixels, lineSize, h);
|
|
|
|
putPixels8C(block + 8, pixels + 8, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels16X2C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8X2C(block, pixels, lineSize, h);
|
|
|
|
putPixels8X2C(block + 8, pixels + 8, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels16Y2C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8Y2C(block, pixels, lineSize, h);
|
|
|
|
putPixels8Y2C(block + 8, pixels + 8, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
void SVQ1Decoder::putPixels16XY2C(byte *block, const byte *pixels, int lineSize, int h) {
|
|
|
|
putPixels8XY2C(block, pixels, lineSize, h);
|
|
|
|
putPixels8XY2C(block + 8, pixels + 8, lineSize, h);
|
2012-04-06 01:00:24 +00:00
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1MotionInterBlock(Common::BitStream32BEMSB *ss, byte *current, byte *previous, int pitch,
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *motion, int x, int y) {
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// predict and decode motion vector
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *pmv[3];
|
2012-04-04 07:32:17 +00:00
|
|
|
pmv[0] = &motion[0];
|
|
|
|
if (y == 0) {
|
|
|
|
pmv[1] = pmv[2] = pmv[0];
|
|
|
|
} else {
|
|
|
|
pmv[1] = &motion[(x / 8) + 2];
|
|
|
|
pmv[2] = &motion[(x / 8) + 4];
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point mv;
|
|
|
|
bool resultValid = svq1DecodeMotionVector(ss, &mv, pmv);
|
2012-04-07 05:22:16 +00:00
|
|
|
if (!resultValid)
|
|
|
|
return false;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 01:56:39 +00:00
|
|
|
motion[0].x = motion[(x / 8) + 2].x = motion[(x / 8) + 3].x = mv.x;
|
|
|
|
motion[0].y = motion[(x / 8) + 2].y = motion[(x / 8) + 3].y = mv.y;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
if (y + (mv.y >> 1) < 0)
|
2012-04-07 01:56:39 +00:00
|
|
|
mv.y = 0;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
if (x + (mv.x >> 1) < 0)
|
|
|
|
mv.x = 0;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
const byte *src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
|
|
|
|
byte *dst = current;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
// Halfpel motion compensation with rounding (a + b + 1) >> 1.
|
2012-04-06 01:00:24 +00:00
|
|
|
// 4 motion compensation functions for the 4 halfpel positions
|
|
|
|
// for 16x16 blocks
|
2012-04-07 23:35:45 +00:00
|
|
|
switch(((mv.y & 1) << 1) + (mv.x & 1)) {
|
2012-04-06 01:00:24 +00:00
|
|
|
case 0:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels16C(dst, src, pitch, 16);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels16X2C(dst, src, pitch, 16);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels16Y2C(dst, src, pitch, 16);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels16XY2C(dst, src, pitch, 16);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return true;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1MotionInter4vBlock(Common::BitStream32BEMSB *ss, byte *current, byte *previous, int pitch,
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *motion, int x, int y) {
|
2012-04-04 07:32:17 +00:00
|
|
|
// predict and decode motion vector (0)
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *pmv[4];
|
2012-04-04 07:32:17 +00:00
|
|
|
pmv[0] = &motion[0];
|
|
|
|
if (y == 0) {
|
|
|
|
pmv[1] = pmv[2] = pmv[0];
|
|
|
|
} else {
|
|
|
|
pmv[1] = &motion[(x / 8) + 2];
|
|
|
|
pmv[2] = &motion[(x / 8) + 4];
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point mv;
|
|
|
|
bool resultValid = svq1DecodeMotionVector(ss, &mv, pmv);
|
2012-04-07 05:22:16 +00:00
|
|
|
if (!resultValid)
|
|
|
|
return false;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// predict and decode motion vector (1)
|
|
|
|
pmv[0] = &mv;
|
2012-04-07 23:35:45 +00:00
|
|
|
if (y == 0)
|
2012-04-04 07:32:17 +00:00
|
|
|
pmv[1] = pmv[2] = pmv[0];
|
2012-04-07 23:35:45 +00:00
|
|
|
else
|
2012-04-04 07:32:17 +00:00
|
|
|
pmv[1] = &motion[(x / 8) + 3];
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeMotionVector(ss, &motion[0], pmv);
|
|
|
|
if (!resultValid)
|
|
|
|
return false;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// predict and decode motion vector (2)
|
|
|
|
pmv[1] = &motion[0];
|
|
|
|
pmv[2] = &motion[(x / 8) + 1];
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeMotionVector(ss, &motion[(x / 8) + 2], pmv);
|
|
|
|
if (!resultValid)
|
|
|
|
return false;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// predict and decode motion vector (3)
|
|
|
|
pmv[2] = &motion[(x / 8) + 2];
|
|
|
|
pmv[3] = &motion[(x / 8) + 3];
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeMotionVector(ss, pmv[3], pmv);
|
|
|
|
if (!resultValid)
|
|
|
|
return false;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// form predictions
|
2012-04-07 01:56:39 +00:00
|
|
|
for (int i = 0; i < 4; i++) {
|
2012-04-07 23:35:45 +00:00
|
|
|
int mvx = pmv[i]->x + (i & 1) * 16;
|
|
|
|
int mvy = pmv[i]->y + (i >> 1) * 16;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
// FIXME: clipping or padding?
|
|
|
|
if (y + (mvy >> 1) < 0)
|
2012-04-04 07:32:17 +00:00
|
|
|
mvy = 0;
|
2012-04-07 23:35:45 +00:00
|
|
|
|
|
|
|
if (x + (mvx >> 1) < 0)
|
2012-04-04 07:32:17 +00:00
|
|
|
mvx = 0;
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
const byte *src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
|
|
|
|
byte *dst = current;
|
2012-04-04 07:32:17 +00:00
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
// Halfpel motion compensation with rounding (a + b + 1) >> 1.
|
2012-04-06 01:00:24 +00:00
|
|
|
// 4 motion compensation functions for the 4 halfpel positions
|
|
|
|
// for 8x8 blocks
|
2012-04-07 23:35:45 +00:00
|
|
|
switch(((mvy & 1) << 1) + (mvx & 1)) {
|
2012-04-06 01:00:24 +00:00
|
|
|
case 0:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels8C(dst, src, pitch, 8);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 1:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels8X2C(dst, src, pitch, 8);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels8Y2C(dst, src, pitch, 8);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2012-04-07 23:35:45 +00:00
|
|
|
putPixels8XY2C(dst, src, pitch, 8);
|
2012-04-06 01:00:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// select next block
|
2012-04-07 23:35:45 +00:00
|
|
|
if (i & 1)
|
|
|
|
current += (pitch - 1) * 8;
|
|
|
|
else
|
|
|
|
current += 8;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return true;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2017-07-24 19:01:19 +00:00
|
|
|
bool SVQ1Decoder::svq1DecodeDeltaBlock(Common::BitStream32BEMSB *ss, byte *current, byte *previous, int pitch,
|
2012-04-07 23:35:45 +00:00
|
|
|
Common::Point *motion, int x, int y) {
|
2012-04-04 07:32:17 +00:00
|
|
|
// get block type
|
2012-04-07 23:35:45 +00:00
|
|
|
uint32 blockType = _blockType->getSymbol(*ss);
|
2012-04-04 07:32:17 +00:00
|
|
|
|
|
|
|
// reset motion vectors
|
2012-04-07 23:35:45 +00:00
|
|
|
if (blockType == SVQ1_BLOCK_SKIP || blockType == SVQ1_BLOCK_INTRA) {
|
|
|
|
motion[0].x =
|
|
|
|
motion[0].y =
|
2012-04-04 07:32:17 +00:00
|
|
|
motion[(x / 8) + 2].x =
|
|
|
|
motion[(x / 8) + 2].y =
|
|
|
|
motion[(x / 8) + 3].x =
|
|
|
|
motion[(x / 8) + 3].y = 0;
|
|
|
|
}
|
|
|
|
|
2012-04-07 23:35:45 +00:00
|
|
|
bool resultValid = true;
|
|
|
|
|
|
|
|
switch (blockType) {
|
2012-04-04 07:32:17 +00:00
|
|
|
case SVQ1_BLOCK_SKIP:
|
|
|
|
svq1SkipBlock(current, previous, pitch, x, y);
|
|
|
|
break;
|
|
|
|
case SVQ1_BLOCK_INTER:
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1MotionInterBlock(ss, current, previous, pitch, motion, x, y);
|
|
|
|
if (!resultValid) {
|
2012-04-07 01:56:39 +00:00
|
|
|
warning("svq1MotionInterBlock decode failure");
|
2012-04-04 07:32:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeBlockNonIntra(ss, current, pitch);
|
2012-04-04 07:32:17 +00:00
|
|
|
break;
|
|
|
|
case SVQ1_BLOCK_INTER_4V:
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1MotionInter4vBlock(ss, current, previous, pitch, motion, x, y);
|
|
|
|
if (!resultValid) {
|
2012-04-07 01:56:39 +00:00
|
|
|
warning("svq1MotionInter4vBlock decode failure");
|
2012-04-04 07:32:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeBlockNonIntra(ss, current, pitch);
|
2012-04-04 07:32:17 +00:00
|
|
|
break;
|
|
|
|
case SVQ1_BLOCK_INTRA:
|
2012-04-07 05:22:16 +00:00
|
|
|
resultValid = svq1DecodeBlockIntra(ss, current, pitch);
|
2012-04-04 07:32:17 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-04-07 05:22:16 +00:00
|
|
|
return resultValid;
|
2012-04-04 07:32:17 +00:00
|
|
|
}
|
|
|
|
|
2014-02-28 02:27:23 +00:00
|
|
|
} // End of namespace Image
|