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; }