void MoviePlayer::drawFramePSX(const Graphics::Surface *frame) {
// The PSX videos have half resolution
Graphics::Surface scaledFrame;
scaledFrame.create(frame->getWidth(), frame->getHeight() * 2, frame->getFormat());
for (int y = 0; y < scaledFrame.getHeight(); y++)
memcpy(scaledFrame.getBasePtr(0, y), frame->getBasePtr(0, y / 2), scaledFrame.getWidth() * scaledFrame.getFormat().bytesPerPixel);
uint16 x = (g_system->getWidth() - scaledFrame.getWidth()) / 2;
uint16 y = (g_system->getHeight() - scaledFrame.getHeight()) / 2;
_vm->_system->copyRectToScreen(scaledFrame.getPixels(), scaledFrame.getPitch(), x, y, scaledFrame.getWidth(), scaledFrame.getHeight());
}
void Animation::drawFontFrame(Graphics::Surface &surface, int32 frame, int16 xx, int16 yy, byte *colorMap) {
debugC(4, kDebugAnim, "drawFontFrame(surface, %d, %d, %d, colorMap)", frame, xx, yy);
if (frame < 0)
frame = 0;
if (frame >= _numFrames)
frame = _numFrames - 1;
if (_numFrames == 0)
return;
int16 dataFrame = frame;
if (_frames[frame]._ref != -1)
dataFrame = _frames[frame]._ref;
int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
int16 rectY = _frames[frame]._y2 - _frames[frame]._y1;
if ((xx + _x1 + _frames[frame]._x1 < 0) || (yy + _y1 + _frames[frame]._y1 < 0))
return;
if (rectX + xx + _x1 + _frames[frame]._x1 >= surface.getWidth())
rectX = surface.getWidth() - xx - _x1 - _frames[frame]._x1;
if (rectX < 0)
return;
if (rectY + yy + _y1 + _frames[frame]._y1 >= surface.getHeight())
rectY = surface.getHeight() - yy - _y1 - _frames[frame]._y1;
if (rectY < 0)
return;
int32 destPitch = surface.getPitch();
uint8 *c = _frames[dataFrame]._data;
uint8 *curRow = (uint8 *)surface.getBasePtr(xx + _x1 + _frames[frame]._x1, yy + _frames[frame]._y1 + _y1);
for (int16 y = 0; y < rectY; y++) {
unsigned char *cur = curRow;
for (int16 x = 0; x < rectX; x++) {
if (*c && *c < 4)
*cur = colorMap[*c];
c++;
cur++;
}
curRow += destPitch;
}
}
bool SlotControl::process(uint32 deltaTimeInMillis) {
if (_engine->getScriptManager()->getStateFlag(_key) & Puzzle::DISABLED)
return false;
if (_engine->canRender()) {
int curItem = _engine->getScriptManager()->getStateValue(_key);
if (curItem != _renderedItem) {
if (_renderedItem != 0 && curItem == 0) {
_engine->getRenderManager()->blitSurfaceToBkg(*_bkg, _rectangle.left, _rectangle.top);
_renderedItem = curItem;
} else {
if (_renderedItem == 0) {
if (_bkg)
delete _bkg;
_bkg = _engine->getRenderManager()->getBkgRect(_rectangle);
} else {
_engine->getRenderManager()->blitSurfaceToBkg(*_bkg, _rectangle.left, _rectangle.top);
}
char buf[16];
if (_engine->getGameId() == GID_NEMESIS)
sprintf(buf, "%d%cobj.tga", curItem, _distanceId);
else
sprintf(buf, "g0z%cu%2.2x1.tga", _distanceId, curItem);
Graphics::Surface *srf = _engine->getRenderManager()->loadImage(buf);
int16 drawx = _rectangle.left;
int16 drawy = _rectangle.top;
if (_rectangle.width() > srf->getWidth())
drawx = _rectangle.left + (_rectangle.width() - srf->getWidth()) / 2;
if (_rectangle.height() > srf->getHeight())
drawy = _rectangle.top + (_rectangle.height() - srf->getHeight()) / 2;
_engine->getRenderManager()->blitSurfaceToBkg(*srf, drawx, drawy, 0);
delete srf;
_renderedItem = curItem;
}
}
}
return false;
}
int16 ScriptFunctions::sfLoadMouseCursor(int16 argc, int16 *argv) {
PictureResource *flex = _vm->_res->getPicture(argv[2]);
if (flex) {
Graphics::Surface *surf = flex->getPicture();
CursorMan.replaceCursor(surf->getPixels(), surf->getWidth(), surf->getHeight(), argv[1], argv[0], 0);
_vm->_res->freeResource(flex);
}
return 0;
}
void VPXDecoder::decodeFrame(Graphics::Surface &surface, Common::SeekableReadStream &dataStream) {
if (!_initialized)
return;
// Read all the data from the stream
Common::ScopedArray<byte> data(new byte[dataStream.size()]);
dataStream.read(data.get(), dataStream.size());
// Perform the actual decode
vpx_codec_err_t result = vpx_codec_decode(&_context, data.get(), dataStream.size(), 0, 0);
if (result != VPX_CODEC_OK)
return;
// Try to get the image
vpx_codec_iter_t iter = 0;
vpx_image_t *image = vpx_codec_get_frame(&_context, &iter);
if (!image)
return;
// Figure out the color range
Graphics::YUVToRGBManager::LuminanceScale scale;
switch (image->range) {
case VPX_CR_STUDIO_RANGE:
scale = Graphics::YUVToRGBManager::kScaleITU;
break;
case VPX_CR_FULL_RANGE:
scale = Graphics::YUVToRGBManager::kScaleFull;
break;
default:
return;
}
// If we don't have it already, create our local surface
if (!_surface)
_surface.reset(new Graphics::Surface(image->w, image->h));
// Do the conversion based on the color space
switch (image->fmt) {
case VPX_IMG_FMT_I420:
YUVToRGBMan.convert420(scale, _surface->getData(), _surface->getPitch(), image->planes[0], image->planes[1], image->planes[2], image->w, image->h, image->stride[0], image->stride[1]);
break;
default:
return;
}
// Copy the subarea into the surface
for (int y = 0; y < surface.getHeight(); y++)
memcpy(surface.getData() + y * surface.getPitch(), _surface->getData() + (y * image->d_h) * image->d_w * 4, image->d_w * 4);
}
bool LBGraphics::imageIsTransparentAt(uint16 image, bool useOffsets, int x, int y) {
MohawkSurface *mhkSurface = findImage(image);
if (useOffsets) {
x += mhkSurface->getOffsetX();
y += mhkSurface->getOffsetY();
}
if (x < 0 || y < 0)
return true;
Graphics::Surface *surface = mhkSurface->getSurface();
if (x >= surface->getWidth() || y >= surface->getHeight())
return true;
return *(byte *)surface->getBasePtr(x, y) == 0;
}
void ZVision::playVideo(Video::VideoDecoder &vid, const Common::Rect &destRect, bool skippable, Subtitle *sub) {
Common::Rect dst = destRect;
// If destRect is empty, no specific scaling was requested. However, we may choose to do scaling anyway
if (dst.isEmpty())
dst = Common::Rect(vid.getWidth(), vid.getHeight());
Graphics::Surface scaled;
if (vid.getWidth() != dst.width() || vid.getHeight() != dst.height())
scaled.create(dst.width(), dst.height(), vid.getPixelFormat());
uint16 x = _workingWindow.left + dst.left;
uint16 y = _workingWindow.top + dst.top;
uint16 finalWidth = dst.width() < _workingWindow.width() ? dst.width() : _workingWindow.width();
uint16 finalHeight = dst.height() < _workingWindow.height() ? dst.height() : _workingWindow.height();
bool showSubs = (_scriptManager->getStateValue(StateKey_Subtitles) == 1);
_clock.stop();
vid.start();
_videoIsPlaying = true;
// Only continue while the video is still playing
while (!shouldQuit() && !vid.endOfVideo() && vid.isPlaying()) {
// Check for engine quit and video stop key presses
while (_eventMan->pollEvent(_event)) {
switch (_event.type) {
case Common::EVENT_KEYDOWN:
switch (_event.kbd.keycode) {
case Common::KEYCODE_q:
if (_event.kbd.hasFlags(Common::KBD_CTRL))
quitGame();
break;
case Common::KEYCODE_SPACE:
if (skippable) {
vid.stop();
}
break;
default:
break;
}
default:
break;
}
}
if (vid.needsUpdate()) {
const Graphics::Surface *frame = vid.decodeNextFrame();
if (sub && showSubs)
sub->process(vid.getCurFrame());
if (frame) {
if (scaled.getPixels()) {
_renderManager->scaleBuffer(frame->getPixels(), scaled.getPixels(), frame->getWidth(), frame->getHeight(), frame->getFormat().bytesPerPixel, scaled.getWidth(), scaled.getHeight());
frame = &scaled;
}
Common::Rect rect = Common::Rect(x, y, x + finalWidth, y + finalHeight);
_renderManager->copyToScreen(*frame, rect, 0, 0);
_renderManager->processSubs(0);
}
}
// Always update the screen so the mouse continues to render
_system->updateScreen();
_system->delayMillis(vid.getTimeToNextFrame() / 2);
}
_videoIsPlaying = false;
_clock.start();
}
void Animation::drawFrame(Graphics::Surface &surface, int32 frame, int16 xx, int16 yy) {
debugC(3, kDebugAnim, "drawFrame(surface, %d, %d, %d)", frame, xx, yy);
if (frame < 0)
frame = 0;
if (frame >= _numFrames)
frame = _numFrames - 1;
if (_numFrames == 0)
return;
int16 dataFrame = frame;
if (_frames[frame]._ref != -1)
dataFrame = _frames[frame]._ref;
if (!_frames[dataFrame]._data)
return;
int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
int16 rectY = _frames[frame]._y2 - _frames[frame]._y1;
int16 offsX = 0;
int16 offsY = 0;
_vm->addDirtyRect(xx + _x1 + _frames[frame]._x1, yy + _y1 + _frames[frame]._y1, xx + rectX + _x1 + _frames[frame]._x1 , yy + rectY + _y1 + _frames[frame]._y1);
if (xx + _x1 + _frames[frame]._x1 < 0) {
offsX = -(xx + _x1 + _frames[frame]._x1);
}
if (offsX >= rectX)
return;
else
rectX -= offsX;
if (yy + _y1 + _frames[frame]._y1 < 0) {
offsY = -(yy + _y1 + _frames[frame]._y1);
}
if (offsY >= rectY)
return;
else
rectY -= offsY;
if (rectX + xx + _x1 + _frames[frame]._x1 >= surface.getWidth())
rectX = surface.getWidth() - xx - _x1 - _frames[frame]._x1;
if (rectX < 0)
return;
if (rectY + yy + _y1 + _frames[frame]._y1 >= surface.getHeight())
rectY = surface.getHeight() - yy - _y1 - _frames[frame]._y1;
if (rectY < 0)
return;
int32 destPitch = surface.getPitch();
uint8 *srcRow = _frames[dataFrame]._data + offsX + (_frames[frame]._x2 - _frames[frame]._x1) * offsY;
uint8 *curRow = (uint8 *)surface.getBasePtr(xx + _x1 + _frames[frame]._x1 + offsX, yy + _frames[frame]._y1 + _y1 + offsY);
for (int16 y = 0; y < rectY; y++) {
uint8 *cur = curRow;
uint8 *c = srcRow + y * (_frames[frame]._x2 - _frames[frame]._x1);
for (int16 x = 0; x < rectX; x++) {
if (*c)
*cur = *c;
c++;
cur++;
}
curRow += destPitch;
}
}