Common::List<Graphics::PixelFormat> OSystem_Wii::getSupportedFormats() const { Common::List<Graphics::PixelFormat> res; res.push_back(_pfRGB565); res.push_back(Graphics::PixelFormat::createFormatCLUT8()); return res; }
void clearList(Common::List<T> &list) { while (!list.empty()) { T p = list.front(); list.erase(list.begin()); delete p; } }
SciVersion GameFeatures::detectMessageFunctionType() { if (_messageFunctionType != SCI_VERSION_NONE) return _messageFunctionType; if (getSciVersion() > SCI_VERSION_1_1) { _messageFunctionType = SCI_VERSION_1_1; return _messageFunctionType; } else if (getSciVersion() < SCI_VERSION_1_1) { _messageFunctionType = SCI_VERSION_1_LATE; return _messageFunctionType; } Common::List<ResourceId> resources = g_sci->getResMan()->listResources(kResourceTypeMessage, -1); if (resources.empty()) { // No messages found, so this doesn't really matter anyway... _messageFunctionType = SCI_VERSION_1_1; return _messageFunctionType; } Resource *res = g_sci->getResMan()->findResource(*resources.begin(), false); assert(res); // Only v2 Message resources use the kGetMessage kernel function. // v3-v5 use the kMessage kernel function. if (READ_SCI11ENDIAN_UINT32(res->data) / 1000 == 2) _messageFunctionType = SCI_VERSION_1_LATE; else _messageFunctionType = SCI_VERSION_1_1; debugC(1, kDebugLevelVM, "Detected message function type: %s", getSciVersionDesc(_messageFunctionType)); return _messageFunctionType; }
/** * Checks both the active and free process list to insure all the links are valid, * and that no processes have been lost */ void Scheduler::CheckStack() { Common::List<PROCESS *> pList; // Check both the active and free process lists for (int i = 0; i < 2; ++i) { PROCESS *p = (i == 0) ? active : pFreeProcesses; if (p != NULL) { // Make sure the linkages are correct while (p->pNext != NULL) { assert(p->pNext->pPrevious == p); pList.push_back(p); p = p->pNext; } pList.push_back(p); } } // Make sure all processes are accounted for for (int idx = 0; idx < NUM_PROCESS; idx++) { bool found = false; for (Common::List<PROCESS *>::iterator i = pList.begin(); i != pList.end(); ++i) { PROCESS *pTemp = *i; if (*i == &processList[idx]) { found = true; break; } } assert(found); } }
Common::String ThemeEngine::getThemeFile(const Common::String &id) { // FIXME: Actually "default" rather sounds like it should use // our default theme which would mean "scummmodern" instead // of the builtin one. if (id.equalsIgnoreCase("default")) return Common::String(); // For our builtin theme we don't have to do anything for now too if (id.equalsIgnoreCase("builtin")) return Common::String(); Common::FSNode node(id); // If the given id is a full path we'll just use it if (node.exists() && (node.isDirectory() || node.getName().matchString("*.zip", true))) return id; // FIXME: // A very ugly hack to map a id to a filename, this will generate // a complete theme list, thus it is slower than it could be. // But it is the easiest solution for now. Common::List<ThemeDescriptor> list; listUsableThemes(list); for (Common::List<ThemeDescriptor>::const_iterator i = list.begin(); i != list.end(); ++i) { if (id.equalsIgnoreCase(i->id)) return i->filename; } warning("Could not find theme '%s' falling back to builtin", id.c_str()); // If no matching id has been found we will // just fall back to the builtin theme return Common::String(); }
virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const { Common::List<Graphics::PixelFormat> result; result.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 10, 5, 0, 15)); result.push_back(Graphics::PixelFormat::createFormatCLUT8()); return result; }
void ThemeEngine::listUsableThemes(const Common::FSNode &node, Common::List<ThemeDescriptor> &list, int depth) { if (!node.exists() || !node.isReadable() || !node.isDirectory()) return; ThemeDescriptor td; // Check whether we point to a valid theme directory. if (themeConfigUsable(node, td.name)) { td.filename = node.getPath(); td.id = node.getName(); list.push_back(td); // A theme directory should never contain any other themes // thus we just return to the caller here. return; } Common::FSList fileList; // Check all files. We need this to find all themes inside ZIP archives. if (!node.getChildren(fileList, Common::FSNode::kListFilesOnly)) return; for (Common::FSList::iterator i = fileList.begin(); i != fileList.end(); ++i) { // We will only process zip files for now if (!i->getPath().matchString("*.zip", true)) continue; td.name.clear(); if (themeConfigUsable(*i, td.name)) { td.filename = i->getPath(); td.id = i->getName(); // If the name of the node object also contains // the ".zip" suffix, we will strip it. if (td.id.matchString("*.zip", true)) { for (int j = 0; j < 4; ++j) td.id.deleteLastChar(); } list.push_back(td); } } fileList.clear(); // Check if we exceeded the given recursion depth if (depth - 1 == -1) return; // As next step we will search all subdirectories if (!node.getChildren(fileList, Common::FSNode::kListDirectoriesOnly)) return; for (Common::FSList::iterator i = fileList.begin(); i != fileList.end(); ++i) listUsableThemes(*i, list, depth == -1 ? - 1 : depth - 1); }
Common::List<Graphics::PixelFormat> OSystem_Android::getSupportedFormats() const { Common::List<Graphics::PixelFormat> res; res.push_back(GLES565Texture::pixelFormat()); res.push_back(GLES5551Texture::pixelFormat()); res.push_back(GLES4444Texture::pixelFormat()); res.push_back(Graphics::PixelFormat::createFormatCLUT8()); return res; }
Common::List<Graphics::PixelFormat> TizenGraphicsManager::getSupportedFormats() const { logEntered(); Common::List<Graphics::PixelFormat> res; res.push_back(Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0)); res.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0)); res.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0)); res.push_back(Graphics::PixelFormat::createFormatCLUT8()); return res; }
Common::List<Graphics::PixelFormat> OSystem_3DS::getSupportedFormats() const { Common::List<Graphics::PixelFormat> list; list.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); // GPU_RGBA8 list.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0)); // GPU_RGB565 // list.push_back(Graphics::PixelFormat(3, 0, 0, 0, 8, 0, 8, 16, 0)); // GPU_RGB8 list.push_back(Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0)); // RGB555 (needed for FMTOWNS?) list.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0)); // GPU_RGBA5551 list.push_back(Graphics::PixelFormat::createFormatCLUT8()); return list; }
void ThemeEngine::listUsableThemes(Common::List<ThemeDescriptor> &list) { #ifndef DISABLE_GUI_BUILTIN_THEME ThemeDescriptor th; th.name = "ScummVM Classic Theme (Builtin Version)"; th.id = "builtin"; th.filename.clear(); list.push_back(th); #endif if (ConfMan.hasKey("themepath")) listUsableThemes(Common::FSNode(ConfMan.get("themepath")), list); listUsableThemes(SearchMan, list); // Now we need to strip all duplicates // TODO: It might not be the best idea to strip duplicates. The user might // have different versions of a specific theme in his paths, thus this code // might show him the wrong version. The problem is we have no ways of checking // a theme version currently. Also since we want to avoid saving the full path // in the config file we can not do any better currently. Common::List<ThemeDescriptor> output; for (Common::List<ThemeDescriptor>::const_iterator i = list.begin(); i != list.end(); ++i) { if (Common::find_if(output.begin(), output.end(), TDComparator(i->id)) == output.end()) output.push_back(*i); } list = output; output.clear(); }
Common::List<Graphics::PixelFormat> DisplayManager::getSupportedPixelFormats() const { Common::List<Graphics::PixelFormat> list; // In order of preference list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5650)); list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5551)); list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_4444)); list.push_back(Graphics::PixelFormat::createFormatCLUT8()); return list; }
void ViewManager::updateState() { Common::List<View *> viewList = _views; for (ListIterator i = viewList.begin(); i != viewList.end(); ++i) { if (_vm->_events->quitFlag) return; View *v = *i; v->updateState(); } }
/** * Determines the first matching format between two lists. * * @param backend The higher priority list, meant to be a list of formats supported by the backend * @param frontend The lower priority list, meant to be a list of formats supported by the engine * @return The first item on the backend list that also occurs on the frontend list * or PixelFormat::createFormatCLUT8() if no matching formats were found. */ inline PixelFormat findCompatibleFormat(Common::List<PixelFormat> backend, Common::List<PixelFormat> frontend) { #ifdef USE_RGB_COLOR for (Common::List<PixelFormat>::iterator i = backend.begin(); i != backend.end(); ++i) { for (Common::List<PixelFormat>::iterator j = frontend.begin(); j != frontend.end(); ++j) { if (*i == *j) return *i; } } #endif return PixelFormat::createFormatCLUT8(); }
/** * Determines the first matching format between two lists. * * @param backend The higher priority list, meant to be a list of formats supported by the backend * @param frontend The lower priority list, meant to be a list of formats supported by the engine * @return The first item on the backend list that also occurs on the frontend list * or PixelFormat::createFormatCLUT8() if no matching formats were found. */ inline Graphics::PixelFormat findCompatibleFormat(const Common::List<Graphics::PixelFormat> &backend, const Common::List<Graphics::PixelFormat> &frontend) { #ifdef USE_RGB_COLOR for (Common::List<Graphics::PixelFormat>::const_iterator i = backend.begin(); i != backend.end(); ++i) { for (Common::List<Graphics::PixelFormat>::const_iterator j = frontend.begin(); j != frontend.end(); ++j) { if (*i == *j) return *i; } } #endif return Graphics::PixelFormat::createFormatCLUT8(); }
bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList) const { // Loop until we find the closing brace Common::String line = stream.readLine(); trimCommentsAndWhiteSpace(&line); // Criteria can be empty if (line.contains('}')) { return false; } // Create a new List to hold the CriteriaEntries criteriaList.push_back(Common::List<Puzzle::CriteriaEntry>()); while (!stream.eos() && !line.contains('}')) { Puzzle::CriteriaEntry entry; // Split the string into tokens using ' ' as a delimiter Common::StringTokenizer tokenizer(line); Common::String token; // Parse the id out of the first token token = tokenizer.nextToken(); sscanf(token.c_str(), "[%u]", &(entry.key)); // Parse the operator out of the second token token = tokenizer.nextToken(); if (token.c_str()[0] == '=') entry.criteriaOperator = Puzzle::EQUAL_TO; else if (token.c_str()[0] == '!') entry.criteriaOperator = Puzzle::NOT_EQUAL_TO; else if (token.c_str()[0] == '>') entry.criteriaOperator = Puzzle::GREATER_THAN; else if (token.c_str()[0] == '<') entry.criteriaOperator = Puzzle::LESS_THAN; // First determine if the last token is an id or a value // Then parse it into 'argument' token = tokenizer.nextToken(); if (token.contains('[')) { sscanf(token.c_str(), "[%u]", &(entry.argument)); entry.argumentIsAKey = true; } else { sscanf(token.c_str(), "%u", &(entry.argument)); entry.argumentIsAKey = false; } criteriaList.back().push_back(entry); line = stream.readLine(); trimCommentsAndWhiteSpace(&line); } return true; }
void RMWindow::getNewFrame(RMGfxTargetBuffer &bigBuf, Common::Rect *rcBoundEllipse) { // Get a pointer to the bytes of the source buffer byte *lpBuf = bigBuf; if (rcBoundEllipse != NULL) { // Circular wipe effect getNewFrameWipe(lpBuf, *rcBoundEllipse); _wiping = true; } else if (_wiping) { // Just finished a wiping effect, so copy the full screen copyRectToScreen(lpBuf, RM_SX * 2, 0, 0, RM_SX, RM_SY); _wiping = false; } else { // Standard screen copy - iterate through the dirty rects Common::List<Common::Rect> dirtyRects = bigBuf.getDirtyRects(); Common::List<Common::Rect>::iterator i; // If showing dirty rects, copy the entire screen background and set up a surface pointer Graphics::Surface *s = NULL; if (_showDirtyRects) { copyRectToScreen(lpBuf, RM_SX * 2, 0, 0, RM_SX, RM_SY); s = g_system->lockScreen(); } for (i = dirtyRects.begin(); i != dirtyRects.end(); ++i) { Common::Rect &r = *i; const byte *lpSrc = lpBuf + (RM_SX * 2) * r.top + (r.left * 2); copyRectToScreen(lpSrc, RM_SX * 2, r.left, r.top, r.width(), r.height()); } if (_showDirtyRects) { for (i = dirtyRects.begin(); i != dirtyRects.end(); ++i) { // Frame the copied area with a rectangle s->frameRect(*i, 0xffffff); } g_system->unlockScreen(); } } if (_bGrabThumbnail) { // Need to generate a thumbnail RMSnapshot s; s.grabScreenshot(lpBuf, 4, _wThumbBuf); _bGrabThumbnail = false; } // Clear the dirty rect list bigBuf.clearDirtyRects(); }
void Location::freeList(Common::List<T> &list, bool removeAll, Common::MemFunc1<bool, T, Location> filter) { typedef typename Common::List<T>::iterator iterator; iterator it = list.begin(); while (it != list.end()) { T z = *it; if (!removeAll && filter(this, z)) { ++it; } else { z->_commands.clear(); it = list.erase(it); } } }
GameList ScummMetaEngine::detectGames(const Common::FSList &fslist) const { GameList detectedGames; Common::List<DetectorResult> results; ::detectGames(fslist, results, 0); // TODO: We still don't handle the FM-TOWNS demos (like zakloom) very well. // In particular, they are detected as ZakTowns, which is bad. for (Common::List<DetectorResult>::iterator x = results.begin(); x != results.end(); ++x) { const PlainGameDescriptor *g = findPlainGameDescriptor(x->game.gameid, gameDescriptions); assert(g); GameDescriptor dg(x->game.gameid, g->description, x->language, x->game.platform); // Append additional information, if set, to the description. dg.updateDesc(x->extra); // Compute and set the preferred target name for this game. // Based on generateComplexID() in advancedDetector.cpp. dg["preferredtarget"] = generatePreferredTarget(*x); // HACK: Detect and distinguish the FM-TOWNS demos if (x->game.platform == Common::kPlatformFMTowns && (x->game.features & GF_DEMO)) { if (x->md5 == "2d388339d6050d8ccaa757b64633954e") { // Indy + Loom demo dg.description() = "Indiana Jones and the Last Crusade & Loom"; dg.updateDesc(x->extra); dg["preferredtarget"] = "indyloom"; } else if (x->md5 == "77f5c9cc0986eb729c1a6b4c8823bbae") { // Zak + Loom demo dg.description() = "Zak McKracken & Loom"; dg.updateDesc(x->extra); dg["preferredtarget"] = "zakloom"; } else if (x->md5 == "3938ee1aa4433fca9d9308c9891172b1") { // Indy + Zak demo dg.description() = "Indiana Jones and the Last Crusade & Zak McKracken"; dg.updateDesc(x->extra); dg["preferredtarget"] = "indyzak"; } } dg.setGUIOptions(x->game.guioptions | MidiDriver::musicType2GUIO(x->game.midi)); dg.appendGUIOptions(getGameGUIOptionsDescriptionLanguage(x->language)); detectedGames.push_back(dg); } return detectedGames; }
void GlkEngine::initGraphicsMode() { uint width = ConfMan.hasKey("width") ? ConfMan.getInt("width") : 640; uint height = ConfMan.hasKey("height") ? ConfMan.getInt("height") : 480; Common::List<Graphics::PixelFormat> formats = g_system->getSupportedFormats(); Graphics::PixelFormat format = formats.front(); for (Common::List<Graphics::PixelFormat>::iterator i = formats.begin(); i != formats.end(); ++i) { if ((*i).bytesPerPixel > 1) { format = *i; break; } } initGraphics(width, height, &format); }
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; }
void initExtensions() { const char *exts = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)); Common::StringTokenizer tokenizer(exts, " "); while (!tokenizer.empty()) { g_extensions.push_back(tokenizer.nextToken()); } }
void ThemeEngine::listUsableThemes(Common::Archive &archive, Common::List<ThemeDescriptor> &list) { ThemeDescriptor td; Common::ArchiveMemberList fileList; archive.listMatchingMembers(fileList, "*.zip"); for (Common::ArchiveMemberList::iterator i = fileList.begin(); i != fileList.end(); ++i) { td.name.clear(); if (themeConfigUsable(**i, td.name)) { td.filename = (*i)->getName(); td.id = (*i)->getDisplayName(); // If the name of the node object also contains // the ".zip" suffix, we will strip it. if (td.id.matchString("*.zip", true)) { for (int j = 0; j < 4; ++j) td.id.deleteLastChar(); } list.push_back(td); } } fileList.clear(); }
void VideoPlayer::processVideoEvents(Common::List<Common::Event> &stopEvents) { Common::Event curEvent; Common::EventManager *eventMan = g_system->getEventManager(); // Process events, and skip video if esc is pressed while (eventMan->pollEvent(curEvent)) { if (curEvent.type == Common::EVENT_RTL || curEvent.type == Common::EVENT_QUIT) { _skipVideo = true; } for (Common::List<Common::Event>::const_iterator iter = stopEvents.begin(); iter != stopEvents.end(); iter++) { if (curEvent.type == iter->type) { if (iter->type == Common::EVENT_KEYDOWN || iter->type == Common::EVENT_KEYUP) { if (curEvent.kbd.keycode == iter->kbd.keycode) { _skipVideo = true; break; } } else { _skipVideo = true; break; } } } } }
Common::List<Graphics::PixelFormat> OpenGLSdlGraphicsManager::getSupportedFormats() const { Common::List<Graphics::PixelFormat> formats; // Our default mode is (memory layout wise) RGBA8888 which is a different // logical layout depending on the endianness. We chose this mode because // it is the only 32bit color mode we can safely assume to be present in // OpenGL and OpenGL ES implementations. Thus, we need to supply different // logical formats based on endianness. #ifdef SCUMM_LITTLE_ENDIAN // ABGR8888 formats.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24)); #else // RGBA8888 formats.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); #endif // RGB565 formats.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0)); // RGBA5551 formats.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0)); // RGBA4444 formats.push_back(Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0)); #if !USE_FORCED_GLES && !USE_FORCED_GLES2 #if !USE_FORCED_GL if (!isGLESContext()) { #endif #ifdef SCUMM_LITTLE_ENDIAN // RGBA8888 formats.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); #else // ABGR8888 formats.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24)); #endif #if !USE_FORCED_GL } #endif #endif // RGB555, this is used by SCUMM HE 16 bit games. // This is not natively supported by OpenGL ES implementations, we convert // the pixel format internally. formats.push_back(Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0)); formats.push_back(Graphics::PixelFormat::createFormatCLUT8()); return formats; }
void fill_list(common::List<bool>& list) { const Uint nb_rows = list.size(); for(Uint i = 0; i != nb_rows; ++i) { list[i] = (i % 2 == 0); } }
void EMIEngine::purgeText() { Common::List<TextObject *> toDelete; foreach (TextObject *t, TextObject::getPool()) { if (t->getStackLevel() == 0) { toDelete.push_back(t); } } while (!toDelete.empty()) { TextObject *t = toDelete.front(); toDelete.pop_front(); delete t; } invalidateTextObjectsSortOrder(); }
virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const { Common::List<Graphics::PixelFormat> result; /* RGBA8888 */ result.push_back(Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); #ifdef FRONTEND_SUPPORTS_RGB565 /* RGB565 - overlay */ result.push_back(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0)); #endif /* RGB555 - fmtowns */ result.push_back(Graphics::PixelFormat(2, 5, 5, 5, 1, 10, 5, 0, 15)); /* Palette - most games */ result.push_back(Graphics::PixelFormat::createFormatCLUT8()); return result; }
reg_t kLock(EngineState *s, int argc, reg_t *argv) { int state = argc > 2 ? argv[2].toUint16() : 1; ResourceType type = g_sci->getResMan()->convertResType(argv[0].toUint16()); ResourceId id = ResourceId(type, argv[1].toUint16()); Resource *which; switch (state) { case 1 : g_sci->getResMan()->findResource(id, 1); break; case 0 : if (id.getNumber() == 0xFFFF) { // Unlock all resources of the requested type Common::List<ResourceId> *resources = g_sci->getResMan()->listResources(type); Common::List<ResourceId>::iterator itr = resources->begin(); while (itr != resources->end()) { Resource *res = g_sci->getResMan()->testResource(*itr); if (res->isLocked()) g_sci->getResMan()->unlockResource(res); ++itr; } delete resources; } else { which = g_sci->getResMan()->findResource(id, 0); if (which) g_sci->getResMan()->unlockResource(which); else { if (id.getType() == kResourceTypeInvalid) warning("[resMan] Attempt to unlock resource %i of invalid type %i", id.getNumber(), argv[0].toUint16()); else // Happens in CD games (e.g. LSL6CD) with the message // resource. It isn't fatal, and it's usually caused // by leftover scripts. debugC(kDebugLevelResMan, "[resMan] Attempt to unlock non-existant resource %s", id.toString().c_str()); } } break; } return s->r_acc; }
void MoviePlayer::play(MovieText *movieTexts, uint32 numMovieTexts, uint32 leadIn, uint32 leadOut) { // This happens when quitting during the "eye" cutscene. if (_vm->shouldQuit()) return; _leadOutFrame = _decoder->getFrameCount(); if (_leadOutFrame > 60) _leadOutFrame -= 60; _movieTexts = movieTexts; _numMovieTexts = numMovieTexts; _currentMovieText = 0; _leadOut = leadOut; if (leadIn) { _vm->_sound->playMovieSound(leadIn, kLeadInSound); } if (_bgSoundStream) { _snd->playInputStream(Audio::Mixer::kSFXSoundType, _bgSoundHandle, _bgSoundStream); } bool terminated = false; Common::List<Common::Event> stopEvents; Common::Event stopEvent; stopEvents.clear(); stopEvent.type = Common::EVENT_KEYDOWN; stopEvent.kbd = Common::KEYCODE_ESCAPE; stopEvents.push_back(stopEvent); terminated = !playVideo(stopEvents); closeTextObject(_currentMovieText, NULL); if (terminated) { _snd->stopHandle(*_bgSoundHandle); _vm->_sound->stopMovieSounds(); _vm->_sound->stopSpeech(); } while (_snd->isSoundHandleActive(*_bgSoundHandle)) _system->delayMillis(100); }