WINTERMUTE: Remove all unneccessary #if 0 blocks

12 files changed, 51 insertions, 885 deletions

diff --git a/engines/wintermute/base/font/base_font_truetype.cpp b/engines/wintermute/base/font/base_font_truetype.cpp
index c643a5e1b1..638b939ec1 100644
--- a/engines/wintermute/base/font/base_font_truetype.cpp
+++ b/engines/wintermute/base/font/base_font_truetype.cpp
@@ -256,12 +256,6 @@ BaseSurface *BaseFontTT::renderTextToTexture(const WideString &text, int width,
 	} else if (align == TAL_RIGHT) {

 		alignment = Graphics::kTextAlignRight;

 	}

-	// TODO: This function gets called a lot, so warnings like these drown out the usefull information

-	static bool hasWarned = false;

-	if (!hasWarned) {

-		hasWarned = true;

-		warning("BaseFontTT::RenderTextToTexture - Not fully ported yet");

-	}

 

 	debugC(kWinterMuteDebugFont, "%s %d %d %d %d", text.c_str(), RGBCOLGetR(_layers[0]->_color), RGBCOLGetG(_layers[0]->_color), RGBCOLGetB(_layers[0]->_color), RGBCOLGetA(_layers[0]->_color));

 //	void drawString(Surface *dst, const Common::String &str, int x, int y, int w, uint32 color, TextAlign align = kTextAlignLeft, int deltax = 0, bool useEllipsis = true) const;

@@ -287,104 +281,7 @@ BaseSurface *BaseFontTT::renderTextToTexture(const WideString &text, int width,
 	delete surface;

 	delete convertedSurface;

 	return retSurface;

-#if 0 //TODO

-	int textHeight = lines.size() * (_maxCharHeight + _ascender);

-	SDL_Surface *surface = SDL_CreateRGBSurface(0, width, textHeight, 32, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000);

-

-	SDL_LockSurface(surface);

-

-	int posY = (int)GetLineHeight() - (int)_descender;

-

-	for (it = lines.begin(); it != lines.end(); ++it) {

-		TextLine *line = (*it);

-		int posX = 0;

-

-		switch (align) {

-		case TAL_CENTER:

-			posX += (width - line->GetWidth()) / 2;

-			break;

-

-		case TAL_RIGHT:

-			posX += width - line->GetWidth();

-			break;

-		}

-

-

-		textOffset = 0;

-		for (size_t i = 0; i < line->GetText().size(); i++) {

-			wchar_t ch = line->GetText()[i];

-

-			GlyphInfo *glyph = _glyphCache->GetGlyph(ch);

-			if (!glyph) {

-				continue;

-			}

-

-			textOffset = MAX(textOffset, glyph->GetBearingY());

-		}

-

-

-		int origPosX = posX;

-

-		wchar_t prevChar = L'\0';

-		for (size_t i = 0; i < line->GetText().size(); i++) {

-			wchar_t ch = line->GetText()[i];

-

-			GlyphInfo *glyph = _glyphCache->GetGlyph(ch);

-			if (!glyph) {

-				continue;

-			}

-

-			float kerning = 0;

-			if (prevChar != L'\0') {

-				kerning = GetKerning(prevChar, ch);

-			}

-			posX += (int)kerning;

-

-

-			if (glyph->GetBearingY() > 0) {

-				int i = 10;

-			}

-

-			SDL_Rect rect;

-			rect.x = posX + glyph->GetBearingX();

-			rect.y = posY - glyph->GetBearingY() + textOffset;

-			rect.w = glyph->GetImage()->w;

-			rect.h = glyph->GetImage()->h;

-

-			BlitSurface(glyph->GetImage(), surface, &rect);

-

-			prevChar = ch;

-			posX += (int)(glyph->GetAdvanceX());

-			posY += (int)(glyph->GetAdvanceY());

-		}

-

-		if (_isUnderline) {

-			for (int i = origPosX; i < origPosX + line->GetWidth(); i++) {

-				Uint8 *buf = (Uint8 *)surface->pixels + (int)(_underlinePos + _ascender) * surface->pitch;

-				Uint32 *buf32 = (Uint32 *)buf;

-

-				buf32[i] = SDL_MapRGBA(surface->format, 255, 255, 255, 255);

-			}

-		}

-

-		SDL_UnlockSurface(surface);

-

-		delete line;

-		line = NULL;

-		posY += GetLineHeight();

-	}

-

-	BaseSurfaceOSystem *wmeSurface = new BaseSurfaceOSystem(_gameRef);

-	if (DID_SUCCEED(wmeSurface->CreateFromSDLSurface(surface))) {

-		SDL_FreeSurface(surface);

-		return wmeSurface;

-	} else {

-		SDL_FreeSurface(surface);

-		delete wmeSurface;

-		return NULL;

-	}

-#endif

-	return NULL;

+	// TODO: _isUnderline, _isBold, _isItalic, _isStriked

 }

 

 

@@ -666,65 +563,6 @@ bool BaseFontTT::initFont() {
 	}

 	_lineHeight = _font->getFontHeight();

 	return STATUS_OK;

-#if 0

-	FT_Error error;

-

-	float vertDpi = 96.0;

-	float horDpi = 96.0;

-

-

-	_fTStream = (FT_Stream)new byte[sizeof(*_fTStream)];

-	memset(_fTStream, 0, sizeof(*_fTStream));

-

-	_fTStream->read = BaseFontTT::FTReadSeekProc;

-	_fTStream->close = BaseFontTT::FTCloseProc;

-	_fTStream->descriptor.pointer = file;

-	_fTStream->size = file->GetSize();

-

-	FT_Open_Args args;

-	args.flags = FT_OPEN_STREAM;

-	args.stream = _fTStream;

-

-	error = FT_Open_Face(_gameRef->_fontStorage->GetFTLibrary(), &args, 0, &_fTFace);

-	if (error) {

-		SAFE_DELETE_ARRAY(_fTStream);

-		_gameRef->_fileManager->closeFile(file);

-		return STATUS_FAILED;

-	}

-

-	error = FT_Set_Char_Size(_fTFace, 0, (FT_F26Dot6)(_fontHeight * 64), (FT_UInt)horDpi, (FT_UInt)vertDpi);

-	if (error) {

-		FT_Done_Face(_fTFace);

-		_fTFace = NULL;

-		return STATUS_FAILED;

-	}

-

-	// http://en.wikipedia.org/wiki/E_(typography)

-	float pixelsPerEm = (_fontHeight / 72.f) * vertDpi; // Size in inches * dpi

-	float emsPerUnit = 1.0f / _fTFace->units_per_EM;

-	float pixelsPerUnit = pixelsPerEm * EmsPerUnit;

-

-	// bounding box in pixels

-	float xMin = _fTFace->bbox.xMin * pixelsPerUnit;

-	float xMax = _fTFace->bbox.xMax * pixelsPerUnit;

-	float yMin = _fTFace->bbox.yMin * pixelsPerUnit;

-	float yMax = _fTFace->bbox.yMax * pixelsPerUnit;

-

-	// metrics in pixels

-	_ascender = _fTFace->ascender * pixelsPerUnit;

-	_descender = - _fTFace->descender * pixelsPerUnit;

-	_lineHeight = MathUtil::RoundUp(_fTFace->height * pixelsPerUnit) + 2;

-	_underlinePos = - _fTFace->underline_position * pixelsPerUnit;

-

-	// max character size (used for texture grid)

-	_maxCharWidth  = (size_t)MathUtil::RoundUp(xMax - xMin);

-	_maxCharHeight = (size_t)MathUtil::RoundUp(yMax - yMin);

-

-	_glyphCache = new FontGlyphCache();

-	_glyphCache->Initialize();

-

-#endif

-	return STATUS_OK;

 }

 

 //////////////////////////////////////////////////////////////////////////

diff --git a/engines/wintermute/base/gfx/base_image.cpp b/engines/wintermute/base/gfx/base_image.cpp
index 3aa21d0f7f..1fff59d85b 100644
--- a/engines/wintermute/base/gfx/base_image.cpp
+++ b/engines/wintermute/base/gfx/base_image.cpp
@@ -114,23 +114,16 @@ bool BaseImage::saveBMPFile(const char *filename) const {
 

 //////////////////////////////////////////////////////////////////////////

 bool BaseImage::resize(int newWidth, int newHeight) {

-	warning("BaseImage::resize(%d, %d), stubbed", newWidth, newHeight);

-#if 0

-	if (!_bitmap) {

-		return STATUS_FAILED;

-	}

-

-	if (newWidth == 0) {

-		NewWidth = FreeImage_GetWidth(_bitmap);

-	}

-	if (newHeight == 0) {

-		NewHeight = FreeImage_GetHeight(_bitmap);

+	// WME Lite used FILTER_BILINEAR with FreeImage_Rescale here.

+	TransparentSurface temp(*_surface, true);

+	if (_deletableSurface) {

+		_deletableSurface->free();

+		delete _deletableSurface;

+		_deletableSurface = NULL;

 	}

-

-

-	FIBITMAP *newImg = FreeImage_Rescale(_bitmap, NewWidth, NewHeight, FILTER_BILINEAR);

-#endif

-	return false;

+	_surface = _deletableSurface = temp.scaleSafe((uint16)newWidth, (uint16)newHeight);

+	temp.free();

+	return true;

 }

 

 

diff --git a/engines/wintermute/base/gfx/base_renderer.h b/engines/wintermute/base/gfx/base_renderer.h
index 83b5ad0e16..008db69713 100644
--- a/engines/wintermute/base/gfx/base_renderer.h
+++ b/engines/wintermute/base/gfx/base_renderer.h
@@ -62,6 +62,7 @@ public:
 	virtual BaseImage *takeScreenshot() = 0;

 	virtual bool setViewport(int left, int top, int right, int bottom);

 	virtual bool setViewport(Rect32 *rect);

+	virtual Rect32 getViewPort() = 0;

 	virtual bool setScreenViewport();

 

 	virtual Graphics::PixelFormat getPixelFormat() const = 0;

diff --git a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
index 00ef2ec95c..90dda1af72 100644
--- a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
+++ b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
@@ -231,8 +231,6 @@ bool BaseRenderOSystem::flip() {
 

 //////////////////////////////////////////////////////////////////////////

 bool BaseRenderOSystem::fill(byte r, byte g, byte b, Common::Rect *rect) {

-	//SDL_SetRenderDrawColor(_renderer, r, g, b, 0xFF);

-	//SDL_RenderClear(_renderer);

 	_clearColor = _renderSurface->format.ARGBToColor(0xFF, r, g, b);

 	if (!_disableDirtyRects) {

 		return STATUS_OK;

@@ -240,6 +238,7 @@ bool BaseRenderOSystem::fill(byte r, byte g, byte b, Common::Rect *rect) {
 	if (!rect) {

 		rect = &_renderRect;

 	}

+	// TODO: This doesn't work with dirty rects

 	_renderSurface->fillRect(*rect, _clearColor);

 

 	return STATUS_OK;

@@ -410,7 +409,6 @@ void BaseRenderOSystem::addDirtyRect(const Common::Rect &rect) {
 		_dirtyRect->extend(rect);

 	}

 	_dirtyRect->clip(_renderRect);

-//	warning("AddDirtyRect: %d %d %d %d", rect.left, rect.top, rect.right, rect.bottom);

 }

 

 void BaseRenderOSystem::drawTickets() {

@@ -421,7 +419,6 @@ void BaseRenderOSystem::drawTickets() {
 		if ((*it)->_wantsDraw == false || (*it)->_isValid == false) {

 			RenderTicket *ticket = *it;

 			addDirtyRect((*it)->_dstRect);

-			//warning("Discarding Rect: %d %d %d %d Width: %d Height: %d", (*it)->_dstRect.left, (*it)->_dstRect.top, (*it)->_dstRect.right, (*it)->_dstRect.bottom, (*it)->_dstRect.width() , (*it)->_dstRect.height());

 			it = _renderQueue.erase(it);

 			delete ticket;

 			decrement++;

@@ -436,7 +433,6 @@ void BaseRenderOSystem::drawTickets() {
 	// The color-mods are stored in the RenderTickets on add, since we set that state again during

 	// draw, we need to keep track of what it was prior to draw.

 	uint32 oldColorMod = _colorMod;

-//	warning("DirtyRect: %d %d %d %d Width: %d Height: %d", _dirtyRect->left, _dirtyRect->top, _dirtyRect->right, _dirtyRect->bottom, _dirtyRect->width(), _dirtyRect->height());

 

 	// Apply the clear-color to the dirty rect.

 	_renderSurface->fillRect(*_dirtyRect, _clearColor);

@@ -521,38 +517,11 @@ bool BaseRenderOSystem::drawLine(int x1, int y1, int x2, int y2, uint32 color) {
 

 //////////////////////////////////////////////////////////////////////////

 BaseImage *BaseRenderOSystem::takeScreenshot() {

-// TODO: Fix this

+// TODO: Clip by viewport.

 	warning("BaseRenderOSystem::TakeScreenshot() - not ported yet");

 	BaseImage *screenshot = new BaseImage(_gameRef->_fileManager);

 	screenshot->copyFrom(_renderSurface);

 	return screenshot;

-#if 0

-	SDL_Rect viewport;

-

-	SDL_RenderGetViewport(_renderer, &viewport);

-

-	SDL_Surface *surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, 0x00000000);

-	if (!surface) {

-		return NULL;

-	}

-

-	if (SDL_RenderReadPixels(_renderer, NULL, surface->format->format, surface->pixels, surface->pitch) < 0) {

-		return NULL;

-	}

-

-	FIBITMAP *dib = FreeImage_Allocate(viewport.w, viewport.h, 24, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);

-

-	int bytespp = FreeImage_GetLine(dib) / FreeImage_GetWidth(dib);

-

-	for (unsigned y = 0; y < FreeImage_GetHeight(dib); y++) {

-		byte *bits = FreeImage_GetScanLine(dib, y);

-		byte *src = (byte *)surface->pixels + (viewport.h - y - 1) * surface->pitch;

-		memcpy(bits, src, bytespp * viewport.w);

-	}

-

-	return new BaseImage(_gameRef,  dib);

-#endif

-	return NULL;

 }

 

 //////////////////////////////////////////////////////////////////////////

@@ -569,84 +538,43 @@ bool BaseRenderOSystem::setViewport(int left, int top, int right, int bottom) {
 	rect.right = (int16)((right - left) * _ratioX);

 	rect.bottom = (int16)((bottom - top) * _ratioY);

 

+	_renderRect = rect;

 	return STATUS_OK;

 }

 

+Rect32 BaseRenderOSystem::getViewPort() {

+	Rect32 ret;

+	ret.top = _renderRect.top;

+	ret.bottom = _renderRect.bottom;

+	ret.left = _renderRect.left;

+	ret.right = _renderRect.right;

+	return ret;

+}

+

 //////////////////////////////////////////////////////////////////////////

 void BaseRenderOSystem::modTargetRect(Common::Rect *rect) {

-#if 0

-	SDL_Rect viewportRect;

-	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

-

-	rect->x = MathUtil::Round(rect->x * _ratioX + _borderLeft - viewportRect.x);

-	rect->y = MathUtil::Round(rect->y * _ratioY + _borderTop - viewportRect.y);

-	rect->w = MathUtil::RoundUp(rect->w * _ratioX);

-	rect->h = MathUtil::RoundUp(rect->h * _ratioY);

-#endif

+	rect->left = MathUtil::round(rect->left * _ratioX + _borderLeft - _renderRect.left);

+	rect->top = MathUtil::round(rect->top * _ratioY + _borderTop - _renderRect.top);

+	rect->setWidth(MathUtil::roundUp(rect->width() * _ratioX));

+	rect->setHeight(MathUtil::roundUp(rect->height() * _ratioY));

 }

 

 //////////////////////////////////////////////////////////////////////////

 void BaseRenderOSystem::pointFromScreen(Point32 *point) {

-#if 0

-	SDL_Rect viewportRect;

-	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

-

-	point->x = point->x / _ratioX - _borderLeft / _ratioX + viewportRect.x;

-	point->y = point->y / _ratioY - _borderTop / _ratioY + viewportRect.y;

-#endif

+	point->x = point->x / _ratioX - _borderLeft / _ratioX + _renderRect.left;

+	point->y = point->y / _ratioY - _borderTop / _ratioY + _renderRect.top;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

 void BaseRenderOSystem::pointToScreen(Point32 *point) {

-#if 0

-	SDL_Rect viewportRect;

-	SDL_RenderGetViewport(GetSdlRenderer(), &viewportRect);

-

-	point->x = MathUtil::RoundUp(point->x * _ratioX) + _borderLeft - viewportRect.x;

-	point->y = MathUtil::RoundUp(point->y * _ratioY) + _borderTop - viewportRect.y;

-#endif

+	point->x = MathUtil::roundUp(point->x * _ratioX) + _borderLeft - _renderRect.left;

+	point->y = MathUtil::roundUp(point->y * _ratioY) + _borderTop - _renderRect.top;

 }

 

 //////////////////////////////////////////////////////////////////////////

 void BaseRenderOSystem::dumpData(const char *filename) {

-	warning("BaseRenderOSystem::DumpData(%s) - not reimplemented yet", filename); // TODO

-#if 0

-	FILE *f = fopen(filename, "wt");

-	if (!f) {

-		return;

-	}

-

-	BaseSurfaceStorage *Mgr = _gameRef->_surfaceStorage;

-

-	int totalKB = 0;

-	int totalLoss = 0;

-	fprintf(f, "Filename;Usage;Size;KBytes\n");

-	for (int i = 0; i < Mgr->_surfaces.getSize(); i++) {

-		BaseSurfaceOSystem *Surf = (BaseSurfaceOSystem *)Mgr->_surfaces[i];

-		if (!Surf->_filename) {

-			continue;

-		}

-		if (!Surf->_valid) {

-			continue;

-		}

-

-		fprintf(f, "%s;%d;", Surf->_filename, Surf->_referenceCount);

-		fprintf(f, "%dx%d;", Surf->getWidth(), Surf->getHeight());

-

-		int kb = Surf->getWidth() * Surf->getHeight() * 4 / 1024;

-

-		TotalKB += kb;

-		fprintf(f, "%d;", kb);

-		fprintf(f, "\n");

-	}

-	fprintf(f, "Total %d;;;%d\n", Mgr->_surfaces.getSize(), TotalKB);

-

-

-	fclose(f);

-	_gameRef->LOG(0, "Texture Stats Dump completed.");

-	_gameRef->QuickMessage("Texture Stats Dump completed.");

-#endif

+	warning("BaseRenderOSystem::DumpData(%s) - stubbed", filename); // TODO

 }

 

 BaseSurface *BaseRenderOSystem::createSurface() {

diff --git a/engines/wintermute/base/gfx/osystem/base_render_osystem.h b/engines/wintermute/base/gfx/osystem/base_render_osystem.h
index 0d00b1b427..dfffc68c17 100644
--- a/engines/wintermute/base/gfx/osystem/base_render_osystem.h
+++ b/engines/wintermute/base/gfx/osystem/base_render_osystem.h
@@ -82,7 +82,7 @@ public:
 	void drawFromTicket(RenderTicket *renderTicket);

 

 	bool setViewport(int left, int top, int right, int bottom);

-

+	Rect32 getViewPort();

 	void modTargetRect(Common::Rect *rect);

 	void pointFromScreen(Point32 *point);

 	void pointToScreen(Point32 *point);

diff --git a/engines/wintermute/base/scriptables/script_ext_date.cpp b/engines/wintermute/base/scriptables/script_ext_date.cpp
index a3bb7e2183..181be8ddd0 100644
--- a/engines/wintermute/base/scriptables/script_ext_date.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_date.cpp
@@ -68,9 +68,7 @@ const char *SXDate::scToString() {
 	// TODO: Make this more stringy, and less ISO 8601-like

 	_strRep.format("%04d-%02d-%02d - %02d:%02d:%02d", _tm.tm_year, _tm.tm_mon, _tm.tm_mday, _tm.tm_hour, _tm.tm_min, _tm.tm_sec);

 	return _strRep.c_str();

-#if 0

-	return asctime(&_tm);

-#endif

+	//return asctime(&_tm);

 }

 

 

diff --git a/engines/wintermute/base/scriptables/script_value.cpp b/engines/wintermute/base/scriptables/script_value.cpp
index 01cb4044ff..9b83daf42f 100644
--- a/engines/wintermute/base/scriptables/script_value.cpp
+++ b/engines/wintermute/base/scriptables/script_value.cpp
@@ -166,11 +166,7 @@ ScValue *ScValue::getProp(const char *name) {
 	if (_type == VAL_STRING && strcmp(name, "Length") == 0) {

 		_gameRef->_scValue->_type = VAL_INT;

 

-#if 0 // TODO: Remove FreeType-dependency

 		if (_gameRef->_textEncoding == TEXT_ANSI) {

-#else

-		if (true) {

-#endif

 			_gameRef->_scValue->setInt(strlen(_valString));

 		} else {

 			WideString wstr = StringUtil::utf8ToWide(_valString);

diff --git a/engines/wintermute/platform_osystem.cpp b/engines/wintermute/platform_osystem.cpp
index c7d0c6cfed..32d53e3a50 100644
--- a/engines/wintermute/platform_osystem.cpp
+++ b/engines/wintermute/platform_osystem.cpp
@@ -179,8 +179,8 @@ bool BasePlatform::setCursorPos(int x, int y) {
 	p.x = x;

 	p.y = y;

 	renderer->pointToScreen(&p);

-// TODO

-	//SDL_WarpMouseInWindow(renderer->GetSdlWindow(), p.x, p.y);

+

+	g_system->warpMouse(x, y);

 	return true;

 }

 

diff --git a/engines/wintermute/utils/path_util.cpp b/engines/wintermute/utils/path_util.cpp
index 2fbe785a38..4e36c3e316 100644
--- a/engines/wintermute/utils/path_util.cpp
+++ b/engines/wintermute/utils/path_util.cpp
@@ -163,40 +163,9 @@ bool PathUtil::fileExists(const AnsiString &fileName) {
 

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::getUserDirectory() {

+AnsiString PathUtil::getUserDirectory() { // TODO: Get rid of

 	warning("PathUtil::GetUserDirectory - stubbed");

 	AnsiString userDir = "./";

-#if 0

-#ifdef __WIN32__

-	char buffer[MAX_PATH_LENGTH];

-	buffer[0] = '\0';

-	LPITEMIDLIST pidl = NULL;

-	LPMALLOC pMalloc;

-	if (DID_SUCCEED(SHGetMalloc(&pMalloc))) {

-		SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA, &pidl);

-		if (pidl) {

-			SHGetPathFromIDList(pidl, buffer);

-		}

-		pMalloc->Free(pidl);

-		userDir = AnsiString(buffer);

-	}

-#elif __MACOSX__

-	FSRef fileRef;

-	OSStatus error = FSFindFolder(kUserDomain, kApplicationSupportFolderType, true, &fileRef);

-	if (error == noErr) {

-		char buffer[MAX_PATH_LENGTH];

-		error = FSRefMakePath(&fileRef, (UInt8 *)buffer, sizeof(buffer));

-		if (error == noErr) {

-			userDir = buffer;

-		}

-

-	}

-#elif __IPHONEOS__

-	char path[MAX_PATH_LENGTH];

-	IOS_GetDataDir(path);

-	userDir = AnsiString(path);

-#endif

-#endif // 0

 	return userDir;

 }

 

diff --git a/engines/wintermute/video/video_player.cpp b/engines/wintermute/video/video_player.cpp
index a4c81d12b5..d0b4019621 100644
--- a/engines/wintermute/video/video_player.cpp
+++ b/engines/wintermute/video/video_player.cpp
@@ -29,8 +29,6 @@
 
 #include "engines/wintermute/video/video_player.h"
 
-//#pragma comment(lib, "vfw32.lib")
-
 namespace WinterMute {
 
 //////////////////////////////////////////////////////////////////////
@@ -42,33 +40,13 @@ VideoPlayer::VideoPlayer(BaseGame *inGame): BaseClass(inGame) {
 	setDefaults();
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::setDefaults() {
 	_playing = false;
-
-	/*  _aviFile = NULL;
-
-	    _audioStream = NULL;
-	    _audioFormat = NULL;
-
-	    _videoStream = NULL;
-	    _videoFormat = NULL;
-	    _videoPGF = NULL;*/
 	_videoEndTime = 0;
-
-	//_sound = NULL;
 	_soundAvailable = false;
-
-	//_vidRenderer = NULL;
-
 	_startTime = 0;
 	_totalVideoTime = 0;
-
-	//_lastSample = -1;
-
-	//_targetFormat = NULL;
-
 	_playPosX = _playPosY = 0;
 	_playZoom = 0.0f;
 
@@ -82,450 +60,49 @@ bool VideoPlayer::setDefaults() {
 	return STATUS_OK;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 VideoPlayer::~VideoPlayer() {
 	cleanup();
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::cleanup() {
-#if 0
-	if (_sound) {
-		_sound->Stop();
-	}
-	if (_videoPGF) {
-		AVIStreamGetFrameClose(_videoPGF);
-	}
-	_videoPGF = NULL;
-
-	_playing = false;
-
-
-	if (_aviFile) {
-		AVIFileRelease(m_AviFile);
-	}
-
-	if (_audioStream) {
-		AVIStreamRelease(m_AudioStream);
-	}
-	if (_videoStream) {
-		AVIStreamRelease(m_VideoStream);
-	}
-
-	if (_audioFormat) {
-		delete[](byte *)m_AudioFormat;
-	}
-	if (_videoFormat) {
-		delete[](byte *)m_VideoFormat;
-	}
-	if (_targetFormat) {
-		delete[](byte *)m_TargetFormat;
-	}
-
-	SAFE_DELETE(_sound);
-	SAFE_DELETE(_vidRenderer);
-
-	SAFE_DELETE_ARRAY(_filename);
-
-	for (int i = 0; i < _subtitles.getSize(); i++) {
-		delete _subtitles[i];
-	}
-	_subtitles.clear();
-
-	return SetDefaults();
-#endif
 	return 0;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
-bool VideoPlayer::initialize(const char *inFilename, const char *SubtitleFile) {
-#if 0
-	cleanup();
-
-	char filename[MAX_PATH_LENGTH];
-	_gameRef->_fileManager->GetFullPath(inFilename, filename);
-
-	// open file
-	if (AVIFileOpen(&_aviFile, Filename, OF_READ, NULL) != 0) {
-		_gameRef->LOG(0, "Error opening AVI file '%s'", filename);
-		return STATUS_FAILED;
-	}
-
-	// get video stream
-	if (AVIFileGetStream(_aviFile, &_videoStream, streamtypeVIDEO, 0) != 0) {
-		_gameRef->LOG(0, "Error finding video stream in AVI file '%s'", filename);
-		return STATUS_FAILED;
-	}
-	_totalVideoTime = AVIStreamEndTime(_videoStream);
-
-	// get audio stream
-	if (_gameRef->m_SoundMgr->_soundAvailable && AVIFileGetStream(_aviFile, &_audioStream, streamtypeAUDIO, 0) == 0) {
-		_soundAvailable = true;
-	} else {
-		_soundAvailable = false;
-	}
-
-
-	LONG Size;
-
-	// get video format
-	if (AVIStreamReadFormat(m_VideoStream, 0, NULL, &Size)) {
-		_gameRef->LOG(0, "Error obtaining video stream format in AVI file '%s'", filename);
-		return STATUS_FAILED;
-	}
-	_videoFormat = (LPBITMAPINFO)new BYTE[Size];
-	AVIStreamReadFormat(m_VideoStream, 0, m_VideoFormat, &Size);
-
-	// initialize optimal target format
-	m_TargetFormat = (LPBITMAPV4HEADER)new BYTE[max(Size, sizeof(BITMAPV4HEADER))];
-	memset(m_TargetFormat, 0, sizeof(BITMAPV4HEADER));
-	memcpy(m_TargetFormat, m_VideoFormat, Size);
-	m_TargetFormat->bV4Size = max(Size, sizeof(BITMAPV4HEADER));
-
-	m_TargetFormat->bV4BitCount = 24;
-	m_TargetFormat->bV4V4Compression = BI_RGB;
-
-	if (_gameRef->m_UseD3D) {
-		m_VidRenderer = new CVidRendererD3D(_gameRef);
-	} else {
-		m_VidRenderer = new CVidRendererDD(_gameRef);
-	}
-
-	if (!m_VidRenderer || DID_FAIL(m_VidRenderer->Initialize(m_VideoFormat, m_TargetFormat))) {
-		_gameRef->LOG(0, "Error initializing video renderer for AVI file '%s'", filename);
-		SAFE_DELETE(m_VidRenderer);
-		return STATUS_FAILED;
-	}
-
-
-	// create sound buffer
-	bool res;
-
-	if (_soundAvailable) {
-		_sound = new BaseSoundAVI(_gameRef);
-		if (DID_FAIL(res = _sound->InitializeBuffer(_audioStream))) {
-			SAFE_DELETE(_sound);
-			_soundAvailable = false;
-			_gameRef->LOG(res, "Error initializing sound buffer for AVI file '%s'", filename);
-		}
-	}
-
-	if (_gameRef->_videoSubtitles) {
-		LoadSubtitles(inFilename, SubtitleFile);
-	}
-
-	_filename = new char[strlen(filename) + 1];
-	if (_filename) {
-		strcpy(_filename, filename);
-	}
-#endif
+bool VideoPlayer::initialize(const char *inFilename, const char *subtitleFile) {
+	warning("VideoPlayer: %s %s - Not implemented yet", inFilename, subtitleFile);
 	return STATUS_OK;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::update() {
-#if 0
-	if (!m_Playing) {
-		return STATUS_OK;
-	}
-
-	bool res;
-
-	if (_soundAvailable && m_Sound) {
-		res = _sound->update();
-		if (DID_FAIL(res)) {
-			return res;
-		}
-	}
-
-
-	DWORD CurrentTime; // current playing time (in ms)
-	/*
-	 if (m_SoundAvailable && m_Sound){
-	 CurrentTime = m_Sound->GetPosition(); // in samples
-	 CurrentTime /= (m_Sound->m_Format.wf.nSamplesPerSec / 1000);
-
-	 if (!m_Sound->IsPlaying()) CurrentTime = m_TotalVideoTime;
-	 }
-	 else
-	 CurrentTime = timeGetTime() - m_StartTime;
-	 */
-	CurrentTime = timeGetTime() - _startTime;
-
-	if (CurrentTime >= _totalVideoTime) {
-		Stop();
-		return STATUS_OK;
-	}
-
-
-	// get and render frame
-	DWORD sample = AVIStreamTimeToSample(_videoStream, CurrentTime);
-	if (sample != _lastSample) {
-		_lastSample = sample;
-
-		// process subtitles
-		_showSubtitle = false;
-		while (_currentSubtitle < _subtitles.getSize()) {
-			int end = _subtitles[_currentSubtitle]->m_EndFrame;
-
-			bool nextFrameOK = (_currentSubtitle < _subtitles.getSize() - 1 && _subtitles[_currentSubtitle + 1]->_startFrame <= sample);
-
-			if (sample > End) {
-				if (NextFrameOK) {
-					_currentSubtitle++;
-				} else {
-					_showSubtitle = (End == 0);
-					break;
-				}
-			} else {
-				_showSubtitle = true;
-				break;
-			}
-		}
-
-
-		// render frame
-		LPBITMAPINFOHEADER FrameData = (LPBITMAPINFOHEADER)AVIStreamGetFrame(m_VideoPGF, sample);
-		if (FrameData) {
-			if (_slowRendering) {
-				return _vidRenderer->ProcessFrameSlow(FrameData);
-			} else {
-				return _vidRenderer->ProcessFrame(FrameData);
-			}
-		} else {
-			return STATUS_FAILED;
-		}
-	} else {
-		return STATUS_OK;
-	}
-#endif
 	return 0;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::display() {
-#if 0
-	if (!m_Playing) {
-		return STATUS_OK;
-	}
-
-	bool res;
-	if (_vidRenderer) {
-		res = _vidRenderer->display(m_PlayPosX, m_PlayPosY, m_PlayZoom);
-	} else {
-		res = STATUS_FAILED;
-	}
-
-	// display subtitle
-	if (m_ShowSubtitle) {
-		BaseFont *font = _gameRef->_videoFont ? _gameRef->_videoFont : _gameRef->_systemFont;
-		int height = font->GetTextHeight((BYTE *)m_Subtitles[_currentSubtitle]->_text, _gameRef->_renderer->_width);
-		font->drawText((byte *)_subtitles[m_CurrentSubtitle]->_text, 0, _gameRef->_renderer->_height - Height - 5, _gameRef->_renderer->_width, TAL_CENTER);
-	}
-
-	return res;
-#endif
 	return 0;
 }
 
-
-
-
 //////////////////////////////////////////////////////////////////////////
-bool VideoPlayer::play(TVideoPlayback type, int x, int y, bool FreezeMusic) {
-#if 0
-	if (!_videoStream || !_vidRenderer) {
-		return STATUS_FAILED;
-	}
-
-	switch (Type) {
-	case VID_PLAY_POS:
-		_playZoom = 100.0f;
-		_playPosX = X;
-		_playPosY = Y;
-		break;
-
-	case VID_PLAY_STRETCH: {
-		float zoomX = (float)((float)_gameRef->_renderer->m_Width / (float)_videoFormat->bmiHeader.biWidth * 100);
-		float zoomY = (float)((float)_gameRef->_renderer->m_Height / (float)_videoFormat->bmiHeader.biHeight * 100);
-		_playZoom = min(ZoomX, ZoomY);
-		_playPosX = (_gameRef->_renderer->_width - _videoFormat->bmiHeader.biWidth * (_playZoom / 100)) / 2;
-		_playPosY = (_gameRef->_renderer->_height - _videoFormat->bmiHeader.biHeight * (_playZoom / 100)) / 2;
-	}
-	break;
-
-	case VID_PLAY_CENTER:
-		_playZoom = 100.0f;
-		_playPosX = (_gameRef->_renderer->_width - _videoFormat->bmiHeader.biWidth) / 2;
-		_playPosY = (_gameRef->_renderer->_height - _videoFormat->bmiHeader.biHeight) / 2;
-		break;
-	}
-
-	_targetFormat->bV4BitCount = 24;
-	_targetFormat->bV4V4Compression = BI_RGB;
-
-
-	_videoPGF = AVIStreamGetFrameOpen(_videoStream, (LPBITMAPINFOHEADER)m_TargetFormat);
-	if (!_videoPGF) {
-		_videoPGF = AVIStreamGetFrameOpen(_videoStream, NULL);
-		if (!_videoPGF) {
-			_gameRef->LOG(0, "Error: Unsupported AVI format (file '%s')", m_Filename);
-			cleanup();
-			return STATUS_FAILED;
-		} else {
-			_gameRef->LOG(0, "Performance warning: non-optimal AVI format, using generic (i.e. slow) rendering routines (file '%s')", m_Filename);
-			_slowRendering = true;
-		}
-	} else {
-		_slowRendering = false;
-	}
-
-	// HACK!!!
-	_slowRendering = true;
-
-
-	_currentSubtitle = 0;
-
-	_gameRef->Freeze(FreezeMusic);
-
-	_playing = true;
-	if (_sound) {
-		_sound->Play();
-	}
-	_startTime = timeGetTime();
-#endif
+bool VideoPlayer::play(TVideoPlayback type, int x, int y, bool freezeMusic) {
 	return STATUS_OK;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::stop() {
-#if 0
-	if (!_playing) {
-		return STATUS_OK;
-	}
-
-	cleanup();
-
-	_gameRef->Unfreeze();
-#endif
 	return STATUS_OK;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 bool VideoPlayer::isPlaying() {
 	return _playing;
 }
 
-
 //////////////////////////////////////////////////////////////////////////
-bool VideoPlayer::loadSubtitles(const char *filename, const char *SubtitleFile) {
-#if 0
-	if (!Filename) {
-		return STATUS_OK;
-	}
-
-	char newFile[MAX_PATH_LENGTH];
-	char drive[_MAX_DRIVE];
-	char dir[_MAX_DIR];
-	char fname[_MAX_FNAME];
-
-	if (SubtitleFile) {
-		strcpy(NewFile, SubtitleFile);
-	} else {
-		_splitpath(filename, drive, dir, fname, NULL);
-		_makepath(NewFile, drive, dir, fname, ".SUB");
-	}
-
-	DWORD size;
-	BYTE *buffer = _gameRef->m_FileManager->readWholeFile(NewFile, &Size, false);
-	if (Buffer == NULL) {
-		return STATUS_OK;    // no subtitles
-	}
-
-
-	LONG Start, End;
-	bool inToken;
-	char *tokenStart;
-	int tokenLength;
-	int tokenPos;
-	int textLength;
-
-	int pos = 0;
-	int lineLength = 0;
-	while (Pos < Size) {
-		start = End = -1;
-		inToken = false;
-		tokenPos = -1;
-		textLength = 0;
-
-		lineLength = 0;
-		while (Pos + LineLength < Size && Buffer[Pos + LineLength] != '\n' && Buffer[Pos + LineLength] != '\0') {
-			lineLength++;
-		}
-
-		int realLength = LineLength - (Pos + LineLength >= Size ? 0 : 1);
-		char *text = new char[RealLength + 1];
-		char *line = (char *)&Buffer[Pos];
-
-		for (int i = 0; i < RealLength; i++) {
-			if (line[i] == '{') {
-				if (!InToken) {
-					InToken = true;
-					TokenStart = line + i + 1;
-					TokenLength = 0;
-					TokenPos++;
-				} else {
-					TokenLength++;
-				}
-			} else if (line[i] == '}') {
-				if (InToken) {
-					InToken = false;
-					char *token = new char[TokenLength + 1];
-					strncpy(Token, TokenStart, TokenLength);
-					Token[TokenLength] = '\0';
-					if (TokenPos == 0) {
-						Start = atoi(Token);
-					} else if (TokenPos == 1) {
-						End = atoi(Token);
-					}
-
-					delete[] Token;
-				} else {
-					Text[TextLength] = line[i];
-					TextLength++;
-				}
-			} else {
-				if (InToken) {
-					TokenLength++;
-				} else {
-					Text[TextLength] = line[i];
-					if (Text[TextLength] == '|') {
-						Text[TextLength] = '\n';
-					}
-					TextLength++;
-				}
-			}
-		}
-		Text[TextLength] = '\0';
-
-		if (Start != -1 && TextLength > 0) {
-			_subtitles.add(new CVidSubtitle(_gameRef,  Text, Start, End));
-		}
-
-		delete[] Text;
-
-		Pos += LineLength + 1;
-	}
-
-	delete[] Buffer;
-#endif
+bool VideoPlayer::loadSubtitles(const char *filename, const char *subtitleFile) {
 	return STATUS_OK;
 }
 
diff --git a/engines/wintermute/video/video_player.h b/engines/wintermute/video/video_player.h
index 4c02506094..190223c6d1 100644
--- a/engines/wintermute/video/video_player.h
+++ b/engines/wintermute/video/video_player.h
@@ -38,6 +38,7 @@
 
 namespace WinterMute {
 
+// AVI-Video-player, currently fully stubbed
 class VideoPlayer : public BaseClass {
 public:
 	bool _showSubtitle;
diff --git a/engines/wintermute/video/video_theora_player.cpp b/engines/wintermute/video/video_theora_player.cpp
index ada645c972..c0a86ecd7e 100644
--- a/engines/wintermute/video/video_theora_player.cpp
+++ b/engines/wintermute/video/video_theora_player.cpp
@@ -84,9 +84,9 @@ void VideoTheoraPlayer::SetDefaults() {
 	_savedPos = 0;
 	_volume = 100;
 	_theoraDecoder = NULL;
-#if 0
-	_subtitler = NULL;
-#endif
+
+	// TODO: Add subtitles-support
+	//_subtitler = NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -154,7 +154,7 @@ bool VideoTheoraPlayer::initialize(const Common::String &filename, const Common:
 //////////////////////////////////////////////////////////////////////////
 bool VideoTheoraPlayer::resetStream() {
 	warning("VidTheoraPlayer::resetStream - stubbed");
-#if 0
+#if 0 // Stubbed for now, as theora isn't seekable
 	if (_sound) {
 		_sound->Stop();
 	}
@@ -227,7 +227,7 @@ bool VideoTheoraPlayer::play(TVideoPlayback type, int x, int y, bool freezeGame,
 		break;
 	}
 	return STATUS_OK;
-#if 0
+#if 0 // Stubbed for now as theora isn't seekable
 	if (StartTime) SeekToTime(StartTime);
 
 	Update();
@@ -299,83 +299,6 @@ bool VideoTheoraPlayer::update() {
 		}
 	}
 
-#if 0
-	m_CurrentTime = m_FreezeGame ? _gameRef->m_LiveTimer : _gameRef->m_Timer;
-
-	if (!IsPlaying()) return STATUS_OK;
-
-	if (m_PlaybackStarted && m_Sound && !m_Sound->IsPlaying()) return STATUS_OK;
-
-	if (m_PlaybackStarted && !m_FreezeGame && _gameRef->m_State == GAME_FROZEN) return STATUS_OK;
-
-	int counter = 0;
-	while (true) {
-		if (m_Sound) DecodeVorbis();
-		else m_AudioFrameReady = true;
-
-		if (m_Texture) DecodeTheora();
-		else m_VideoFrameReady = true;
-
-		if ((!m_Sound || !m_AudioFrameReady) && (!m_Texture || !m_VideoFrameReady) && m_File->IsEOF()) {
-			// end playback
-			if (!m_Looping) {
-				m_State = THEORA_STATE_FINISHED;
-				if (m_Sound) m_Sound->Stop();
-				if (m_FreezeGame) _gameRef->Unfreeze();
-				break;
-			} else {
-				ResetStream();
-				return STATUS_OK;
-			}
-		}
-
-
-		if (!m_VideoFrameReady || !m_AudioFrameReady) {
-			Counter++;
-			if (StreamInData() == 0) break;
-		} else break;
-	}
-
-
-	// If playback has begun, top audio buffer off immediately.
-	//if (m_Sound) WriteAudio();
-
-	// are we at or past time for this video frame?
-	if (m_PlaybackStarted && m_VideoFrameReady && (!m_FrameRendered || m_VideobufTime <= GetMovieTime())) {
-		//_gameRef->LOG(0, "%f %f", m_VideobufTime, GetMovieTime());
-		if (m_Texture) WriteVideo();
-		m_VideoFrameReady = false;
-
-		if (m_SavedState == THEORA_STATE_PAUSED) {
-			Pause();
-			m_SavedState = THEORA_STATE_NONE;
-		}
-	}
-
-	// if our buffers either don't exist or are ready to go,
-	// we can begin playback
-	bool startNow = false;
-	if ((!m_TheoraStreams || m_VideoFrameReady) &&
-	        (!m_VorbisStreams || m_AudioFrameReady)) StartNow = true;
-	// same if we've run out of input
-	if (m_File->IsEOF()) StartNow = true;
-
-
-	if (m_Sound) WriteAudio();
-
-
-	if (!m_PlaybackStarted && StartNow && !m_SeekingKeyframe) {
-		//m_StartTime = timeGetTime();
-		m_StartTime = m_CurrentTime;
-		if (m_Sound) {
-			m_Sound->SetPrivateVolume(m_Volume);
-			m_Sound->Play();
-		}
-		m_PlaybackStarted = true;
-	}
-
-	if (m_Subtitler && _gameRef->m_VideoSubtitles) m_Subtitler->update(GetMovieFrame());
-#endif
 	return STATUS_OK;
 }
 
@@ -442,11 +365,11 @@ bool VideoTheoraPlayer::display(uint32 alpha) {
 	} else {
 		res = STATUS_FAILED;
 	}
-#if 0
-	if (m_Subtitler && _gameRef->m_VideoSubtitles) {
+	// TODO: Add subtitles-support
+/*	if (m_Subtitler && _gameRef->m_VideoSubtitles) {
 		m_Subtitler->display();
-	}
-#endif
+	}*/
+
 	return res;
 }
 
@@ -494,64 +417,6 @@ inline int intlog(int num) {
 //////////////////////////////////////////////////////////////////////////
 bool VideoTheoraPlayer::seekToTime(uint32 time) {
 	warning("VideoTheoraPlayer::SeekToTime(%d) - not supported", time);
-#if 0
-	if (!m_TheoraStreams) return STATUS_FAILED;
-
-
-	float targetTime = Time / 1000.0f;
-
-
-	ogg_page page;
-	int read = 1;
-	ogg_int64_t gran;
-	float movieLength = 0;
-	DWORD LastPos = 0;
-
-	int keyframe_granule_shift = intlog(m_TheoraInfo.keyframe_frequency_force - 1);
-
-	while (!m_File->IsEOF() && read != 0) {
-		read = BufferData(&m_OggSyncState);
-
-		while (ogg_sync_pageout(&m_OggSyncState, &page) > 0) {
-			int serno = ogg_page_serialno(&page);
-			//This is theora stream we were searching for
-			if (m_TheoraStreamState.serialno == serno) {
-				//Calculate a rough time estimate
-				gran = ogg_page_granulepos(&page);
-				if (gran >= 0) {
-					ogg_int64_t iframe = gran >> keyframe_granule_shift;
-					ogg_int64_t pframe = gran   - (iframe << keyframe_granule_shift);
-					movieLength = (iframe + pframe) *
-					              ((double)m_TheoraInfo.fps_denominator / m_TheoraInfo.fps_numerator);
-
-					if (movieLength >= TargetTime) {
-						m_TimeOffset = movieLength;
-						//m_TimeOffset = TargetTime;
-						//m_File->Seek(LastPos);
-
-						goto finish;
-					}
-					LastPos = m_File->GetPos();
-				}
-			}
-		}
-	}
-
-finish:
-	ogg_sync_reset(&m_OggSyncState);
-
-	ogg_stream_reset(&m_TheoraStreamState);
-	ogg_stream_reset(&m_VorbisStreamState);
-
-	theora_clear(&m_TheoraState);
-	theora_decode_init(&m_TheoraState, &m_TheoraInfo);
-	vorbis_synthesis_restart(&m_VorbisDSPState);
-
-	m_SeekingKeyframe = true;
-
-	//theora_packet_iskeyframe
-
-#endif
 	return STATUS_OK;
 }