VideoEntryPtr VideoManager::open(const Common::String &fileName, Audio::Mixer::SoundType soundType) {
// If this video is already playing, return that entry
VideoEntryPtr oldVideo = findVideo(fileName);
if (oldVideo)
return oldVideo;
// Otherwise, create a new entry
Common::SeekableReadStream *stream = SearchMan.createReadStreamForMember(fileName);
if (!stream)
return VideoEntryPtr();
Video::VideoDecoder *video = new Video::QuickTimeDecoder();
video->setSoundType(soundType);
if (!video->loadStream(stream)) {
// FIXME: Better error handling
delete video;
return VideoEntryPtr();
}
// Create the entry
VideoEntryPtr entry(new VideoEntry(video, fileName));
// Enable dither if necessary
checkEnableDither(entry);
// Add it to the video list
_videos.push_back(entry);
return entry;
}
Video::VideoDecoder *ZVision::loadAnimation(const Common::String &fileName) {
Common::String tmpFileName = fileName;
tmpFileName.toLowercase();
Video::VideoDecoder *animation = NULL;
if (tmpFileName.hasSuffix(".rlf"))
animation = new RLFDecoder();
else if (tmpFileName.hasSuffix(".avi"))
animation = new ZorkAVIDecoder();
#ifdef USE_MPEG2
else if (tmpFileName.hasSuffix(".vob"))
animation = new Video::MPEGPSDecoder();
#endif
else
error("Unknown suffix for animation %s", fileName.c_str());
Common::File *_file = getSearchManager()->openFile(tmpFileName);
if (!_file)
error("Error opening %s", tmpFileName.c_str());
bool loaded = animation->loadStream(_file);
if (!loaded)
error("Error loading animation %s", tmpFileName.c_str());
return animation;
}
reg_t kPlayDuck(EngineState *s, int argc, reg_t *argv) {
uint16 operation = argv[0].toUint16();
Video::VideoDecoder *videoDecoder = 0;
bool reshowCursor = g_sci->_gfxCursor->isVisible();
switch (operation) {
case 1: // Play
// 6 params
s->_videoState.reset();
s->_videoState.fileName = Common::String::format("%d.duk", argv[1].toUint16());
videoDecoder = new Video::AVIDecoder();
if (!videoDecoder->loadFile(s->_videoState.fileName)) {
warning("Could not open Duck %s", s->_videoState.fileName.c_str());
break;
}
if (reshowCursor)
g_sci->_gfxCursor->kernelHide();
{
// Duck videos are 16bpp, so we need to change the active pixel format
int oldWidth = g_system->getWidth();
int oldHeight = g_system->getHeight();
Common::List<Graphics::PixelFormat> formats;
formats.push_back(videoDecoder->getPixelFormat());
initGraphics(640, 480, true, formats);
if (g_system->getScreenFormat().bytesPerPixel != videoDecoder->getPixelFormat().bytesPerPixel)
error("Could not switch screen format for the duck video");
playVideo(videoDecoder, s->_videoState);
// Switch back to 8bpp
initGraphics(oldWidth, oldHeight, oldWidth > 320);
}
if (reshowCursor)
g_sci->_gfxCursor->kernelShow();
break;
default:
kStub(s, argc, argv);
break;
}
return s->r_acc;
}
bool VideoManager::updateMovies() {
bool updateScreen = false;
for (VideoList::iterator it = _videos.begin(); it != _videos.end(); ) {
// Check of the video has reached the end
if ((*it)->endOfVideo()) {
if ((*it)->isLooping()) {
// Seek back if looping
(*it)->seek((*it)->getStart());
} else {
// Done; close and continue on
(*it)->close();
it = _videos.erase(it);
continue;
}
}
Video::VideoDecoder *video = (*it)->_video;
// Ignore paused videos
if (video->isPaused()) {
it++;
continue;
}
// Check if we need to draw a frame
if (video->needsUpdate()) {
if (drawNextFrame(*it)) {
updateScreen = true;
}
}
// Remember to increase the iterator
it++;
}
// Return true if we need to update the screen
return updateScreen;
}
void PrinceEngine::playVideo(Common::String videoFilename) {
// Set the correct video mode
initGraphics(640, 480, true, 0);
if (_system->getScreenFormat().bytesPerPixel == 1) {
warning("Couldn't switch to a RGB color video mode to play a video.");
return;
}
debug(2, "Screen format: %s", _system->getScreenFormat().toString().c_str());
Video::VideoDecoder *videoDecoder = new Video::AVIDecoder();
if (!videoDecoder->loadFile(videoFilename)) {
delete videoDecoder;
warning("Unable to open video %s", videoFilename.c_str());
initGraphics(640, 480, true);
return;
}
videoDecoder->start();
bool skipVideo = false;
while (!shouldQuit() && !videoDecoder->endOfVideo() && !skipVideo) {
if (videoDecoder->needsUpdate()) {
const Graphics::Surface *frame = videoDecoder->decodeNextFrame();
if (frame) {
if (frame->format.bytesPerPixel > 1) {
Graphics::Surface *frame1 = frame->convertTo(_system->getScreenFormat());
_system->copyRectToScreen(frame1->getPixels(), frame1->pitch, 0, 0, frame1->w, frame1->h);
frame1->free();
delete frame1;
} else {
_system->copyRectToScreen(frame->getPixels(), frame->pitch, 0, 0, frame->w, frame->h);
}
_system->updateScreen();
}
}
Common::Event event;
while (_system->getEventManager()->pollEvent(event)) {
if ((event.type == Common::EVENT_KEYDOWN && event.kbd.keycode == Common::KEYCODE_ESCAPE) ||
event.type == Common::EVENT_LBUTTONUP)
skipVideo = true;
}
_system->delayMillis(10);
}
delete videoDecoder;
initGraphics(640, 480, true);
}
reg_t kPlayVMD(EngineState *s, int argc, reg_t *argv) {
uint16 operation = argv[0].toUint16();
Video::VideoDecoder *videoDecoder = 0;
bool reshowCursor = g_sci->_gfxCursor->isVisible();
Common::String warningMsg;
switch (operation) {
case 0: // init
s->_videoState.reset();
s->_videoState.fileName = s->_segMan->derefString(argv[1]);
if (argc > 2 && argv[2] != NULL_REG)
warning("kPlayVMD: third parameter isn't 0 (it's %04x:%04x - %s)", PRINT_REG(argv[2]), s->_segMan->getObjectName(argv[2]));
break;
case 1:
{
// Set VMD parameters. Called with a maximum of 6 parameters:
//
// x, y, flags, gammaBoost, gammaFirst, gammaLast
//
// gammaBoost boosts palette colors in the range gammaFirst to
// gammaLast, but only if bit 4 in flags is set. Percent value such that
// 0% = no amplification These three parameters are optional if bit 4 is
// clear. Also note that the x, y parameters play subtle games if used
// with subfx 21. The subtleness has to do with creation of temporary
// planes and positioning relative to such planes.
uint16 flags = argv[3].getOffset();
Common::String flagspec;
if (argc > 3) {
if (flags & kDoubled)
flagspec += "doubled ";
if (flags & kDropFrames)
flagspec += "dropframes ";
if (flags & kBlackLines)
flagspec += "blacklines ";
if (flags & kUnkBit3)
flagspec += "bit3 ";
if (flags & kGammaBoost)
flagspec += "gammaboost ";
if (flags & kHoldBlackFrame)
flagspec += "holdblack ";
if (flags & kHoldLastFrame)
flagspec += "holdlast ";
if (flags & kUnkBit7)
flagspec += "bit7 ";
if (flags & kStretch)
flagspec += "stretch";
warning("VMDFlags: %s", flagspec.c_str());
s->_videoState.flags = flags;
}
warning("x, y: %d, %d", argv[1].getOffset(), argv[2].getOffset());
s->_videoState.x = argv[1].getOffset();
s->_videoState.y = argv[2].getOffset();
if (argc > 4 && flags & 16)
warning("gammaBoost: %d%% between palette entries %d and %d", argv[4].getOffset(), argv[5].getOffset(), argv[6].getOffset());
break;
}
case 6: // Play
videoDecoder = new Video::AdvancedVMDDecoder();
if (s->_videoState.fileName.empty()) {
// Happens in Lighthouse
warning("kPlayVMD: Empty filename passed");
return s->r_acc;
}
if (!videoDecoder->loadFile(s->_videoState.fileName)) {
warning("Could not open VMD %s", s->_videoState.fileName.c_str());
break;
}
if (reshowCursor)
g_sci->_gfxCursor->kernelHide();
playVideo(videoDecoder, s->_videoState);
if (reshowCursor)
g_sci->_gfxCursor->kernelShow();
break;
case 23: // set video palette range
s->_vmdPalStart = argv[1].toUint16();
s->_vmdPalEnd = argv[2].toUint16();
break;
case 14:
// Takes an additional integer parameter (e.g. 3)
case 16:
// Takes an additional parameter, usually 0
case 21:
// Looks to be setting the video size and position. Called with 4 extra integer
// parameters (e.g. 86, 41, 235, 106)
default:
warningMsg = Common::String::format("PlayVMD - unsupported subop %d. Params: %d (", operation, argc);
for (int i = 0; i < argc; i++) {
warningMsg += Common::String::format("%04x:%04x", PRINT_REG(argv[i]));
warningMsg += (i == argc - 1 ? ")" : ", ");
}
warning("%s", warningMsg.c_str());
break;
}
return s->r_acc;
}
reg_t kShowMovie(EngineState *s, int argc, reg_t *argv) {
// Hide the cursor if it's showing and then show it again if it was
// previously visible.
bool reshowCursor = g_sci->_gfxCursor->isVisible();
if (reshowCursor)
g_sci->_gfxCursor->kernelHide();
uint16 screenWidth = g_system->getWidth();
uint16 screenHeight = g_system->getHeight();
Video::VideoDecoder *videoDecoder = 0;
if (argv[0].getSegment() != 0) {
Common::String filename = s->_segMan->getString(argv[0]);
if (g_sci->getPlatform() == Common::kPlatformMacintosh) {
// Mac QuickTime
// The only argument is the string for the video
// HACK: Switch to 16bpp graphics for Cinepak.
initGraphics(screenWidth, screenHeight, screenWidth > 320, NULL);
if (g_system->getScreenFormat().bytesPerPixel == 1) {
warning("This video requires >8bpp color to be displayed, but could not switch to RGB color mode");
return NULL_REG;
}
videoDecoder = new Video::QuickTimeDecoder();
if (!videoDecoder->loadFile(filename))
error("Could not open '%s'", filename.c_str());
} else {
// DOS SEQ
// SEQ's are called with no subops, just the string and delay
// Time is specified as ticks
videoDecoder = new SEQDecoder(argv[1].toUint16());
if (!videoDecoder->loadFile(filename)) {
warning("Failed to open movie file %s", filename.c_str());
delete videoDecoder;
videoDecoder = 0;
}
}
} else {
// Windows AVI
// TODO: This appears to be some sort of subop. case 0 contains the string
// for the video, so we'll just play it from there for now.
#ifdef ENABLE_SCI32
if (getSciVersion() >= SCI_VERSION_2_1) {
// SCI2.1 always has argv[0] as 1, the rest of the arguments seem to
// follow SCI1.1/2.
if (argv[0].toUint16() != 1)
error("SCI2.1 kShowMovie argv[0] not 1");
argv++;
argc--;
}
#endif
switch (argv[0].toUint16()) {
case 0: {
Common::String filename = s->_segMan->getString(argv[1]);
videoDecoder = new Video::AVIDecoder();
if (filename.equalsIgnoreCase("gk2a.avi")) {
// HACK: Switch to 16bpp graphics for Indeo3.
// The only known movie to do use this codec is the GK2 demo trailer
// If another video turns up that uses Indeo, we may have to add a better
// check.
initGraphics(screenWidth, screenHeight, screenWidth > 320, NULL);
if (g_system->getScreenFormat().bytesPerPixel == 1) {
warning("This video requires >8bpp color to be displayed, but could not switch to RGB color mode");
return NULL_REG;
}
}
if (!videoDecoder->loadFile(filename.c_str())) {
warning("Failed to open movie file %s", filename.c_str());
delete videoDecoder;
videoDecoder = 0;
} else {
s->_videoState.fileName = filename;
}
break;
}
default:
warning("Unhandled SCI kShowMovie subop %d", argv[0].toUint16());
}
}
if (videoDecoder) {
playVideo(videoDecoder, s->_videoState);
// HACK: Switch back to 8bpp if we played a true color video.
// We also won't be copying the screen to the SCI screen...
if (g_system->getScreenFormat().bytesPerPixel != 1)
initGraphics(screenWidth, screenHeight, screenWidth > 320);
else {
g_sci->_gfxScreen->kernelSyncWithFramebuffer();
g_sci->_gfxPalette->kernelSyncScreenPalette();
}
}
if (reshowCursor)
g_sci->_gfxCursor->kernelShow();
return s->r_acc;
}
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 ZVision::playVideo(Video::VideoDecoder &videoDecoder, const Common::Rect &destRect, bool skippable) {
byte bytesPerPixel = videoDecoder.getPixelFormat().bytesPerPixel;
uint16 origWidth = videoDecoder.getWidth();
uint16 origHeight = videoDecoder.getHeight();
uint scale = 1;
// If destRect is empty, no specific scaling was requested. However, we may choose to do scaling anyway
if (destRect.isEmpty()) {
// Most videos are very small. Therefore we do a simple 2x scale
if (origWidth * 2 <= 640 && origHeight * 2 <= 480) {
scale = 2;
}
} else {
// Assume bilinear scaling. AKA calculate the scale from just the width.
// Also assume that the scaling is in integral intervals. AKA no 1.5x scaling
// TODO: Test ^these^ assumptions
scale = destRect.width() / origWidth;
// TODO: Test if we need to support downscale.
}
uint16 pitch = origWidth * bytesPerPixel;
uint16 finalWidth = origWidth * scale;
uint16 finalHeight = origHeight * scale;
byte *scaledVideoFrameBuffer;
if (scale != 1) {
scaledVideoFrameBuffer = new byte[finalWidth * finalHeight * bytesPerPixel];
}
uint16 x = ((WINDOW_WIDTH - finalWidth) / 2) + destRect.left;
uint16 y = ((WINDOW_HEIGHT - finalHeight) / 2) + destRect.top;
_clock.stop();
videoDecoder.start();
// Only continue while the video is still playing
while (!shouldQuit() && !videoDecoder.endOfVideo() && videoDecoder.isPlaying()) {
// Check for engine quit and video stop key presses
while (!videoDecoder.endOfVideo() && videoDecoder.isPlaying() && _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) {
videoDecoder.stop();
}
break;
default:
break;
}
default:
break;
}
}
if (videoDecoder.needsUpdate()) {
const Graphics::Surface *frame = videoDecoder.decodeNextFrame();
if (frame) {
if (scale != 1) {
scaleBuffer((const byte *)frame->getPixels(), scaledVideoFrameBuffer, origWidth, origHeight, bytesPerPixel, scale);
_system->copyRectToScreen(scaledVideoFrameBuffer, pitch * 2, x, y, finalWidth, finalHeight);
} else {
_system->copyRectToScreen((const byte *)frame->getPixels(), pitch, x, y, finalWidth, finalHeight);
}
}
}
// Always update the screen so the mouse continues to render
_system->updateScreen();
_system->delayMillis(videoDecoder.getTimeToNextFrame());
}
_clock.start();
if (scale != 1) {
delete[] scaledVideoFrameBuffer;
}
}
bool VideoManager::drawNextFrame(VideoEntryPtr videoEntry) {
Video::VideoDecoder *video = videoEntry->_video;
const Graphics::Surface *frame = video->decodeNextFrame();
if (!frame || !videoEntry->isEnabled()) {
return false;
}
Graphics::Surface *convertedFrame = nullptr;
Graphics::PixelFormat pixelFormat = _vm->_system->getScreenFormat();
if (frame->format != pixelFormat) {
// We don't support downconverting to 8bpp without having
// support in the codec. Set _enableDither if shows up.
if (pixelFormat.bytesPerPixel == 1) {
warning("Cannot convert high color video frame to 8bpp");
return false;
}
// Convert to the current screen format
convertedFrame = frame->convertTo(pixelFormat, video->getPalette());
frame = convertedFrame;
} else if (pixelFormat.bytesPerPixel == 1 && video->hasDirtyPalette()) {
// Set the palette when running in 8bpp mode only
// Don't do this for Myst, which has its own per-stack handling
if (_vm->getGameType() != GType_MYST)
_vm->_system->getPaletteManager()->setPalette(video->getPalette(), 0, 256);
}
// Clip the video to make sure it stays on the screen (Myst does this a few times)
Common::Rect targetRect = Common::Rect(video->getWidth(), video->getHeight());
targetRect.translate(videoEntry->getX(), videoEntry->getY());
Common::Rect frameRect = Common::Rect(video->getWidth(), video->getHeight());
if (targetRect.left < 0) {
frameRect.left -= targetRect.left;
targetRect.left = 0;
}
if (targetRect.top < 0) {
frameRect.top -= targetRect.top;
targetRect.top = 0;
}
if (targetRect.right > _vm->_system->getWidth()) {
frameRect.right -= targetRect.right - _vm->_system->getWidth();
targetRect.right = _vm->_system->getWidth();
}
if (targetRect.bottom > _vm->_system->getHeight()) {
frameRect.bottom -= targetRect.bottom - _vm->_system->getHeight();
targetRect.bottom = _vm->_system->getHeight();
}
_vm->_system->copyRectToScreen(frame->getBasePtr(frameRect.left, frameRect.top), frame->pitch,
targetRect.left, targetRect.top, targetRect.width(), targetRect.height());
// Delete 8bpp conversion surface
if (convertedFrame) {
convertedFrame->free();
delete convertedFrame;
}
// We've drawn something to the screen, make sure we update it
return true;
}
bool VideoManager::updateMovies() {
bool updateScreen = false;
for (VideoList::iterator it = _videos.begin(); it != _videos.end(); ) {
// Check of the video has reached the end
if ((*it)->endOfVideo()) {
if ((*it)->isLooping()) {
// Seek back if looping
(*it)->seek((*it)->getStart());
} else {
// Done; close and continue on
(*it)->close();
it = _videos.erase(it);
continue;
}
}
Video::VideoDecoder *video = (*it)->_video;
// Ignore paused videos
if (video->isPaused()) {
it++;
continue;
}
// Check if we need to draw a frame
if (video->needsUpdate()) {
const Graphics::Surface *frame = video->decodeNextFrame();
Graphics::Surface *convertedFrame = 0;
if (frame && (*it)->isEnabled()) {
Graphics::PixelFormat pixelFormat = _vm->_system->getScreenFormat();
if (frame->format != pixelFormat) {
// We don't support downconverting to 8bpp without having
// support in the codec. Set _enableDither if shows up.
if (pixelFormat.bytesPerPixel == 1) {
warning("Cannot convert high color video frame to 8bpp");
(*it)->close();
it = _videos.erase(it);
continue;
}
// Convert to the current screen format
convertedFrame = frame->convertTo(pixelFormat, video->getPalette());
frame = convertedFrame;
} else if (pixelFormat.bytesPerPixel == 1 && video->hasDirtyPalette()) {
// Set the palette when running in 8bpp mode only
// Don't do this for Myst, which has its own per-stack handling
if (_vm->getGameType() != GType_MYST)
_vm->_system->getPaletteManager()->setPalette(video->getPalette(), 0, 256);
}
// Clip the width/height to make sure we stay on the screen (Myst does this a few times)
uint16 width = MIN<int32>(video->getWidth(), _vm->_system->getWidth() - (*it)->getX());
uint16 height = MIN<int32>(video->getHeight(), _vm->_system->getHeight() - (*it)->getY());
_vm->_system->copyRectToScreen(frame->getPixels(), frame->pitch, (*it)->getX(), (*it)->getY(), width, height);
// We've drawn something to the screen, make sure we update it
updateScreen = true;
// Delete 8bpp conversion surface
if (convertedFrame) {
convertedFrame->free();
delete convertedFrame;
}
}
}
// Check the video time
_vm->doVideoTimer(*it, false);
// Remember to increase the iterator
it++;
}
// Return true if we need to update the screen
return updateScreen;
}
