piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-23 06:09:50 -06:00
Code Issues Packages Projects Releases Wiki Activity

Common: Moved Windows console functions to common

Browse Source 
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1887 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
John Peterson
2009-01-17 14:28:09 +00:00
parent 7f9ce70b33
commit ae9cfbd8e3
70 changed files with 1337 additions and 2987 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Source/Core/Common/Common.vcproj
View File

@ -566,6 +566,14 @@
RelativePath=".\Src\Common.h"
>
</File>
<File
RelativePath=".\Src\ConsoleWindow.cpp"
>
</File>
<File
RelativePath=".\Src\ConsoleWindow.h"
>
</File>
<File
RelativePath=".\Src\CPUDetect.cpp"
>

3
Source/Core/Common/Src/Common.h
View File

@ -36,9 +36,6 @@
#define LOGGING
#endif
// Allow wxWidgets in Core
//#define WX_CORE
#include "../../../PluginSpecs/CommonTypes.h"
#define HAVE_WIIUSE 1
#define HAVE_WX 1

93
Source/Plugins/Plugin_Wiimote/Src/Console.h → Source/Core/Common/Src/ConsoleWindow.h
View File

@ -1,41 +1,52 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef WIIMOTE_CONSOLE_H
#define WIIMOTE_CONSOLE_H
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
#include <iostream>
//////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
std::string Tm(bool Ms = false);
void startConsoleWin(int width, int height, char* fname);
int wprintf(const char *fmt, ...);
int aprintf(int a, const char *fmt, ...);
void ClearScreen();
#ifdef _WIN32
HWND GetConsoleHwnd(void);
#endif
///////////////////////////////
#endif // WIIMOTE_CONSOLE_H
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef _CONSOLE_H
#define _CONSOLE_H
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
#include <iostream>
#ifdef _WIN32
#include <windows.h>
#endif
//////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations
// ¯¯¯¯¯¯¯¯¯¯¯¯¯
namespace Console
{
// Settings
extern bool WriteToFile;
// Functions
void Open(int Width = 80, int Height = 100, char * Name = "Console", bool File = false);
void Close();
int Print(const char *fmt, ...);
void ClearScreen();
#ifdef _WIN32
HWND GetHwnd(void);
#endif
} // Console
///////////////////////////////
#endif // _CONSOLE_H

3
Source/Core/Common/Src/DynamicLibrary.cpp
View File

@ -40,7 +40,6 @@ and stopped.
#include "FileUtil.h"
#include "StringUtil.h"
#include "DynamicLibrary.h"
#include "../../../../Branches/MusicMod/Common/Src/Console.h"
///////////////////////////////////
@ -157,7 +156,7 @@ void* DynamicLibrary::Get(const char* funcname) const
if (!retval)
{
LOG(MASTER_LOG, "Symbol %s missing in %s (error: %s)\n", funcname, library_file.c_str(), GetLastErrorAsString().c_str());
PanicAlert("Symbol %s missing in %s (error: %s)\n", funcname, library_file.c_str(), GetLastErrorAsString().c_str());
//PanicAlert("Symbol %s missing in %s (error: %s)\n", funcname, library_file.c_str(), GetLastErrorAsString().c_str());
}
return retval;

130
Source/Core/Core/Core.vcproj
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Version="9,00"
Name="Core"
ProjectGUID="{F0B874CB-4476-4199-9315-8343D05AE684}"
RootNamespace="Core"
@ -1000,6 +1000,70 @@
>
</File>
</Filter>
<Filter
Name="Boot"
>
<File
RelativePath=".\Src\Boot\Boot.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot.h"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_BIOSEmu.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_DOL.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_DOL.h"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_ELF.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_ELF.h"
>
</File>
<File
RelativePath=".\Src\Boot\ElfReader.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\ElfReader.h"
>
</File>
<File
RelativePath=".\Src\Boot\ElfTypes.h"
>
</File>
</Filter>
<Filter
Name="ActionReplay"
>
<File
RelativePath=".\Src\ActionReplay.cpp"
>
</File>
<File
RelativePath=".\Src\ActionReplay.h"
>
</File>
<File
RelativePath=".\Src\ARDecrypt.cpp"
>
</File>
<File
RelativePath=".\Src\ARDecrypt.h"
>
</File>
</Filter>
<Filter
Name="IPC HLE"
>
@ -1100,70 +1164,6 @@
>
</File>
</Filter>
<Filter
Name="Boot"
>
<File
RelativePath=".\Src\Boot\Boot.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot.h"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_BIOSEmu.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_DOL.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_DOL.h"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_ELF.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\Boot_ELF.h"
>
</File>
<File
RelativePath=".\Src\Boot\ElfReader.cpp"
>
</File>
<File
RelativePath=".\Src\Boot\ElfReader.h"
>
</File>
<File
RelativePath=".\Src\Boot\ElfTypes.h"
>
</File>
</Filter>
<Filter
Name="ActionReplay"
>
<File
RelativePath=".\Src\ActionReplay.cpp"
>
</File>
<File
RelativePath=".\Src\ActionReplay.h"
>
</File>
<File
RelativePath=".\Src\ARDecrypt.cpp"
>
</File>
<File
RelativePath=".\Src\ARDecrypt.h"
>
</File>
</Filter>
<File
RelativePath=".\Src\Console.cpp"
>

1
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -25,7 +25,6 @@
#include "../Core.h" // Local core functions
#include "../Debugger/Debugger_SymbolMap.h"
#include "../Host.h"
#include "../../../../Branches/MusicMod/Common/Src/Console.h"
///////////////////////

6
Source/Core/DolphinWX/DolphinWX.vcproj
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Version="9,00"
Name="DolphinWX"
ProjectGUID="{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}"
RootNamespace="DolphinWX"
@ -30,7 +30,7 @@
<Tool
Name="VCPreBuildEventTool"
CommandLine="&quot;$(ProjectDir)..\Common\SubWCRev.exe&quot; &quot;$(SolutionDir)\.&quot; &quot;$(ProjectDir)..\Common\src\svnrev_template.h&quot; &quot;$(ProjectDir)..\Common\src\svnrev.h&quot;"
ExcludedFromBuild="false"
ExcludedFromBuild="true"
/>
<Tool
Name="VCCustomBuildTool"
@ -131,7 +131,7 @@
Name="VCPostBuildEventTool"
Description="Copying Data\* to $(TargetDir)"
CommandLine="xcopy &quot;$(SolutionDir)..\Data&quot; &quot;$(TargetDir)&quot; /s /e /q /d&#x0D;&#x0A;echo Copying External .dlls&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\Cg\*.dll&quot; &quot;$(TargetDir)&quot; /s /e /q /d&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\SDL\win32\*.dll&quot; &quot;$(TargetDir)&quot; /s /e /q /d&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\WiiUse\Win32\*.dll&quot; &quot;$(TargetDir)&quot; /s /e /q /d&#x0D;&#x0A;"
ExcludedFromBuild="false"
ExcludedFromBuild="true"
/>
</Configuration>
<Configuration

2
Source/Core/DolphinWX/Src/BootManager.cpp
View File

@ -55,7 +55,7 @@
#include "ConfigMain.h"
#include "Frame.h"
#include "CodeWindow.h"
#include "../../../../Branches/MusicMod/Common/Src/Console.h"
#include "../../../Branches/MusicMod/Main/Src/Setup.h"
#ifdef MUSICMOD
#include "../../../Branches/MusicMod/Main/Src/Main.h" // MusicMod
#endif

26
Source/MusicMod.sln
View File

@ -6,7 +6,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Core", "Core\Core\Core.vcpr
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA} = {C7E5D50A-2916-464B-86A7-E10B3CC88ADA}
{0318BA30-EF48-441A-9E10-DC85EFAE39F0} = {0318BA30-EF48-441A-9E10-DC85EFAE39F0}
{71B16F46-0B00-4EDA-B253-D6D9D03A215C} = {71B16F46-0B00-4EDA-B253-D6D9D03A215C}
{DE7C596C-CBC4-4278-8909-146D63990803} = {DE7C596C-CBC4-4278-8909-146D63990803}
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510} = {29C2ABC1-ADA5-42CD-A5FC-96022D52A510}
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C} = {B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}
@ -55,19 +54,16 @@ EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DolphinWX", "Core\DolphinWX\DolphinWX.vcproj", "{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}"
ProjectSection(ProjectDependencies) = postProject
{48AD7E0A-25B1-4974-A1E3-03F8C438D34F} = {48AD7E0A-25B1-4974-A1E3-03F8C438D34F}
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160} = {CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}
{0318BA30-EF48-441A-9E10-DC85EFAE39F0} = {0318BA30-EF48-441A-9E10-DC85EFAE39F0}
{8D612734-FAA5-4B8A-804F-4DEA2367D495} = {8D612734-FAA5-4B8A-804F-4DEA2367D495}
{71B16F46-0B00-4EDA-B253-D6D9D03A215C} = {71B16F46-0B00-4EDA-B253-D6D9D03A215C}
{33546D62-7F34-4EA6-A88E-D538B36E16BF} = {33546D62-7F34-4EA6-A88E-D538B36E16BF}
{DE7C596C-CBC4-4278-8909-146D63990803} = {DE7C596C-CBC4-4278-8909-146D63990803}
{3E03C179-8251-46E4-81F4-466F114BAC63} = {3E03C179-8251-46E4-81F4-466F114BAC63}
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF} = {95CCAABC-7062-47C4-B8C1-A064DD5F16FF}
{521498BE-6089-4780-8223-E67C22F4E068} = {521498BE-6089-4780-8223-E67C22F4E068}
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510} = {29C2ABC1-ADA5-42CD-A5FC-96022D52A510}
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77} = {4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}
{F0B874CB-4476-4199-9315-8343D05AE684} = {F0B874CB-4476-4199-9315-8343D05AE684}
{0B72B5D6-5D72-4391-84A7-9CCA5392668A} = {0B72B5D6-5D72-4391-84A7-9CCA5392668A}
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C} = {B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}
EndProjectSection
EndProject
@ -139,7 +135,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Externals", "Externals", "{
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Player", "..\Branches\MusicMod\Player\Player.vcproj", "{0B72B5D6-5D72-4391-84A7-9CCA5392668A}"
ProjectSection(ProjectDependencies) = postProject
{DE7C596C-CBC4-4278-8909-146D63990803} = {DE7C596C-CBC4-4278-8909-146D63990803}
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
EndProjectSection
EndProject
@ -155,7 +150,6 @@ EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Main", "..\Branches\MusicMod\Main\Main.vcproj", "{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}"
ProjectSection(ProjectDependencies) = postProject
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160} = {CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}
{DE7C596C-CBC4-4278-8909-146D63990803} = {DE7C596C-CBC4-4278-8909-146D63990803}
{0B72B5D6-5D72-4391-84A7-9CCA5392668A} = {0B72B5D6-5D72-4391-84A7-9CCA5392668A}
EndProjectSection
EndProject
@ -239,8 +233,10 @@ Global
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Debug|Win32.ActiveCfg = Debug|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Debug|x64.ActiveCfg = Debug|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|Win32.Build.0 = DebugFast|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|x64.ActiveCfg = DebugFast|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|Win32.ActiveCfg = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|Win32.Build.0 = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|x64.ActiveCfg = Release|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|x64.Build.0 = Release|x64
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Debug|Win32.ActiveCfg = Debug|Win32
@ -322,7 +318,6 @@ Global
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Debug|Win32.ActiveCfg = Debug|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Debug|x64.ActiveCfg = Debug|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|Win32.Build.0 = DebugFast|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|x64.ActiveCfg = DebugFast|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release|Win32.ActiveCfg = Release|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release|Win32.Build.0 = Release|Win32
@ -359,15 +354,14 @@ Global
{521498BE-6089-4780-8223-E67C22F4E068}.DebugFast|x64.ActiveCfg = DebugFast|x64
{521498BE-6089-4780-8223-E67C22F4E068}.DebugFast|x64.Build.0 = DebugFast|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Release|Win32.ActiveCfg = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release|Win32.Build.0 = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release|x64.ActiveCfg = Release|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Release|x64.Build.0 = Release|x64
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.Debug|Win32.ActiveCfg = Debug|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.Debug|Win32.Build.0 = Debug|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.Debug|x64.ActiveCfg = Debug|x64
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.Debug|x64.Build.0 = Debug|x64
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|Win32.ActiveCfg = Debug|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|Win32.Build.0 = Debug|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|Win32.Build.0 = DebugFast|Win32
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|x64.ActiveCfg = Debug|x64
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.DebugFast|x64.Build.0 = Debug|x64
{0B72B5D6-5D72-4391-84A7-9CCA5392668A}.Release|Win32.ActiveCfg = Release|Win32
@ -378,7 +372,7 @@ Global
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.Debug|Win32.Build.0 = Debug|Win32
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.Debug|x64.ActiveCfg = Debug|x64
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.Debug|x64.Build.0 = Debug|x64
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.DebugFast|Win32.ActiveCfg = Debug|Win32
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.DebugFast|x64.ActiveCfg = Debug|x64
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.DebugFast|x64.Build.0 = Debug|x64
{0D14F1E9-490B-4A2D-A4EF-0535E8B3C718}.Release|Win32.ActiveCfg = Release|Win32
@ -387,8 +381,8 @@ Global
{DE7C596C-CBC4-4278-8909-146D63990803}.Debug|Win32.ActiveCfg = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.Debug|Win32.Build.0 = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.Debug|x64.ActiveCfg = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.DebugFast|Win32.ActiveCfg = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.DebugFast|Win32.Build.0 = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.DebugFast|Win32.Build.0 = DebugFast|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.DebugFast|x64.ActiveCfg = Debug|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.Release|Win32.ActiveCfg = Release|Win32
{DE7C596C-CBC4-4278-8909-146D63990803}.Release|Win32.Build.0 = Release|Win32
@ -397,8 +391,8 @@ Global
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.Debug|Win32.ActiveCfg = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.Debug|Win32.Build.0 = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.Debug|x64.ActiveCfg = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.DebugFast|Win32.ActiveCfg = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.DebugFast|Win32.Build.0 = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.DebugFast|Win32.ActiveCfg = DebugFast|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.DebugFast|Win32.Build.0 = DebugFast|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.DebugFast|x64.ActiveCfg = Debug|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.Release|Win32.ActiveCfg = Release|Win32
{95CCAABC-7062-47C4-B8C1-A064DD5F16FF}.Release|Win32.Build.0 = Release|Win32

6
Source/Plugins/Plugin_DSP_HLE/Plugin_DSP_HLE.vcproj
View File

@ -742,15 +742,15 @@
Name="Logging"
>
<File
RelativePath=".\Src\Logging\Console.cpp"
RelativePath=".\Src\Debugger\File.cpp"
>
</File>
<File
RelativePath=".\Src\Logging\Console.h"
RelativePath=".\Src\Debugger\File.h"
>
</File>
<File
RelativePath=".\Src\Logging\Logging.cpp"
RelativePath=".\Src\Debugger\Logging.cpp"
>
</File>
</Filter>

12
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Blocks.cpp
View File

@ -19,7 +19,10 @@
//
//////////////////////////////////////////////////////////////////////////////////////////
// includes
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include <iostream>
#include <fstream>
#include <sstream>
@ -28,13 +31,16 @@
#include <stdlib.h>
#endif
#include "ConsoleWindow.h" // Open and close console
#include "Debugger.h"
#include "PBView.h"
#include "IniFile.h"
#include "FileUtil.h"
#include "StringUtil.h"
#include "FileSearch.h"
#include "../Logging/Console.h" // open and close console
//#include "../Logging/File.h" // Write to file
///////////////////////////////
// Make the wxTextCtrls scroll with each other
@ -55,7 +61,7 @@ void CDebugger::DoScrollBlocks()
else if(GetAsyncKeyState(VK_NUMPAD2))
A += 0.11;
wprintf("GetScrollPos:%i GetScrollRange:%i GetPosition:%i GetLastPosition:%i GetMaxWidth:%i \
Console::Print("GetScrollPos:%i GetScrollRange:%i GetPosition:%i GetLastPosition:%i GetMaxWidth:%i \
GetLineLength:%i XYToPosition:%i\n \
GetScrollPos * GetLineLength + GetScrollRange:%i A:%f\n",
m_bl95->GetScrollPos(wxVERTICAL), m_bl95->GetScrollRange(wxVERTICAL),

105
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Debugger.cpp
View File

@ -19,26 +19,31 @@
//
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
// includes
#include <iostream>
#include <iostream> // System
#include <fstream>
#include <sstream>
#ifndef _WIN32
#include <stdlib.h>
#include <stdlib.h>
#endif
#include "ConsoleWindow.h" // Open and close console
#include "Debugger.h"
#include "PBView.h"
#include "IniFile.h"
#include "FileUtil.h"
#include "StringUtil.h"
#include "FileSearch.h"
#include "../Logging/Console.h" // open and close console
#include "../Debugger/File.h" // Write to file
//////////////////////////////
// =======================================================================================
// Declare events
// Event table and class
BEGIN_EVENT_TABLE(CDebugger,wxDialog)
EVT_CLOSE(CDebugger::OnClose) // on close event
@ -69,8 +74,6 @@ BEGIN_EVENT_TABLE(CDebugger,wxDialog)
//EVT_SCROLL(CDebugger::ScrollBlocks)
//EVT_SCROLLWIN(CDebugger::ScrollBlocks)
END_EVENT_TABLE()
// =======================================================================================
CDebugger::CDebugger(wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &position, const wxSize& size, long style)
@ -147,7 +150,50 @@ CDebugger::~CDebugger()
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
}
// ====================
// ========================================================================
// System functions
// --------------
void CDebugger::OnClose(wxCloseEvent& /*event*/)
{
// Save the window position when we hide the window to
IniFile file;
file.Load(DEBUGGER_CONFIG_FILE);
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
EndModal(0);
#ifdef _WIN32
Console::Close(); // Take the console window with it
#endif
}
void CDebugger::DoHide()
{
Hide();
#ifdef _WIN32
Console::Close(); // The console goes with the wx window
#endif
}
void CDebugger::DoShow()
{
Show();
DoShowHideConsole(); // The console goes with the wx window
}
void CDebugger::OnUpdate(wxCommandEvent& /*event*/)
{
this->NotifyUpdate();
}
// ===============
// ==========================================================================
// Save and load settings
// --------------
void CDebugger::Save(IniFile& _IniFile) const
{
// TODO2: get the screen resolution and make limits from that
@ -197,7 +243,12 @@ void CDebugger::Load(IniFile& _IniFile)
_IniFile.Get("SoundWindow", "StoreMails", &StoreMails, m_gcwiiset->IsChecked(1));
m_gcwiiset->Check(1, StoreMails);
}
// ===================
//////////////////////////////////////////////////////////////////////////////////////////
// Create GUI controls
// -------------
void CDebugger::CreateGUIControls()
{
SetTitle(wxT("Sound Debugging"));
@ -517,39 +568,7 @@ SetTitle(wxT("Sound Debugging"));
NotifyUpdate();
// --------------------------------------------------------------------
}
// ========================================================================
// System functions
// --------------
void CDebugger::OnClose(wxCloseEvent& /*event*/)
{
// save the window position when we hide the window to
IniFile file;
file.Load(DEBUGGER_CONFIG_FILE);
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
EndModal(0);
CloseConsole(); // Take the console window with it
}
void CDebugger::DoHide()
{
Hide();
CloseConsole(); // The console goes with the wx window
}
void CDebugger::DoShow()
{
Show();
DoShowHideConsole(); // The console goes with the wx window
}
void CDebugger::OnUpdate(wxCommandEvent& /*event*/)
{
this->NotifyUpdate();
}
// ===============
/////////////////////////////
// =======================================================================================
@ -663,11 +682,13 @@ void CDebugger::ShowHideConsole(wxCommandEvent& event)
}
void CDebugger::DoShowHideConsole()
{
{
#ifdef _WIN32
if(m_options->IsChecked(3))
OpenConsole();
else
CloseConsole();
#endif
}
// ==============

117
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/File.cpp Normal file
View File

@ -0,0 +1,117 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
// --------------------
// Includes
#include <string>
#include <stdio.h>
#include "Common.h"
#ifdef _WIN32
#include <windows.h>
#endif
#if defined(HAVE_WX) && HAVE_WX
#include "../Debugger/Debugger.h"
#include "../Debugger/File.h"
extern CDebugger* m_frame;
#endif
// --------------------
// On and off
bool g_consoleEnable = true;
//int gSaveFile = 0;
#define DEBUG_HLE
// --------------------
// Create file handles
#ifdef DEBUG_HLE
FILE* __fStdOut[nFiles];
#endif
// =======================================================================================
/* Open file handles */
// -------------
void StartFile(int width, int height, char* fname)
{
#if defined(DEBUG_HLE) && defined(_WIN32)
if(fname)
{
for(int i = 0; i < nFiles; i++)
{
// Edit the log file name
std::string FileEnding = ".log";
std::string FileName = fname;
char buffer[33]; _itoa(i, buffer, 10); // convert number to string
std::string FullFilename = (FileName + buffer + FileEnding);
__fStdOut[i] = fopen(FullFilename.c_str(), "w");
}
}
#endif
}
// ======================
//////////////////////////////////////////////////////////////////////////////////////////
/* Close the file handles */
// -------------
void CloseFile()
{
// Close the file handles
for(int i = 0; i < nFiles; i++)
{
if(__fStdOut[i]) fclose(__fStdOut[i]);
}
}
//////////////////////////////
// ---------------------------------------------------------------------------------------
// File printf function
// -------------
int PrintFile(int a, char *fmt, ...)
{
#if defined(DEBUG_HLE) && defined(_WIN32)
if(m_frame->gSaveFile)
{
char s[StringSize];
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, StringSize, fmt, argptr);
va_end(argptr);
// ---------------------------------------------------------------------------------------
if(__fStdOut[a]) // TODO: make this work, we have to set all default values to NULL
// to make it work
fprintf(__fStdOut[a], s);
// -------------
return(cnt);
}
else
{
return 0;
}
#else
return 0;
#endif
}

35
Source/Plugins/Plugin_DSP_HLE/Src/Debugger/Mails.cpp
View File

@ -19,7 +19,10 @@
//
//////////////////////////////////////////////////////////////////////////////////////////
// includes
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include <iostream>
#include <fstream>
#include <sstream>
@ -28,23 +31,31 @@
#include <stdlib.h>
#endif
//#include "ConsoleWindow.h" // Open and close console
#include "Debugger.h"
#include "PBView.h"
#include "IniFile.h"
#include "FileUtil.h"
#include "StringUtil.h"
#include "FileSearch.h"
#include "../Logging/Console.h" // open and close console
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
extern std::vector<std::string> sMailLog, sMailTime;
extern CDebugger* m_frame;
///////////////////////////////
// =======================================================================================
// Update mail window
// --------------
void CDebugger::DoUpdateMail()
{
//wprintf("i %i %i\n", sFullMail.size(), sMailLog.size());
//Console::Print("i %i %i\n", sFullMail.size(), sMailLog.size());
if(sFullMail.size() > 0 && sMailLog.size() > 0)
{
@ -69,7 +80,7 @@ void CDebugger::UpdateMail(wxNotebookEvent& event)
// Change mail from radio button change
void CDebugger::ChangeMail(wxCommandEvent& event)
{
//wprintf("abc");
//Console::Print("abc");
DoUpdateMail();
//if(StoreMails) ReadDir();
}
@ -120,7 +131,7 @@ void CDebugger::ReadDir()
else
cut = pieces[0];
//wprintf("%s %s %s\n", pieces[0].c_str(), pieces[1].c_str(),
//Console::Print("%s %s %s\n", pieces[0].c_str(), pieces[1].c_str(),
// pieces[2].c_str(), pieces[3].c_str());
if (NoDuplicate(pieces[0]) && pieces.size() >= 3)
@ -163,11 +174,11 @@ u32 CDebugger::CountFiles(std::string FileName)
for (u32 i = 0; i < all_all_files.size(); i++)
{
//wprintf("CountFiles %i %s\n", i, all_all_files[i].c_str());
//Console::Print("CountFiles %i %s\n", i, all_all_files[i].c_str());
if(all_all_files[i] == FileName)
match++;
}
//wprintf("We found %i files for this game\n", match);
//Console::Print("We found %i files for this game\n", match);
return match;
}
// ==============
@ -219,13 +230,13 @@ void CDebugger::Readfile(std::string FileName, bool GC)
if(m_RadioBox[3]->IsItemEnabled(i)) curr_n++;
m_RadioBox[3]->Enable(i, false); // disable all
}
//wprintf("Disabled all: n %i\n", n);
//Console::Print("Disabled all: n %i\n", n);
for (u32 i = 0; i < n; i++)
{
m_RadioBox[3]->Enable(i, true); // then anble the right ones
//wprintf("m_RadioBox[3] enabled: %i\n", i);
//Console::Print("m_RadioBox[3] enabled: %i\n", i);
std::string sz = "";
std::ostringstream ci;
@ -233,7 +244,7 @@ void CDebugger::Readfile(std::string FileName, bool GC)
std::string f0 = FULL_MAIL_LOGS_DIR + FileName + "_sep" + ci.str() + "_sep" + "0_sep" + (GC ? "GC" : "Wii") + "_sep.log";
std::string f1 = FULL_MAIL_LOGS_DIR + FileName + "_sep" + ci.str() + "_sep" + "1_sep" + (GC ? "GC" : "Wii") + "_sep.log";
//wprintf("ifstream %s %s\n", f0.c_str(), f1.c_str());
//Console::Print("ifstream %s %s\n", f0.c_str(), f1.c_str());
if(sFullMail.size() <= i) sFullMail.resize(sFullMail.size() + 1);
if(sMailLog.size() <= i) sMailLog.resize(sMailLog.size() + 1);
@ -244,7 +255,7 @@ void CDebugger::Readfile(std::string FileName, bool GC)
else sMailLog.at(i) = "";
}
if(n < curr_n) m_RadioBox[3]->Select(n - 1);
//wprintf("Select: %i | n %i curr_n %i\n", n - 1, n, curr_n);
//Console::Print("Select: %i | n %i curr_n %i\n", n - 1, n, curr_n);
DoUpdateMail();
}
// ==============
@ -278,7 +289,7 @@ void CDebugger::OnGameChange(wxCommandEvent& event)
void CDebugger::MailSettings(wxCommandEvent& event)
{
//for (int i = 0; i < all_all_files.size(); ++i)
//wprintf("s: %s \n", all_all_files.at(i).c_str());
//Console::Print("s: %s \n", all_all_files.at(i).c_str());
ScanMails = m_gcwiiset->IsChecked(0);
StoreMails = m_gcwiiset->IsChecked(1);

230
Source/Plugins/Plugin_DSP_HLE/Src/Logging/Console.cpp
View File

@ -1,230 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
// --------------------
// Includes
#include <string>
#include <stdio.h>
#include "Common.h"
#ifdef _WIN32
#include <windows.h>
#endif
#if defined(HAVE_WX) && HAVE_WX
#include "../Debugger/Debugger.h"
extern CDebugger* m_frame;
#endif
// --------------------
// On and off
bool g_consoleEnable = true;
//int gSaveFile = 0;
#define DEBUG_HLE
// --------------------
// Settings
int nFiles = 4;
// --------------------
// Create handles
#ifdef DEBUG_HLE
FILE* __fStdOut[4]; // you have to update this manually, we can't place a nFiles in there
#endif
#ifdef _WIN32
HANDLE __hStdOut = NULL;
#endif
// =======================================================================================
/* Start console window - width and height is the size of console window, if you specify
fname, the output will also be written to this file. TODO: Close the file pointer when the app
is closed */
// -------------
void startConsoleWin(int width, int height, char* fname)
{
#if defined(DEBUG_HLE) && defined(_WIN32)
AllocConsole();
SetConsoleTitle(fname);
__hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD co = {width,height};
SetConsoleScreenBufferSize(__hStdOut, co);
SMALL_RECT coo = {0,0,(width - 1),70}; // top, left, right, bottom
SetConsoleWindowInfo(__hStdOut, TRUE, &coo);
// ---------------------------------------------------------------------------------------
// Write to a file
if(fname)
{
for(int i = 0; i < nFiles; i++)
{
// Edit the log file name
std::string FileEnding = ".log";
std::string FileName = fname;
char buffer[33]; _itoa(i, buffer, 10); // convert number to string
std::string FullFilename = (FileName + buffer + FileEnding);
__fStdOut[i] = fopen(FullFilename.c_str(), "w");
}
}
// ---------------
#endif
}
// ---------------------------------------------------------------------------------------
// File printf function
int aprintf(int a, char *fmt, ...)
{
#if defined(DEBUG_HLE) && defined(_WIN32)
if(m_frame->gSaveFile)
{
char s[5000]; // WARNING: mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 5000, fmt, argptr); // remember to update this value to
va_end(argptr);
// ---------------------------------------------------------------------------------------
if(__fStdOut[a]) // TODO: make this work, we have to set all default values to NULL
//to make it work
fprintf(__fStdOut[a], s);
// -------------
return(cnt);
}
else
{
return 0;
}
#else
return 0;
#endif
}
// ---------------------------------------------------------------------------------------
// Printf to screen function
int wprintf(const char *fmt, ...)
{
#if defined(DEBUG_HLE) && defined(_WIN32)
char s[1024*20]; // Warning, mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 1024*20, fmt, argptr);
va_end(argptr);
DWORD cCharsWritten;
// ---------------------------------------------------------------------------------------
if(__hStdOut)
{
WriteConsole(__hStdOut, s, strlen(s), &cCharsWritten, NULL);
}
// -------------
return(cnt);
#else
return 0;
#endif
}
// ---------------------------------------------------------------------------------------
// Clear console screen
void ClearScreen()
{
#if defined(DEBUG_HLE) && defined(_WIN32)
if(g_consoleEnable)
{
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize,
coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize,
coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
}
#endif
}
// ---------------------------------------------------------------------------------------
// Get window handle of console window to be able to resize it
#if defined(DEBUG_HLE) && defined(_WIN32)
HWND GetConsoleHwnd(void)
{
#define MY_BUFSIZE 1024 // Buffer size for console window titles.
HWND hwndFound; // This is what is returned to the caller.
char pszNewWindowTitle[MY_BUFSIZE]; // Contains fabricated
// WindowTitle.
char pszOldWindowTitle[MY_BUFSIZE]; // Contains original
// WindowTitle.
// Fetch current window title.
GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);
// Format a "unique" NewWindowTitle.
wsprintf(pszNewWindowTitle,"%d/%d",
GetTickCount(),
GetCurrentProcessId());
// Change current window title.
SetConsoleTitle(pszNewWindowTitle);
// Ensure window title has been updated.
Sleep(40);
// Look for NewWindowTitle.
hwndFound = FindWindow(NULL, pszNewWindowTitle);
// Restore original window title.
SetConsoleTitle(pszOldWindowTitle);
return(hwndFound);
}
#endif // win32

28
Source/Plugins/Plugin_DSP_HLE/Src/Logging/Console.h
View File

@ -1,28 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
void startConsoleWin(int width, int height, char* fname);
int wprintf(const char *fmt, ...);
int aprintf(int a, char *fmt, ...);
void ClearScreen();
void OpenConsole();
void CloseConsole();
#ifdef _WIN32
HWND GetConsoleHwnd(void);
#endif

943
Source/Plugins/Plugin_DSP_HLE/Src/Logging/Logging.cpp
View File

@ -1,943 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
//
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
//
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
#include <iostream>
#include <vector>
#include <string> // so that we can test std::string == abc
#include <math.h> // for the pow() function
#ifdef _WIN32
#include <windows.h>
#endif
#include "StringUtil.h"
#include "../Debugger/Debugger.h"
#include "../Debugger/PBView.h"
#include "Console.h" // open and close console, clear console window
#include "../Globals.h"
#include "../UCodes/UCodes.h"
#include "../UCodes/UCode_AXStructs.h"
#include "../UCodes/UCode_AX.h"
#include "../UCodes/UCode_AXWii.h"
#include "../UCodes/UCode_AX_Voice.h"
// Externals
extern int nFiles;
extern CDebugger* m_frame;
//int PBSize = 128;
// Parameter blocks
std::vector<int> mem(NUMBER_OF_PBS); // mem1 or mem2
std::vector<u32> gloopPos(NUMBER_OF_PBS);
std::vector<u32> gsampleEnd(NUMBER_OF_PBS);
std::vector<u32> gsamplePos(NUMBER_OF_PBS);
// main
std::vector<u16> running(NUMBER_OF_PBS, 0);
std::vector<u16> gsrc_type(NUMBER_OF_PBS);
std::vector<u16> gis_stream(NUMBER_OF_PBS);
// PBSampleRateConverter src
std::vector<u32> gratio(NUMBER_OF_PBS);
std::vector<u32> gratiohi(NUMBER_OF_PBS);
std::vector<u32> gratiolo(NUMBER_OF_PBS);
std::vector<u32> gfrac(NUMBER_OF_PBS);
std::vector<u32> gcoef(NUMBER_OF_PBS);
// PBSampleRateConverter mixer
std::vector<u16> gvolume_left(NUMBER_OF_PBS);
std::vector<u16> gmix_unknown(NUMBER_OF_PBS);
std::vector<u16> gvolume_right(NUMBER_OF_PBS);
std::vector<u16> gmix_unknown2(NUMBER_OF_PBS);
std::vector<u16> gmixer_control(NUMBER_OF_PBS);
std::vector<u32> gmixer_control_wii(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol1(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol2(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol3(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol4(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol5(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol6(NUMBER_OF_PBS);
std::vector<u16> gmixer_vol7(NUMBER_OF_PBS);
std::vector<u16> gmixer_d1(NUMBER_OF_PBS);
std::vector<u16> gmixer_d2(NUMBER_OF_PBS);
std::vector<u16> gmixer_d3(NUMBER_OF_PBS);
std::vector<u16> gmixer_d4(NUMBER_OF_PBS);
std::vector<u16> gmixer_d5(NUMBER_OF_PBS);
std::vector<u16> gmixer_d6(NUMBER_OF_PBS);
std::vector<u16> gmixer_d7(NUMBER_OF_PBS);
// PBVolumeEnvelope vol_env
std::vector<u16> gcur_volume(NUMBER_OF_PBS);
std::vector<u16> gcur_volume_delta(NUMBER_OF_PBS);
// PBAudioAddr audio_addr (incl looping)
std::vector<u16> gaudioFormat(NUMBER_OF_PBS);
std::vector<u16> glooping(NUMBER_OF_PBS);
std::vector<u16> gloop1(NUMBER_OF_PBS);
std::vector<u16> gloop2(NUMBER_OF_PBS);
std::vector<u16> gloop3(NUMBER_OF_PBS);
// PBADPCMInfo adpcm
std::vector<u16> gadloop1(NUMBER_OF_PBS);
std::vector<u16> gadloop2(NUMBER_OF_PBS);
std::vector<u16> gadloop3(NUMBER_OF_PBS);
// updates
std::vector<u16> gupdates1(NUMBER_OF_PBS);
std::vector<u16> gupdates2(NUMBER_OF_PBS);
std::vector<u16> gupdates3(NUMBER_OF_PBS);
std::vector<u16> gupdates4(NUMBER_OF_PBS);
std::vector<u16> gupdates5(NUMBER_OF_PBS);
std::vector<u32> gupdates_addr(NUMBER_OF_PBS);
std::vector<u32> gupdates_data(NUMBER_OF_PBS);
std::vector<u32> gupdates_data1(NUMBER_OF_PBS);
std::vector<u32> gupdates_data2(NUMBER_OF_PBS);
std::vector<u32> gupdates_data3(NUMBER_OF_PBS);
std::vector<u32> gupdates_data4(NUMBER_OF_PBS);
// Counters
int count1 = 0;
int count2 = 0;
int iupd = 0;
bool iupdonce = false;
std::vector<u16> viupd(15); // the length of the update frequency bar
int vectorLengthGUI = 8; // length of playback history bar for the GUI version
int vectorLength = 15; // for console version
int vectorLength2 = 100; // for console version, how long to show
// More stuff
// should we worry about the additonal memory these lists require? bool will allocate
// very little memory
std::vector< std::vector<bool> > vector1(NUMBER_OF_PBS, std::vector<bool>(vectorLength, false));
std::vector< std::vector<bool> > vector2(NUMBER_OF_PBS, std::vector<bool>(vectorLength2, false));
std::vector<int> numberRunning(NUMBER_OF_PBS);
// Classes
extern CDebugger* m_frame;
// =======================================================================================
// Write title
// --------------
std::string writeTitle(int a, bool Wii)
{
std::string b;
if(a == 0)
{
if(m_frame->bShowBase) // show base 10
{
b = " adpcm adpcm_loop\n";
b = b + " Nr m pos / end lpos | voll volr | isl iss | pre yn1 yn2 pre yn1 yn2 | frac ratio[hi lo]\n";
}
else
{
b = " adpcm adpcm_loop\n";
b = b + " Nr pos / end lpos | voll volr | isl iss | pre yn1 yn2 pre yn1 yn2 | frac rati[hi lo ]\n";
}
}
else if(a == 1)
{
if(m_frame->bShowBase) // show base 10
{
b = " Nr pos / end lpos | voll volr | src form coef | 1 2 3 4 5 addr value\n";
}
else
{
b = " Nr pos / end lpos | voll volr | src form coef | 1 2 3 4 5 addr value\n";
}
}
else if(a == 2)
{
if(m_frame->bShowBase) // show base 10
{
b = " Nr pos / end lpos | voll volr | isl iss | e-l e-s\n";
}
else
{
b = " Nr pos / end lpos | voll volr | isl iss | e-l e-s\n";
}
}
else if(a == 3)
{
if(m_frame->bShowBase) // show base 10
{
if(Wii)
b = " Nr voll volr dl dr curv delt mixc r | v1 v2 v3 v4 v5 v6 v7 | d1 d2 d3 d4 d5 d6 d7\n";
else
b = " Nr voll volr dl dr curv delt mixc r | v1 v2 v3 v4 v5 v6 v7 | d1 d2 d3 d4 d5 d6 d7\n";
}
else
{
if(Wii)
b = " Nr voll volr dl dr curv delt mixc r | v1 v2 v3 v4 v5 v6 v7 | d1 d2 d3 d4 d5 d6 d7\n";
else
b = " Nr voll volr dl dr curv delt mixc r | v1 v2 v3 v4 v5 v6 v7 | d1 d2 d3 d4 d5 d6 d7\n";
}
}
return b;
}
// =======================================================================================
// =======================================================================================
// Write main message (presets)
// --------------
std::string writeMessage(int a, int i, bool Wii)
{
char buf [1000] = "";
std::string sbuf;
// =======================================================================================
// PRESETS
// ---------------------------------------------------------------------------------------
/*
PRESET 0
" Nr m pos / end lpos | voll volr | isl iss | pre yn1 yn2 pre yn1 yn2 | frac ratio[hi lo]\n";
"---------------|00 1 12,341,234/134,123,412 12341234 | 00,000 00,000 | 0 0 | 000 00000 00000 000 00000 00000 | 00000 00000[0 00000]
" Nr pos / end lpos | voll volr | isl iss | pre yn1 yn2 pre yn1 yn2 | frac rati[hi lo ]\n";
"---------------|00 12,341,234/134,123,412 12341234 | 00,000 00,000 | 0 0 | 000 0000 0000 000 0000 0000 | 0000 0000[0 00000]
PRESET 1 (updates)
" Nr pos / end lpos | voll volr | src form coef | 1 2 3 4 5 addr value\n";
"---------------|00 12,341,234/12,341,234 12341234 | 00,000 00,000 | 0 0 0 | 0 0 0 0 0 80808080 80808080
PRESET 2
" Nr pos / end lpos | voll volr | isl iss | e-l e-s\n";
"---------------|00 12,341,234/12341234 12,341,234 | 00000 00000 | 0 0 | 00,000,000 00,000,000
*/
if(a == 0)
{
if(m_frame->bShowBase) // base 10 (decimal)
{
if(Wii) // Wii
{
sprintf(buf,"%c%02i %i %10s/%10s %10s | %6s %6s | %i %i | %03i %05i %05i %03i %05i %05i | %05i %05i[%i %05i]",
223, i, mem[i], ThS(gsamplePos[i],true).c_str(), ThS(gsampleEnd[i],true).c_str(), ThS(gloopPos[i],true).c_str(),
ThS(gvolume_left[i]).c_str(), ThS(gvolume_right[i]).c_str(),
glooping[i], gis_stream[i],
gadloop1[i], gadloop2[i], gadloop3[i], gloop1[i], gloop2[i], gloop3[i],
gfrac[i], gratio[i], gratiohi[i], gratiolo[i]
);
}
else // GC
{
sprintf(buf,"%c%02i %10s/%10s %10s | %6s %6s | %i %i | %03i %05i %05i %03i %05i %05i | %05i %05i[%i %05i]",
223, i, ThS(gsamplePos[i],true).c_str(), ThS(gsampleEnd[i],true).c_str(), ThS(gloopPos[i],true).c_str(),
ThS(gvolume_left[i]).c_str(), ThS(gvolume_right[i]).c_str(),
glooping[i], gis_stream[i],
gadloop1[i], gadloop2[i], gadloop3[i], gloop1[i], gloop2[i], gloop3[i],
gfrac[i], gratio[i], gratiohi[i], gratiolo[i]
);
}
}
else
{
sprintf(buf,"%c%02i %08x/%08x %08x | %04x %04x | %i %i | %02x %04x %04x %02x %04x %04x | %04x %04x[%i %04x]",
223, i, gsamplePos[i], gsampleEnd[i], gloopPos[i],
gvolume_left[i], gvolume_right[i],
glooping[i], gis_stream[i],
gadloop1[i], gadloop2[i], gadloop3[i], gloop1[i], gloop2[i], gloop3[i],
gfrac[i], gratio[i], gratiohi[i], gratiolo[i]
);
}
}
else if(a == 1)
{
if(m_frame->bShowBase) // base 10 (decimal)
{
sprintf(buf,"%c%02i %10s/%10s %10s | %6s %6s | %u %u %u | %u %u %u %u %u %08x %08x %08x %08x %08x %08x",
223, i, ThS(gsamplePos[i]).c_str(), ThS(gsampleEnd[i]).c_str(), ThS(gloopPos[i]).c_str(),
ThS(gvolume_left[i]).c_str(), ThS(gvolume_right[i]).c_str(),
gsrc_type[i], gaudioFormat[i], gcoef[i],
gupdates1[i], gupdates2[i], gupdates3[i], gupdates4[i], gupdates5[i], gupdates_addr[i],
gupdates_data[i], gupdates_data1[i], gupdates_data2[i], gupdates_data3[i], gupdates_data4[i]
);
}
else // base 16 (hexadecimal)
{
if(Wii) // Wii
{
sprintf(buf,"%c%02i %08x/%08x %08x | %04x %04x | %u %u %u | %u %u %u %08x %08x %08x %08x %08x %08x",
223, i, gsamplePos[i], gsampleEnd[i], gloopPos[i],
gvolume_left[i], gvolume_right[i],
gsrc_type[i], gaudioFormat[i], gcoef[i],
gupdates1[i], gupdates2[i], gupdates3[i], gupdates_addr[i],
gupdates_data[i], gupdates_data1[i], gupdates_data2[i], gupdates_data3[i], gupdates_data4[i]
);
}
else // GC
{
sprintf(buf,"%c%02i %08x/%08x %08x | %04x %04x | %u %u %u | %u %u %u %u %u %08x %08x %08x %08x %08x %08x",
223, i, gsamplePos[i], gsampleEnd[i], gloopPos[i],
gvolume_left[i], gvolume_right[i],
gsrc_type[i], gaudioFormat[i], gcoef[i],
gupdates1[i], gupdates2[i], gupdates3[i], gupdates4[i], gupdates5[i], gupdates_addr[i],
gupdates_data[i], gupdates_data1[i], gupdates_data2[i], gupdates_data3[i], gupdates_data4[i]
);
}
}
}
else if(a == 2)
{
if(m_frame->bShowBase)
{
sprintf(buf,"%c%02i %10s/%10s %10s | %05i %05i | %i %i | %10s %10s",
223, i, ThS(gsamplePos[i]).c_str(), ThS(gsampleEnd[i]).c_str(), ThS(gloopPos[i]).c_str(),
gvolume_left[i], gvolume_right[i],
glooping[i], gis_stream[i],
ThS(gsampleEnd[i] - gloopPos[i], false).c_str(), ThS(gsampleEnd[i] - gsamplePos[i], false).c_str()
);
}
else
{
sprintf(buf,"%c%02i %08x/%08x %08x | %04x %04x | %i %i | %08x %08x",
223, i, gsamplePos[i], gsampleEnd[i], gloopPos[i],
gvolume_left[i], gvolume_right[i],
glooping[i], gis_stream[i],
gsampleEnd[i] - gloopPos[i], gsampleEnd[i] - gsamplePos[i]
);
}
}
/*
PRESET 3
" Nr voll volr dl dr curv delt mixc r | v1 v2 v3 v4 v5 v6 v7 | d1 d2 d3 d4 d5 d6 d7\n";
"---------------|00 00000 00000 00000 00000 00000 00000 00000 0 | 00000 00000 00000 00000 00000 00000 00000 | 00000 00000 00000 00000 00000 00000 00000
*/
else if(a == 3)
{
if(m_frame->bShowBase)
{
if(Wii) // Wii
{
sprintf(buf,"%c%02i %05i %05i %05i %05i %05i %05i %05i %i | %05i %05i %05i %05i %05i %05i %05i | %05i %05i %05i %05i %05i %05i %05i",
223, i,
gvolume_left[i], gvolume_right[i], gmix_unknown[i], gmix_unknown2[i], gcur_volume[i], gcur_volume_delta[i],
gmixer_control_wii[i], (gmixer_control_wii[i] & MIXCONTROL_RAMPING),
gmixer_vol1[i], gmixer_vol2[i], gmixer_vol3[i], gmixer_vol4[i], gmixer_vol5[i],
gmixer_vol6[i], gmixer_vol7[i],
gmixer_d1[i], gmixer_d2[i], gmixer_d3[i], gmixer_d4[i], gmixer_d5[i],
gmixer_d6[i], gmixer_d7[i]
);
}
else // GC
{
sprintf(buf,"%c%02i %05i %05i %05i %05i %05i %05i %08i %i | %05i %05i %05i %05i %05i %05i %05i | %05i %05i %05i %05i %05i %05i %05i",
223, i,
gvolume_left[i], gvolume_right[i], gmix_unknown[i], gmix_unknown2[i], gcur_volume[i], gcur_volume_delta[i],
gmixer_control[i], (gmixer_control[i] & MIXCONTROL_RAMPING),
gmixer_vol1[i], gmixer_vol2[i], gmixer_vol3[i], gmixer_vol4[i], gmixer_vol5[i],
gmixer_vol6[i], gmixer_vol7[i],
gmixer_d1[i], gmixer_d2[i], gmixer_d3[i], gmixer_d4[i], gmixer_d5[i],
gmixer_d6[i], gmixer_d7[i]
);
}
}
else
{
if(Wii)
{
sprintf(buf,"%c%02i %04x %04x %04x %04x %04x %04x %08x %i | %04x %04x %04x %04x %04x %04x %04x | %04x %04x %04x %04x %04x %04x %04x",
223, i,
gvolume_left[i], gvolume_right[i], gmix_unknown[i], gmix_unknown2[i], gcur_volume[i], gcur_volume_delta[i],
gmixer_control_wii[i], (gmixer_control_wii[i] & MIXCONTROL_RAMPING),
gmixer_vol1[i], gmixer_vol2[i], gmixer_vol3[i], gmixer_vol4[i], gmixer_vol5[i],
gmixer_vol6[i], gmixer_vol7[i],
gmixer_d1[i], gmixer_d2[i], gmixer_d3[i], gmixer_d4[i], gmixer_d5[i],
gmixer_d6[i], gmixer_d7[i]
);
}
else
{
sprintf(buf,"%c%02i %04x %04x %04x %04x %04x %04x %04x %i | %04x %04x %04x %04x %04x %04x %04x | %04x %04x %04x %04x %04x %04x %04x",
223, i,
gvolume_left[i], gvolume_right[i], gmix_unknown[i], gmix_unknown2[i], gcur_volume[i], gcur_volume_delta[i],
gmixer_control[i], (gmixer_control[i] & MIXCONTROL_RAMPING),
gmixer_vol1[i], gmixer_vol2[i], gmixer_vol3[i], gmixer_vol4[i], gmixer_vol5[i],
gmixer_vol6[i], gmixer_vol7[i],
gmixer_d1[i], gmixer_d2[i], gmixer_d3[i], gmixer_d4[i], gmixer_d5[i],
gmixer_d6[i], gmixer_d7[i]
);
}
}
}
sbuf = buf;
return sbuf;
}
// ================
// =======================================================================================
// Collect parameters from Wii or GC
// --------------
/*
std::string ShowAllPB(int a, int i)
{
if(a == 0)
{
}
else if(a == 1)
{
}
else if(a == 1)
{
}
else if(a == 1)
}
*/
// ================
// =======================================================================================
// Collect parameters from Wii or GC
// --------------
//inline void MixAddVoice(ParamBlockType &pb
//void CollectPB(bool Wii, int i, AXParamBlockWii * PBw, ParamBlockType &pb)
template<class ParamBlockType> void CollectPB(bool Wii, int i, ParamBlockType &PBs)
//void CollectPB(bool Wii, int i, AXParamBlockWii * PBw, AXParamBlock * PBs)
{
// AXPB base
gsrc_type[i] = PBs[i].src_type;
gcoef[i] = PBs[i].coef_select;
if(Wii) gmixer_control_wii[i] = PBs[i].mixer_control;
else gmixer_control[i] = PBs[i].mixer_control;
//running[i] = PBs[i].running;
gis_stream[i] = PBs[i].is_stream;
// mixer (some differences)
gvolume_left[i] = PBs[i].mixer.volume_left;
gvolume_right[i] = PBs[i].mixer.volume_right;
gmix_unknown[i] = PBs[i].mixer.unknown;
gmix_unknown2[i] = PBs[i].mixer.unknown2;
gcur_volume[i] = PBs[i].vol_env.cur_volume;
gcur_volume_delta[i] = PBs[i].vol_env.cur_volume_delta;
gmixer_vol1[i] = PBs[i].mixer.unknown3[0];
gmixer_vol2[i] = PBs[i].mixer.unknown3[2];
gmixer_vol3[i] = PBs[i].mixer.unknown3[4];
gmixer_vol4[i] = PBs[i].mixer.unknown3[6];
gmixer_vol5[i] = PBs[i].mixer.unknown3[0];
gmixer_vol6[i] = PBs[i].mixer.unknown3[2];
gmixer_vol7[i] = PBs[i].mixer.unknown3[4];
gmixer_d1[i] = PBs[i].mixer.unknown4[1];
gmixer_d2[i] = PBs[i].mixer.unknown4[3];
gmixer_d3[i] = PBs[i].mixer.unknown4[5];
gmixer_d4[i] = PBs[i].mixer.unknown4[7];
gmixer_d5[i] = PBs[i].mixer.unknown4[1];
gmixer_d6[i] = PBs[i].mixer.unknown4[3];
gmixer_d7[i] = PBs[i].mixer.unknown4[5];
// PBAudioAddr audio_addr
glooping[i] = PBs[i].audio_addr.looping;
gaudioFormat[i] = PBs[i].audio_addr.sample_format;
gloopPos[i] = (PBs[i].audio_addr.loop_addr_hi << 16) | PBs[i].audio_addr.loop_addr_lo;
gsampleEnd[i] = (PBs[i].audio_addr.end_addr_hi << 16) | PBs[i].audio_addr.end_addr_lo;
gsamplePos[i] = (PBs[i].audio_addr.cur_addr_hi << 16) | PBs[i].audio_addr.cur_addr_lo;
if(gloopPos[i] > 0x20000000) gloopPos[i] -= 0x20000000;
if(gsampleEnd[i] > 0x20000000) gsampleEnd[i] -= 0x20000000;
if(gsamplePos[i] > 0x20000000) { gsamplePos[i] -= 0x20000000;
mem[i] = 2;} else { mem[i] = 1; }
// PBADPCMLoopInfo adpcm_loop_info (same in GC and Wii)
gadloop1[i] = PBs[i].adpcm.pred_scale;
gadloop2[i] = PBs[i].adpcm.yn1;
gadloop3[i] = PBs[i].adpcm.yn2;
gloop1[i] = PBs[i].adpcm_loop_info.pred_scale;
gloop2[i] = PBs[i].adpcm_loop_info.yn1;
gloop3[i] = PBs[i].adpcm_loop_info.yn2;
// updates (differences)
gupdates1[i] = PBs[i].updates.num_updates[0];
gupdates2[i] = PBs[i].updates.num_updates[1];
gupdates3[i] = PBs[i].updates.num_updates[2];
gupdates4[i] = PBs[i].updates.num_updates[3];
gupdates5[i] = PBs[i].updates.num_updates[4];
gupdates_addr[i] = (PBs[i].updates.data_hi << 16) | PBs[i].updates.data_lo;
if(gupdates_addr[i] > 0x80000000 && gupdates_addr[i] < 0x93ffffff)
{
gupdates_data[i] = Memory_Read_U32(gupdates_addr[i]);
gupdates_data1[i] = Memory_Read_U32(gupdates_addr[i] + 4);
gupdates_data2[i] = Memory_Read_U32(gupdates_addr[i] + 8);
gupdates_data3[i] = Memory_Read_U32(gupdates_addr[i] + 12);
gupdates_data3[i] = Memory_Read_U32(gupdates_addr[i] + 16);
}
// PBSampleRateConverter src
gratio[i] = (u32)(((PBs[i].src.ratio_hi << 16) + PBs[i].src.ratio_lo) * ratioFactor);
gratiohi[i] = PBs[i].src.ratio_hi;
gratiolo[i] = PBs[i].src.ratio_lo;
gfrac[i] = PBs[i].src.cur_addr_frac;
}
// ===============
// =======================================================================================
// Prepare the condition that makes us show a certain block
// --------------
template<class ParamBlockType>
bool PrepareConditions(bool Wii, int i, ParamBlockType &PBs)
{
bool Conditions;
if (m_frame->gOnlyLooping) // show only looping blocks
{
Conditions = PBs[i].audio_addr.looping ? true : false;
}
else if (m_frame->gShowAll) // show all blocks
{
Conditions = true;
}
else if (m_frame->giShowAll > -1) // show all blocks
{
if (m_frame->giShowAll == 0)
Conditions = (i < 31);
else if(m_frame->giShowAll == 1)
Conditions = (i > 30 && i < 61);
else if(m_frame->giShowAll == 2)
Conditions = (i > 60 && i < 91);
else if(m_frame->giShowAll == 3)
Conditions = (i > 90 && i < 121);
}
else // show only the ones that have recently been running
{
Conditions = (numberRunning.at(i) > 0 || PBs[i].audio_addr.looping);
}
return Conditions;
}
// ===============
template<class ParamBlockType>
void Logging_(short* _pBuffer, int _iSize, int a, bool Wii, ParamBlockType &PBs,
int numberOfPBs, u32 m_addressPBs)
//void Logging__(short* _pBuffer, int _iSize, int a, bool Wii)
{
bool Conditions; // Select blocks to show
// =======================================================================================
// Update parameter values
// --------------
// We could chose to update these only if a block is currently running. Later I'll add options
// to see both the current and the latest active value.
int irun = 0;
for (int i = 0; i < numberOfPBs; i++)
{
// --------------------------------------------------------------------
// Write a line for the text log if nothing is playing
// --------------
if (PBs[i].running)
{
irun++;
}
if (i == numberOfPBs - 1 && irun == 0)
{
for (int j = 0; j < nFiles; j++)
{
std::string sfbuff;
sfbuff = "-----\n";
aprintf(j, (char *)sfbuff.c_str());
}
}
// --------------
// --------------------------------------
// Now go through only a subset of the blocks depending on Conditions
// ------------------
/* Prepare conditions. We may for example get Conditions = true for blocks
that currently have numberRunning.at(i) > 0 */
Conditions = PrepareConditions(Wii, i, PBs);
if (Conditions)
{
// Collect parameters
CollectPB(Wii, i, PBs);
// ---------------------------------------------------------------------------------------
// Write to file
// --------------
for (int ii = 0; ii < nFiles; ii++)
{
std::string sfbuff;
if(a == 0) sfbuff = "***"; // note if it's before or after an update (*** = before)
else sfbuff = " ";
// write running
char cbuf[10];
sprintf(cbuf, "%i", PBs[i].running);
sfbuff = sfbuff + cbuf;
sfbuff = sfbuff + writeMessage(ii, i, Wii);
// write _iSize
strcpy(cbuf, ""); sprintf(cbuf, "%i", _iSize);
sfbuff = sfbuff + " | _iSize: " + cbuf + "\n";
aprintf(ii, (char *)sfbuff.c_str());
}
// --------------
}
}
// ==============
// =======================================================================================
// Control how often the screen is updated, and then update the screen
// --------------
if(a == 0) count1++; // a == 0 when Logging is called before the blocks are updated
if (m_frame->gUpdFreq > 0 && count1 > (200/m_frame->gUpdFreq))
{
// =======================================================================================
/* Save the displayed running history for each block. Vector1 is a vector1[NUMBER_OF_PBS]
[100] vector. */
// --------------
/*
Move all items back like this:
1 to 0
2 1
3 ...
5 to 4
*/
for (int i = 0; i < numberOfPBs; i++)
{
for (int j = 1; j < vectorLength; j++)
{
vector1.at(i).at(j-1) = vector1.at(i).at(j);
}
// save the latest value
vector1.at(i).at(vectorLength-1) = PBs[i].running ? true : false;
}
// ==============
// =======================================================================================
/* Have a separate set for which ones to show. Currently show blocks that have been
running at least once the last 100 updates.
// --------------
Move all items back like this:
1 to 0
2 1
3 ...
*/
for (int i = 0; i < numberOfPBs; i++)
{
for (int j = 1; j < vectorLength2; j++)
{
vector2.at(i).at(j-1) = vector2.at(i).at(j);
}
// save the latest value
vector2.at(i).at(vectorLength2-1) = PBs[i].running ? true : false;
}
// ==============
// =======================================================================================
// Count how many we have running now in a certain block
// --------------
int jj = 0;
for (int i = 0; i < numberOfPBs; i++)
{
jj = 0;
for (int j = 0; j < vectorLength2-1; j++) // the hundred last updates
{
if (vector2.at(i).at(j)) // if it was on then
{
jj++;
}
numberRunning.at(i) = jj;
}
}
// ==============
// =======================================================================================
// Write header
// --------------
char buffer [1000] = "";
std::string sbuff;
sbuff = writeTitle(m_frame->gPreset, Wii);
// ==============
// =======================================================================================
// Now go through all blocks
// --------------
for (int i = 0; i < numberOfPBs; i++)
{
// --------------------------------------
// Now go through only a subset of the blocks depending on Conditions
// ------------------
// Prepare conditions
Conditions = PrepareConditions(Wii, i, PBs);
if (Conditions)
{
// --------------------------------------
// Save playback history text string for the console and GUI debugger
// ------------------
if(m_frame)
{
std::string guipr; // gui progress
for (int j = 0; j < vectorLengthGUI; j++)
{
if(vector1.at(i).at(j) == false)
{
guipr = guipr + "0";
}
else
{
guipr = guipr + "1";
}
}
u32 run = atoi( guipr.c_str());
m_frame->m_GPRListView->m_CachedRegs[1][i] = run;
guipr.clear();
}
// and for the console debugger
for (int j = 0; j < vectorLength; j++)
{
if(vector1.at(i).at(j) == false)
{
sbuff = sbuff + " ";
}
else
{
sprintf(buffer, "%c", 177);
sbuff = sbuff + buffer; strcpy(buffer, "");
}
}
// ---------
// Hopefully this is false if we don't have a debugging window and so it doesn't cause a crash
if(m_frame)
{
m_frame->m_GPRListView->m_CachedRegs[2][i] = gsamplePos[i];
m_frame->m_GPRListView->m_CachedRegs[3][i] = gsampleEnd[i];
m_frame->m_GPRListView->m_CachedRegs[4][i] = gloopPos[i];
m_frame->m_GPRListView->m_CachedRegs[5][i] = gvolume_left[i];
m_frame->m_GPRListView->m_CachedRegs[6][i] = gvolume_right[i];
m_frame->m_GPRListView->m_CachedRegs[7][i] = glooping[i];
m_frame->m_GPRListView->m_CachedRegs[8][i] = gloop1[i];
m_frame->m_GPRListView->m_CachedRegs[9][i] = gloop2[i];
m_frame->m_GPRListView->m_CachedRegs[10][i] = gloop3[i];
m_frame->m_GPRListView->m_CachedRegs[11][i] = gis_stream[i];
m_frame->m_GPRListView->m_CachedRegs[12][i] = gaudioFormat[i];
m_frame->m_GPRListView->m_CachedRegs[13][i] = gsrc_type[i];
m_frame->m_GPRListView->m_CachedRegs[14][i] = gcoef[i];
m_frame->m_GPRListView->m_CachedRegs[15][i] = gfrac[i];
m_frame->m_GPRListView->m_CachedRegs[16][i] = gratio[i];
m_frame->m_GPRListView->m_CachedRegs[17][i] = gratiohi[i];
m_frame->m_GPRListView->m_CachedRegs[18][i] = gratiolo[i];
m_frame->m_GPRListView->m_CachedRegs[19][i] = gupdates1[i];
m_frame->m_GPRListView->m_CachedRegs[20][i] = gupdates2[i];
m_frame->m_GPRListView->m_CachedRegs[21][i] = gupdates3[i];
m_frame->m_GPRListView->m_CachedRegs[22][i] = gupdates4[i];
m_frame->m_GPRListView->m_CachedRegs[23][i] = gupdates5[i];
}
// add new line
sbuff = sbuff + writeMessage(m_frame->gPreset, i, Wii); strcpy(buffer, "");
sbuff = sbuff + "\n";
} // end of if(Conditions)
// ==============
} // end of for (int i = 0; i < numberOfPBs; i++)
// =======================================================================================
// Write global values
// ---------------
int nOfBlocks;
int span = m_frame->gLastBlock - m_addressPBs;
if(Wii)
nOfBlocks = (m_frame->gLastBlock-m_addressPBs) / 256;
else
nOfBlocks = (m_frame->gLastBlock-m_addressPBs) / 192;
sprintf(buffer, "\nThe parameter blocks span from %08x to %08x (%s bytes) impl. %i blocks | numberOfPBs %i | _iSize %i\n",
m_addressPBs, m_frame->gLastBlock, ThS(span).c_str(), nOfBlocks, numberOfPBs, _iSize);
sbuff = sbuff + buffer; strcpy(buffer, "");
// ===============
// =======================================================================================
// Write settings
// ---------------
sprintf(buffer, "\nSettings: SSBM fix %i | SSBM rem1 %i | SSBM rem2 %i\nSequenced %i | Volume %i | Reset %i | Only looping %i | Save file %i\n",
gSSBM, gSSBMremedy1, gSSBMremedy2, gSequenced,
gVolume, gReset, m_frame->gOnlyLooping, m_frame->gSaveFile);
sbuff = sbuff + buffer; strcpy(buffer, "");
// ===============
// =======================================================================================
// Show update frequency
// ---------------
sbuff = sbuff + "\n";
if(!iupdonce)
{
viupd.at(0) = 1;
viupd.at(1) = 1;
viupd.at(2) = 1;
iupdonce = true;
}
for (u32 i = 0; i < viupd.size(); i++) // 0, 1,..., 9
{
if (i < viupd.size()-1)
{
viupd.at(viupd.size()-i-1) = viupd.at(viupd.size()-i-2); // move all forward
}
else
{
viupd.at(0) = viupd.at(viupd.size()-1);
}
// Correction
if (viupd.at(viupd.size()-3) == 1 && viupd.at(viupd.size()-2) == 1 && viupd.at(viupd.size()-1) == 1)
{
viupd.at(0) = 0;
}
if(viupd.at(0) == 0 && viupd.at(1) == 1 && viupd.at(2) == 1 && viupd.at(3) == 0)
{
viupd.at(0) = 1;
}
}
for (u32 i = 0; i < viupd.size(); i++)
{
if(viupd.at(i) == 0)
sbuff = sbuff + " ";
else
sbuff = sbuff + ".";
}
// ================
// =======================================================================================
// Print
// ----------------
ClearScreen();
wprintf("%s", sbuff.c_str());
sbuff.clear(); strcpy(buffer, "");
// ================
// New values are written so update - DISABLED - It flickered a lot, even worse than a
// console window. So for now only the console windows is updated.
/*
if(m_frame)
{
m_frame->NotifyUpdate();
}
*/
count2=0;
count1=0;
} // end of if (j>20)
} // end of function
// I placed this in CUCode_AX so it can share member values with that class
void CUCode_AX::Logging(short* _pBuffer, int _iSize, int a, bool Wii)
{
/* Doing all this may have a noticable CPU effect, so we can disable it completely
this way. But remember that "Save to file" will not write anything then either. */
if (m_frame->gUpdFreq > 0)
{
int version; // AX version
int numberOfPBs;
// Declare structures
AXParamBlock PBs[NUMBER_OF_PBS];
AXParamBlockWii PBw[NUMBER_OF_PBS];
AXParamBlockWii_ PBw_[NUMBER_OF_PBS];
if(_CRC == 0xfa450138) version = 0; else version = 1;
// Read out structs and number of PBs that have data
if(Wii)
{
if(version == 0)
{
numberOfPBs = ReadOutPBsWii(m_addressPBs, PBw, NUMBER_OF_PBS);
Logging_(_pBuffer, _iSize, a, Wii, PBw, numberOfPBs, m_addressPBs);
}
else
{
numberOfPBs = ReadOutPBsWii(m_addressPBs, PBw_, NUMBER_OF_PBS);
Logging_(_pBuffer, _iSize, a, Wii, PBw_, numberOfPBs, m_addressPBs);
}
}
else
{
numberOfPBs = ReadOutPBs(m_addressPBs, PBs, NUMBER_OF_PBS);
Logging_(_pBuffer, _iSize, a, Wii, PBs, numberOfPBs, m_addressPBs);
}
}
}

19
Source/Plugins/Plugin_DSP_HLE/Src/PCHW/Mixer.cpp
View File

@ -15,20 +15,29 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
// This queue solution is temporary. I'll implement something more efficient later.
#include <queue>
#include "../Config.h"
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
// This queue solution is temporary. I'll implement something more efficient later.
#include <queue> // System
#include "Thread.h" // Common
#include "ConsoleWindow.h"
#include "../Config.h" // Local
#include "../Globals.h"
#include "../DSPHandler.h"
#include "../Logging/Console.h"
#include "Thread.h"
#include "../Debugger/File.h"
#include "Mixer.h"
#include "FixedSizeQueue.h"
#ifdef _WIN32
#include "../PCHW/DSoundStream.h"
#endif
///////////////////////
namespace {
Common::CriticalSection push_sync;

2
Source/Plugins/Plugin_DSP_HLE/Src/SConscript
View File

@ -17,7 +17,7 @@ files = [
'Globals.cpp',
'PCHW/AOSoundStream.cpp',
'PCHW/Mixer.cpp',
'Logging/Console.cpp',
'Debugger/File.cpp',
'UCodes/UCode_AX.cpp',
'UCodes/UCode_AXWii.cpp',
'UCodes/UCode_CARD.cpp',

14
Source/Plugins/Plugin_DSP_HLE/Src/UCodes/UCode_AX.cpp
View File

@ -15,11 +15,11 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "FileUtil.h" // for IsDirectory
#include "StringUtil.h" // for StringFromFormat
#include "FileUtil.h" // For IsDirectory()
#include "StringUtil.h" // For StringFromFormat()
#if defined(HAVE_WX) && HAVE_WX
#include "../Debugger/Debugger.h"
#include "../Logging/Console.h" // for aprintf
//#include "../Logging/File.h" // For PrintFile()
extern CDebugger* m_frame;
#endif
#include <sstream>
@ -119,7 +119,7 @@ if(m_frame->ScanMails)
{
if(saveNext && saveNext < 100) // limit because saveNext is not initialized
{
//wprintf("End");
//Console::Print("End");
// Save the timestamps and comment
std::ostringstream ci;
@ -217,7 +217,7 @@ if(m_frame->ScanMails)
// In case the mail didn't match any saved mail, save it
if(addnew == m_frame->sMail.size())
{
//wprintf("%i | %i\n", addnew, m_frame->sMail.size());
//Console::Print("%i | %i\n", addnew, m_frame->sMail.size());
u32 resizeTo = m_frame->sMail.size() + 1;
// ------------------------------------
@ -248,7 +248,7 @@ if(m_frame->ScanMails)
// Save as file
if(m_frame->StoreMails)
{
//wprintf("m_frame->sMail.size(): %i | resizeTo:%i\n", m_frame->sMail.size(), resizeTo);
//Console::Print("m_frame->sMail.size(): %i | resizeTo:%i\n", m_frame->sMail.size(), resizeTo);
SaveLogFile(lMail, resizeTo, 0, Wii);
}
@ -377,7 +377,7 @@ void CUCode_AX::MixAdd(short* _pBuffer, int _iSize)
if (on > 0 && off > 0) pDest[7] = 1;
}
//aprintf(1, "%08x %04x %04x\n", updaddr, updpar, upddata);
//PrintFile(1, "%08x %04x %04x\n", updaddr, updpar, upddata);
// ------------
for (int i = 0; i < numberOfPBs; i++)

4
Source/Plugins/Plugin_DSP_HLE/Src/UCodes/UCode_AXWii.cpp
View File

@ -19,7 +19,7 @@
#if defined(HAVE_WX) && HAVE_WX
#include "../Debugger/Debugger.h"
#include "../Logging/Console.h" // for aprintf
//#include "../Logging/File.h" // For PrintFile
extern CDebugger * m_frame;
#endif
@ -194,7 +194,7 @@ void CUCode_AXWii::MixAdd_(short* _pBuffer, int _iSize, ParamBlockType &PBs)
if (on > 0 && off > 0) pDest[7] = 1;
}
//aprintf(1, "%08x %04x %04x\n", updaddr, updpar, upddata);
//PrintFile(1, "%08x %04x %04x\n", updaddr, updpar, upddata);
// ------------

77
Source/Plugins/Plugin_DSP_HLE/Src/main.cpp
View File

@ -15,32 +15,42 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include <iostream>
#include "Globals.h"
#include "Globals.h" // Local
#if defined(HAVE_WX) && HAVE_WX
#include "Logging/Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Debugger/Debugger.h" // for the CDebugger class
CDebugger* m_frame;
#include "Debugger/File.h" // For file logging
#include "Debugger/Debugger.h" // For the CDebugger class
CDebugger* m_frame;
#endif
#include "ConsoleWindow.h" // Common: For the Windows console
#include "ChunkFile.h"
#include "WaveFile.h"
#include "resource.h"
#ifdef _WIN32
#include "PCHW/DSoundStream.h"
#include "ConfigDlg.h"
#include "PCHW/DSoundStream.h"
#include "ConfigDlg.h"
#else
#include "PCHW/AOSoundStream.h"
#include "PCHW/AOSoundStream.h"
#endif
#include "PCHW/Mixer.h"
#include "DSPHandler.h"
#include "Config.h"
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
DSPInitialize g_dspInitialize;
u8* g_pMemory;
extern std::vector<std::string> sMailLog, sMailTime;
@ -50,6 +60,11 @@ std::string gpName;
static bool log_ai = false;
static WaveFileWriter g_wave_writer;
// --------------------------------------
// Mailbox utility
// ----------
struct DSPState
{
u32 CPUMailbox;
@ -69,14 +84,15 @@ struct DSPState
DSPMailbox_Read[1] = true;
}
};
DSPState g_dspState;
// ====================
// -------------------
///////////////////////////////
#if defined(HAVE_WX) && HAVE_WX
//////////////////////////////////////////////////////////////////////////////////////////
// wxWidgets - Some kind of stuff wx needs
// wxWidgets: Create the wxApp
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#if defined(HAVE_WX) && HAVE_WX
class wxDLLApp : public wxApp
{
bool OnInit()
@ -87,9 +103,13 @@ class wxDLLApp : public wxApp
IMPLEMENT_APP_NO_MAIN(wxDLLApp)
WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
///////////////////
#endif
///////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// DllMain
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#ifdef _WIN32
HINSTANCE g_hInstance = NULL;
@ -126,6 +146,7 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
return(TRUE);
}
#endif
///////////////////
// =======================================================================================
@ -134,9 +155,9 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
void OpenConsole()
{
#if defined (_WIN32)
startConsoleWin(155, 100, "Sound Debugging"); // give room for 100 rows
wprintf("OpenConsole > Console opened\n");
MoveWindow(GetConsoleHwnd(), 0,400, 1280,550, true); // move window, TODO: make this
Console::Open(155, 100, "Sound Debugging"); // give room for 100 rows
Console::Print("OpenConsole > Console opened\n");
MoveWindow(Console::GetHwnd(), 0,400, 1280,550, true); // move window, TODO: make this
// adjustable from the debugging window
#endif
}
@ -150,6 +171,10 @@ void CloseConsole()
// ===================
//////////////////////////////////////////////////////////////////////////////////////////
// Exported fuctions
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// =======================================================================================
// Create debugging window - We could use use wxWindow win; new CDebugger(win) like nJoy but I don't
// know why it would be better. - There's a lockup problem with ShowModal(), but Show() doesn't work
@ -216,11 +241,11 @@ void Initialize(void *init)
gpName = g_dspInitialize.pName(); // save the game name globally
for (u32 i = 0; i < gpName.length(); ++i) // and fix it
{
wprintf(L"%c", gpName[i]);
Console::Print(L"%c", gpName[i]);
std::cout << gpName[i];
if (gpName[i] == ':') gpName[i] = ' ';
}
wprintf(L"\n");
Console::Print(L"\n");
#endif
CDSPHandler::CreateInstance();
@ -269,7 +294,13 @@ void Shutdown()
void DoState(unsigned char **ptr, int mode) {
PointerWrap p(ptr, mode);
}
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Mailbox fuctions
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
unsigned short DSP_ReadMailboxHigh(bool _CPUMailbox)
{
if (_CPUMailbox)
@ -334,7 +365,12 @@ void DSP_WriteMailboxLow(bool _CPUMailbox, unsigned short _Value)
PanicAlert("CPU can't write %08x to DSP mailbox", _Value);
}
}
///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Other DSP fuctions
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
unsigned short DSP_WriteControlRegister(unsigned short _Value)
{
return CDSPHandler::GetInstance().WriteControlRegister(_Value);
@ -369,3 +405,4 @@ void DSP_SendAIBuffer(unsigned int address, int sample_rate)
DSound::DSound_UpdateSound();
#endif
}
///////////////////////////////

8
Source/Plugins/Plugin_DSP_LLE/Plugin_DSP_LLE.vcproj
View File

@ -710,14 +710,6 @@
RelativePath=".\Src\Logging\AXTask.cpp"
>
</File>
<File
RelativePath=".\Src\Logging\Console.cpp"
>
</File>
<File
RelativePath=".\Src\Logging\Console.h"
>
</File>
<File
RelativePath=".\Src\Logging\Logging.cpp"
>

197
Source/Plugins/Plugin_DSP_LLE/Src/Logging/Console.cpp
View File

@ -1,197 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifdef _WIN32
// =======================================================================================
// Includes
// --------------
#include <string>
#include <stdio.h>
#include <windows.h>
// ---------------------------------------------------------------------------------------
// Defines and settings
// --------------
bool g_consoleEnable = true;
#define DEBUGG
//#define DEBUGG_FILEONLY
//#define DEBUGG_NOFILE
// ---------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------
// Handles
// --------------
#ifdef DEBUGG
FILE* __fStdOut = NULL;
#endif
#ifndef DEBUGG_FILEONLY
HANDLE __hStdOut = NULL;
#endif
// ==============
// =======================================================================================
// Width and height is the size of console window, if you specify fname,
// the output will also be writton to this file. The file pointer is automatically closed
// when you close the app
// --------------
void startConsoleWin(int width, int height, char* fname)
{
#ifdef DEBUGG
#ifndef DEBUGG_FILEONLY
AllocConsole();
SetConsoleTitle(fname);
__hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD co = {width,height};
SetConsoleScreenBufferSize(__hStdOut, co);
SMALL_RECT coo = {0,0,(width - 1),70}; // top, left, right, bottom
SetConsoleWindowInfo(__hStdOut, TRUE, &coo);
#endif
#ifndef DEBUGG_NOFILE
// ---------------------------------------------------------------------------------------
// Write to a file
if(fname)
{
// Edit the log file name
std::string FileEnding = ".log";
std::string FileName = fname;
std::string FullFilename = (FileName + FileEnding);
__fStdOut = fopen(FullFilename.c_str(), "w");
}
// -----------------
#endif
#endif
}
void ClearScreen();
int wprintf(char *fmt, ...)
{
#ifdef DEBUGG
char s[6000]; // WARNING: mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 3000, fmt, argptr);
va_end(argptr);
DWORD cCharsWritten;
// ---------------------------------------------------------------------------------------
#ifndef DEBUGG_FILEONLY
if(__hStdOut)
{
WriteConsole(__hStdOut, s, strlen(s), &cCharsWritten, NULL);
}
#endif
#ifndef DEBUGG_NOFILE
// ---------------------------------------------------------------------------------------
if(__fStdOut)
fprintf(__fStdOut, s);
// ---------------------------------------------------------------------------------------
#endif
return(cnt);
#else
return 0;
#endif
}
// =======================================================================================
// Clear screen
// --------------
void ClearScreen()
{
if(g_consoleEnable)
{
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
//HANDLE hConsole = __hStdOut;
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize,
coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize,
coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
}
}
// =======================================================================================
// Get console HWND to be able to use MoveWindow()
// --------------
HWND GetConsoleHwnd(void)
{
#define MY_BUFSIZE 1024 // Buffer size for console window titles.
HWND hwndFound; // This is what is returned to the caller.
char pszNewWindowTitle[MY_BUFSIZE]; // Contains fabricated
// WindowTitle.
char pszOldWindowTitle[MY_BUFSIZE]; // Contains original
// WindowTitle.
// Fetch current window title.
GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);
// Format a "unique" NewWindowTitle.
wsprintf(pszNewWindowTitle,"%d/%d",
GetTickCount(),
GetCurrentProcessId());
// Change current window title.
SetConsoleTitle(pszNewWindowTitle);
// Ensure window title has been updated.
Sleep(40);
// Look for NewWindowTitle.
hwndFound = FindWindow(NULL, pszNewWindowTitle);
// Restore original window title.
SetConsoleTitle(pszOldWindowTitle);
return(hwndFound);
}
#endif

26
Source/Plugins/Plugin_DSP_LLE/Src/Logging/Console.h
View File

@ -1,26 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifdef _WIN32
void startConsoleWin(int width, int height, char* fname);
int wprintf(char *fmt, ...);
void ClearScreen();
HWND GetConsoleHwnd(void);
#endif

31
Source/Plugins/Plugin_DSP_LLE/Src/Logging/Logging.cpp
View File

@ -30,16 +30,20 @@
#include "Common.h"
#include "UCode_AXStructs.h" // they are only in a virtual dir called UCodes AX
#include "Console.h" // For wprintf, ClearScreen
#include "ConsoleWindow.h" // For Console::Print, Console::ClearScreen
// =====================
// ---------------------------------------------------------------------------------------
// Declarations
// =======================================================================================
// Declarations and definitions
// --------------
// ----------------------------------
// Settings
// --------------
#define NUMBER_OF_PBS 64 // Todo: move this to a logging class
// ---------------------------------------------------------------------------------------
// -----------------------------------
// Externals
// --------------
extern u32 m_addressPBs;
@ -49,9 +53,8 @@ short globalpBuffer;
u32 gLastBlock;
// --------------
// ---------------------------------------------------------------------------------------
// Vectors and other stuff
// -----------------------------------
// Vectors and other things
// --------------
std::vector<u32> gloopPos(64);
std::vector<u32> gsampleEnd(64);
@ -91,7 +94,7 @@ std::vector<u32> gsamplePos(64);
std::vector<u16> gupdates5(64);
std::vector<u32> gupdates_addr(64);
// other stuff
// Other things
std::vector<u16> Jump(64); // this is 1 or 0
std::vector<int> musicLength(64);
std::vector< std::vector<int> > vector1(64, std::vector<int>(100,0));
@ -110,7 +113,7 @@ std::vector<u16> vector62(vectorLength);
std::vector<u16> vector63(vectorLength);
int ReadOutPBs(AXParamBlock * _pPBs, int _num);
// ===========
// =====================
// =======================================================================================
@ -359,8 +362,8 @@ void Logging()
// =======================================================================================
// Print
// ---------------
ClearScreen();
wprintf("%s", sbuff.c_str());
Console::ClearScreen();
Console::Print("%s", sbuff.c_str());
sbuff.clear(); strcpy(buffer, "");
// ---------------
k=0;
@ -377,4 +380,4 @@ void Logging()
#endif
#endif

10
Source/Plugins/Plugin_DSP_LLE/Src/Logging/ReadPBs.cpp
View File

@ -28,7 +28,7 @@
#include "CommonTypes.h" // Pluginspecs
#include "UCode_AXStructs.h" // For the AXParamBlock structure
#include "Console.h" // For wprintf, ClearScreen
#include "ConsoleWindow.h" // For Console::Print, Console::ClearScreen
u32 m_addressPBs = 0;
@ -54,7 +54,7 @@ int ReadOutPBs(AXParamBlock * _pPBs, int _num)
// reading and 'halfword' swap
n++;
if (n > 20 && logall) {ClearScreen();}
if (n > 20 && logall) {Console::ClearScreen();}
for (int i = 0; i < _num; i++)
{
// ---------------------------------------------------------------------------------------
@ -68,7 +68,7 @@ int ReadOutPBs(AXParamBlock * _pPBs, int _num)
// Create a shortcut that let us update struct members
short * pDest = (short *) & _pPBs[i];
if (n > 20 && logall) {wprintf("%c%i:", 223, i);} // logging
if (n > 20 && logall) {Console::Print("%c%i:", 223, i);} // logging
// --------------
// Here we update the PB. We do it by going through all 192 / 2 = 96 u16 values
@ -80,7 +80,7 @@ int ReadOutPBs(AXParamBlock * _pPBs, int _num)
{
if (pSrc[p] != 0 && n > 20 && logall)
{
wprintf("%i %04x | ", p, Common::swap16(pSrc[p]));
Console::Print("%i %04x | ", p, Common::swap16(pSrc[p]));
}
}
@ -88,7 +88,7 @@ int ReadOutPBs(AXParamBlock * _pPBs, int _num)
}
if(n > 20 && logall) {wprintf("\n");} // logging
if(n > 20 && logall) {Console::Print("\n");} // logging
// --------------
// Here we update the block address to the starting point of the next PB
blockAddr = (_pPBs[i].next_pb_hi << 16) | _pPBs[i].next_pb_lo;

24
Source/Plugins/Plugin_DSP_LLE/Src/main.cpp
View File

@ -15,12 +15,17 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "Common.h"
#include "Globals.h"
// =======================================================================================
// Includes
// --------------
#include "Common.h" // Common
#include "WaveFile.h"
#include "CommonTypes.h"
#include "Mixer.h"
#include "ConsoleWindow.h" // For Console::Open, Console::Print
#include "Globals.h" // Local
#include "gdsp_interpreter.h"
#include "gdsp_interface.h"
#include "disassemble.h"
@ -28,7 +33,6 @@
#ifdef _WIN32
#include "DisAsmDlg.h"
#include "DSoundStream.h"
#include "Logging/Console.h" // For wprintf, ClearScreen
#include "Logging/Logging.h" // For Logging
HINSTANCE g_hInstance = NULL;
@ -47,10 +51,11 @@
#endif
#include "ChunkFile.h"
// ==============
// =======================================================================================
// Globals
// Global declarations and definitions
// --------------
DSPInitialize g_dspInitialize;
@ -68,7 +73,6 @@ bool bCanWork = false;
// Set this if you want to log audio. search for log_ai in this file to see the filename.
static bool log_ai = false;
WaveFileWriter g_wave_writer;
// ==============
@ -134,12 +138,12 @@ void DllDebugger(HWND _hParent, bool Show)
MoveWindow(g_Dialog.m_hWnd, 450,0, 780,530, true);
// Open the console window
startConsoleWin(155, 100, "Sound Debugging"); // give room for 100 rows
wprintf("DllDebugger > Console opened\n");
// TODO: Make this adjustable from the Debugging window
MoveWindow(GetConsoleHwnd(), 0,400, 1280,500, true);
Console::Open(155, 100, "Sound Debugging"); // give room for 100 rows
Console::Print("DllDebugger > Console opened\n");
// Todo: Make this adjustable from the Debugging window
MoveWindow(Console::GetHwnd(), 0,400, 1280,500, true);
#else
MessageBox(0, "Can't open debugging window in Release build of this plugin.", "DSP LLE", 0);
MessageBox(0, "Can't open debugging window in the Release build of this plugin.", "DSP LLE", 0);
#endif
#endif
}

14
Source/Plugins/Plugin_VideoOGL/Plugin_VideoOGL.vcproj
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Version="9,00"
Name="Plugin_VideoOGL"
ProjectGUID="{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}"
RootNamespace="Plugin_VideoOGL"
@ -865,19 +865,11 @@
Name="Logging"
>
<File
RelativePath=".\Src\Logging\Console.cpp"
RelativePath=".\Src\Debugger\Logging.cpp"
>
</File>
<File
RelativePath=".\Src\Logging\Console.h"
>
</File>
<File
RelativePath=".\Src\Logging\Logging.cpp"
>
</File>
<File
RelativePath=".\Src\Logging\Logging.h"
RelativePath=".\Src\Debugger\Logging.h"
>
</File>
<File

151
Source/Plugins/Plugin_VideoOGL/Src/Debugger/Debugger.cpp
View File

@ -15,24 +15,34 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "../Globals.h"
#include "IniFile.h" // Common files
// =======================================================================================
// Includes
// ---------------
#include "../Globals.h" // The precompiled header
#include "IniFile.h" // Common
#include "ConsoleWindow.h" // Move console window
#include "../Config.h" // Config settings
#include "PBView.h" // Debugger files
#include "Debugger.h"
#include "../Logging/Console.h" // open and close console
// externals
extern int gSaveFile; // make this an int to allow multiple save file options
extern int gPreset;
int A, B;
#include "Logging.h" // Open and close console
// ========================
// =======================================================================================
// Declare events
// Declarations and definitions
// ---------------
extern int gPreset;
int A, B;
// ========================
// =======================================================================================
// Event table and class
// ---------------
BEGIN_EVENT_TABLE(CDebugger,wxDialog)
EVT_SHOW(CDebugger::OnShow)
EVT_CLOSE(CDebugger::OnClose)
@ -48,7 +58,6 @@ BEGIN_EVENT_TABLE(CDebugger,wxDialog)
EVT_BUTTON(ID_BP,CDebugger::Bp)
EVT_BUTTON(ID_BM,CDebugger::Bm)
END_EVENT_TABLE()
// =======================================================================================
CDebugger::CDebugger(wxWindow *parent, wxWindowID id, const wxString &title,
@ -72,7 +81,61 @@ CDebugger::~CDebugger()
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
}
// =========================
// ==========================================================================
// System functions
// --------------
void CDebugger::OnShow(wxShowEvent& /*event*/)
{
// bring the console back to
if(m_Check[2]->IsChecked())
{
OpenConsole();
#ifdef _WIN32
MoveWindow(Console::GetHwnd(), 0,400, 1280,500, true); // Move window TODO: make this
// adjustable from the debugging window
#endif
}
}
void CDebugger::OnClose(wxCloseEvent& /*event*/)
{
// save the window position when we hide the window to
IniFile file;
file.Load(DEBUGGER_CONFIG_FILE);
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
EndModal(0); // it seems like this works for Show() to, not just ShowModal();
CloseConsole(); // The console goes with the wx window
}
void CDebugger::DoHide()
{
Hide();
CloseConsole(); // The console goes with the wx window
}
void CDebugger::DoShow()
{
Show();
DoShowHideConsole(); // The console goes with the wx window
}
void CDebugger::OnUpdate(wxCommandEvent& /*event*/)
{
this->NotifyUpdate();
}
// ===============
// ==========================================================================
// Save and load settings
// --------------
void CDebugger::Save(IniFile& _IniFile) const
{
// TODO1: make this work when we close the entire program to, currently on total close we get
@ -87,7 +150,8 @@ void CDebugger::Save(IniFile& _IniFile) const
_IniFile.Set("VideoWindow", "w", GetSize().GetWidth());
_IniFile.Set("VideoWindow", "h", GetSize().GetHeight());
}
_IniFile.Set("VideoWindow", "Console", m_Check[2]->IsChecked()); // save settings
_IniFile.Set("VideoWindow", "Console", m_Check[2]->IsChecked()); // Save settings
_IniFile.Set("VideoWindow", "WriteToFile", m_Check[0]->IsChecked());
_IniFile.Set("VideoWindow", "UpdateFrequency", m_RadioBox[1]->GetSelection());
_IniFile.Set("VideoWindow", "LogLevel", g_Config.iLog);
}
@ -102,12 +166,15 @@ void CDebugger::Load(IniFile& _IniFile)
_IniFile.Get("VideoWindow", "h", &h, GetSize().GetHeight());
SetSize(x, y, w, h);
// saved settings
// Saved settings
bool Console;
_IniFile.Get("VideoWindow", "Console", &Console, m_Check[2]->IsChecked());
m_Check[2]->SetValue(Console);
DoShowHideConsole();
_IniFile.Get("VideoWindow", "WriteToFile", &LocalLogFile, m_Check[0]->IsChecked());
m_Check[0]->SetValue(LocalLogFile);
_IniFile.Get("VideoWindow", "UpdateFrequency", &gUpdFreq, m_RadioBox[1]->GetSelection());
m_RadioBox[1]->SetSelection(gUpdFreq);
DoChangeFrequency();
@ -115,6 +182,8 @@ void CDebugger::Load(IniFile& _IniFile)
_IniFile.Get("VideoWindow", "LogLevel", &g_Config.iLog, 0);
m_settings->Check(g_Config.iLog - 1, true);
}
// ===============
void CDebugger::CreateGUIControls()
{
@ -183,6 +252,9 @@ void CDebugger::CreateGUIControls()
// checkboxes
m_Check[0] = new wxCheckBox(m_PageMain, ID_SAVETOFILE, wxT("Save to file"),
wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
//m_Check[0]->SetToolTip(wxT("This will write the console output to" FULL_LOGS_DIR "oglgfx.txt"));
m_Check[0]->SetToolTip(wxT("This will write the console output to" FULL_LOGS_DIR "oglgfx.txt"));
m_Check[2] = new wxCheckBox(m_PageMain, ID_SHOWCONSOLE, wxT("Show console"),
wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
@ -297,55 +369,6 @@ void CDebugger::CreateGUIControls()
}
// ==========================================================================
// System functions
// --------------
void CDebugger::OnShow(wxShowEvent& /*event*/)
{
// bring the console back to
if(m_Check[2]->IsChecked())
{
OpenConsole();
#ifdef _WIN32
MoveWindow(GetConsoleHwnd(), 0,400, 1280,500, true); // Move window TODO: make this
// adjustable from the debugging window
#endif
}
}
void CDebugger::OnClose(wxCloseEvent& /*event*/)
{
// save the window position when we hide the window to
IniFile file;
file.Load(DEBUGGER_CONFIG_FILE);
this->Save(file);
file.Save(DEBUGGER_CONFIG_FILE);
EndModal(0); // it seems like this works for Show() to, not just ShowModal();
CloseConsole(); // The console goes with the wx window
}
void CDebugger::DoHide()
{
Hide();
CloseConsole(); // The console goes with the wx window
}
void CDebugger::DoShow()
{
Show();
DoShowHideConsole(); // The console goes with the wx window
}
void CDebugger::OnUpdate(wxCommandEvent& /*event*/)
{
this->NotifyUpdate();
}
// ===============
// =======================================================================================
// Change preset
// --------------
@ -422,7 +445,7 @@ void CDebugger::GeneralSettings(wxCommandEvent& event)
switch (event.GetId())
{
case ID_SAVETOFILE: // Save to file
gSaveFile = m_Check[0]->IsChecked();
LocalLogFile = m_Check[0]->IsChecked();
break;
case ID_SHOWCONSOLE:
DoShowHideConsole();
@ -441,8 +464,8 @@ void CDebugger::DoShowHideConsole()
{
OpenConsole();
#ifdef _WIN32
MoveWindow(GetConsoleHwnd(), 0,400, 1280,500, true); // move window, TODO: make this
// adjustable from the debugging window
MoveWindow(Console::GetHwnd(), 0,400, 1280,500, true); // Move window. TODO: make this
// adjustable from the debugging window
#endif
}
else

71
Source/Plugins/Plugin_VideoOGL/Src/Globals.cpp
View File

@ -33,56 +33,41 @@
#include "main.h"
#include "IniFile.h"
#include "ConsoleWindow.h"
#include <assert.h>
/////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// Open and close the Windows console window
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#ifdef _WIN32
// The Windows console handle. The one for Linux is in Linux/Linux.cpp
static HANDLE hConsole = NULL;
//////////////////////////////////
void OpenConsole()
{
COORD csize;
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
SMALL_RECT srect;
if (hConsole)
return;
AllocConsole();
SetConsoleTitle("Opengl Plugin Output");
// set width and height
csize.X = 155; // this fits on 1280 pixels TODO: make it adjustable from the wx debugging window
csize.Y = 300; // 300 rows
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), csize);
// make the internal buffer match the width we set
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbiInfo);
srect = csbiInfo.srWindow;
srect.Right = srect.Left + csize.X - 1; // match
srect.Bottom = srect.Top + 44;
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &srect);
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
Console::Open(100, 300, "OpenGL Plugin Output"); // give room for 300 rows
Console::Print("OpenGL console opened\n");
MoveWindow(Console::GetHwnd(), 0,400, 1280,550, true); // Move window. Todo: make this
// adjustable from the debugging window
}
void CloseConsole()
{
if (hConsole == NULL)
return;
FreeConsole();
hConsole = NULL;
Console::Close();
}
#endif
//////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Write logs
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// The log file handle
static FILE* pfLog = NULL;
// This is on by default, but can be controlled from the debugging window
bool LocalLogFile = true;
void __Log(const char *fmt, ...)
{
char* Msg = (char*)alloca(strlen(fmt)+512);
@ -94,17 +79,20 @@ void __Log(const char *fmt, ...)
g_VideoInitialize.pLog(Msg, FALSE);
if (pfLog == NULL)
// If we have no file to write to, create one
if (pfLog == NULL && LocalLogFile)
pfLog = fopen(FULL_LOGS_DIR "oglgfx.txt", "w");
if (pfLog != NULL)
// Write to file
if (pfLog != NULL && LocalLogFile)
fwrite(Msg, strlen(Msg), 1, pfLog);
#ifdef _WIN32
DWORD tmp;
WriteConsole(hConsole, Msg, (DWORD)strlen(Msg), &tmp, 0);
// Write to the console screen, if one exists
Console::Print(Msg);
#else
//printf("%s", Msg);
#endif
//printf("%s", Msg);
#endif
}
void __Log(int type, const char *fmt, ...)
@ -119,7 +107,8 @@ void __Log(int type, const char *fmt, ...)
g_VideoInitialize.pLog(Msg, FALSE);
#ifdef _WIN32
DWORD tmp;
WriteConsole(hConsole, Msg, (DWORD)strlen(Msg), &tmp, 0);
// Write to the console screen, if one exists
Console::Print(Msg);
#endif
}
//////////////////////////////////

19
Source/Plugins/Plugin_VideoOGL/Src/Globals.h
View File

@ -15,18 +15,31 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
// This file should DIE.
#ifndef _GLOBALS_H
#define _GLOBALS_H
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include "Common.h"
#include "Config.h"
#include "VideoCommon.h"
#include "pluginspecs_video.h"
//////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
// Turns file logging on and off
extern bool LocalLogFile;
// A global plugin specification
extern PLUGIN_GLOBALS* globals;
//////////////////////////////
#endif
#endif // _GLOBALS_H

213
Source/Plugins/Plugin_VideoOGL/Src/Logging/Console.cpp
View File

@ -1,213 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#include "../Globals.h"
#include <string>
#include <stdio.h>
#ifdef _WIN32
#include <windows.h>
#endif
//////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// --------------------
// On and off
bool g_consoleEnable = true;
int gSaveFile = 0;
#define DEBUGG
// --------------------
// Settings
int nFiles = 1;
// --------------------
// Create handles
#ifdef DEBUGG
FILE* __fStdOut[1]; // you have to update this manually, we can't place a nFiles in there
#endif
#ifdef _WIN32
HANDLE __hStdOut = NULL;
#endif
///////////////////////////////////
// =======================================================================================
/* Start console window - width and height is the size of console window, if you specify
fname, the output will also be written to this file. TODO: Close the file pointer when the app
is closed */
// -------------
void startConsoleWin(int width, int height, char* fname)
{
#if defined(DEBUGG) && defined(_WIN32)
AllocConsole();
SetConsoleTitle(fname);
__hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
// swt the width and height of the window
COORD co = {width,height};
SetConsoleScreenBufferSize(__hStdOut, co);
// make the internal buffer match the width we set
SMALL_RECT coo = {0,0,(width - 1),70}; // top, left, right, bottom
SetConsoleWindowInfo(__hStdOut, TRUE, &coo);
// ---------------------------------------------------------------------------------------
// Write to a file
if(fname)
{
for(int i = 0; i < nFiles; i++)
{
// Edit the log file name
std::string FileEnding = ".log";
std::string FileName = fname;
char buffer[33]; _itoa(i, buffer, 10); // convert number to string
std::string FullFilename = (FileName + buffer + FileEnding);
__fStdOut[i] = fopen(FullFilename.c_str(), "w");
}
}
// ---------------
#endif
}
// ---------------------------------------------------------------------------------------
// File printf function
int aprintf(int a, char *fmt, ...)
{
#if defined(DEBUGG) && defined(_WIN32)
if(gSaveFile)
{
char s[5000]; // WARNING: mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 5000, fmt, argptr); // remember to update this value to
va_end(argptr);
// ---------------------------------------------------------------------------------------
if(__fStdOut[a]) // TODO: make this work, we have to set all default values to NULL
//to make it work
fprintf(__fStdOut[a], s);
// -------------
return(cnt);
}
else
{
return 0;
}
#else
return 0;
#endif
}
void ClearScreen()
{
#if defined(DEBUGG) && defined(_WIN32)
if(g_consoleEnable)
{
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize,
coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize,
coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
}
#endif
}
#ifndef _WIN32
// VERY UGLY! needs to be fixed soon, just fixing the biuld...
void CloseConsole()
{
}
void OpenConsole()
{
}
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Get the window handle of the console
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#if defined(DEBUGG) && defined(_WIN32)
HWND GetConsoleHwnd(void)
{
#define MY_BUFSIZE 1024 // Buffer size for console window titles.
HWND hwndFound; // This is what is returned to the caller.
char pszNewWindowTitle[MY_BUFSIZE]; // Contains fabricated
// WindowTitle.
char pszOldWindowTitle[MY_BUFSIZE]; // Contains original
// WindowTitle.
// Fetch current window title.
GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);
// Format a "unique" NewWindowTitle.
wsprintf(pszNewWindowTitle,"%d/%d",
GetTickCount(),
GetCurrentProcessId());
// Change current window title.
SetConsoleTitle(pszNewWindowTitle);
// Ensure window title has been updated.
Sleep(40);
// Look for NewWindowTitle.
hwndFound = FindWindow(NULL, pszNewWindowTitle);
// Restore original window title.
SetConsoleTitle(pszOldWindowTitle);
return(hwndFound);
}
#endif // win32
////////////////////////////////////

27
Source/Plugins/Plugin_VideoOGL/Src/Logging/Console.h
View File

@ -1,27 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
void startConsoleWin(int width, int height, char* fname);
int aprintf(int a, char *fmt, ...);
void ClearScreen();
void OpenConsole();
void CloseConsole();
#ifdef _WIN32
HWND GetConsoleHwnd(void);
#endif

284
Source/Plugins/Plugin_VideoOGL/Src/Logging/Logging.cpp
View File

@ -1,284 +0,0 @@
//////////////////////////////////////////////////////////////////////////////////////////
//
// Licensetype: GNU General Public License (GPL)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
//
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
//
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//
//////////////////////////////////////////////////////////////////////////////////////////
#include "../Globals.h" // this is the precompiled header and must be the first ...
// ---------------------------------------------------------------------------------------
// Includes
// -------------
#include <iostream>
#include <vector>
#include <string> // so that we can test std::string == abc
#include <math.h> // for the pow() function
#ifdef _WIN32
#include <windows.h>
#endif
#include "../GLUtil.h"
#if defined(HAVE_WX) && HAVE_WX
#include "../Debugger/Debugger.h" // for the CDebugger class
#include "../Debugger/PBView.h"
#include "Console.h" // open and close console, clear console window
#endif
#include "../Logging/Logging.h" // for global logging values
// ---------------------------------------------------------------------------------------
// Externals
// -------------
extern int nFiles;
float ratioFactor; // a global to get the ratio factor from MixAdd
int gPreset = 0;
u32 gLastBlock;
extern bool gSSBM;
extern bool gSSBMremedy1;
extern bool gSSBMremedy2;
extern bool gSequenced;
extern bool gReset;
bool gOnlyLooping = false;
extern int gSaveFile;
//extern int gleft, gright, gtop, gbottom; // from BPStructs.cpp
// ---------------------------------------------------------------------------------------
// Counters
// -------------
int j = 0;
int k = 0;
bool iupdonce = false;
std::vector<u16> viupd(15); // the length of the update frequency bar
// ---------------------------------------------------------------------------------------
// Classes
// -------------
#if defined(HAVE_WX) && HAVE_WX
extern CDebugger* m_frame;
#endif
// =======================================================================================
// Write title
// --------------
std::string writeTitle(int a)
{
std::string b;
if(a == 0)
{
b = "lef rig top bot | wid hei\n";
}
return b;
}
// =======================================================================================
// =======================================================================================
// Write main message (presets)
// --------------
std::string writeMessage(int a, int i)
{
char buf [1000] = "";
std::string sbuf;
// =======================================================================================
// PRESETS
// ---------------------------------------------------------------------------------------
/*
PRESET 0
"lef rig top bot | xof yof\n";
"000 000 000 000 | 000 00
*/
if(a == 0)
{
sprintf(buf,"%03i %03i %03i %03i | %03i %03i",
0, OpenGL_GetWidth(), OpenGL_GetHeight(), 0,
OpenGL_GetXoff(), OpenGL_GetYoff());
}
sbuf = buf;
return sbuf;
}
// =======================================================================================
// Logging
void Logging(int a)
{
// =======================================================================================
// Update parameter values
// --------------
// AXPB base
// ==============
// ---------------------------------------------------------------------------------------
// Write to file
// --------------
for (int ii = 0; ii < nFiles; ii++)
{
std::string sfbuff;
sfbuff = sfbuff + writeMessage(ii, 0);
#if defined(HAVE_WX) && HAVE_WX
aprintf(ii, (char *)sfbuff.c_str());
#endif
}
// --------------
// =======================================================================================
// Control how often the screen is updated, and then update the screen
// --------------
if(a == 0) j++;
//if(l == pow((double)2,32)) l=0; // reset l
//l++;
if (m_frame->gUpdFreq > 0 && j > (30 / m_frame->gUpdFreq))
{
// =======================================================================================
// Write header
// --------------
char buffer [1000] = "";
std::string sbuff;
sbuff = writeTitle(gPreset);
// ==============
// hopefully this is false if we don't have a debugging window and so it doesn't cause a crash
/* // nothing do do here yet
if(m_frame)
{
m_frame->m_GPRListView->m_CachedRegs[1][0] = 0;
}
*/
// add new line
sbuff = sbuff + writeMessage(gPreset, 0); strcpy(buffer, "");
sbuff = sbuff + "\n";
// =======================================================================================
// Write global values
// ---------------
/*
sprintf(buffer, "\nThe parameter blocks span from %08x to %08x | distance %i %i\n", m_addressPBs, gLastBlock, (gLastBlock-m_addressPBs), (gLastBlock-m_addressPBs) / 192);
sbuff = sbuff + buffer; strcpy(buffer, "");
*/
// ===============
// =======================================================================================
// Write settings
// ---------------
/*
sprintf(buffer, "\nSettings: SSBM fix %i | SSBM rem1 %i | SSBM rem2 %i | Sequenced %i | Reset %i | Only looping %i | Save file %i\n",
gSSBM, gSSBMremedy1, gSSBMremedy2, gSequenced, gReset, gOnlyLooping, gSaveFile);
sbuff = sbuff + buffer; strcpy(buffer, "");
*/
// ===============
// =======================================================================================
// Show update frequency
// ---------------
sbuff = sbuff + "\n";
if(!iupdonce)
{
/*
for (int i = 0; i < 10; i++)
{
viupd.at(i) == 0;
}
*/
viupd.at(0) = 1;
viupd.at(1) = 1;
viupd.at(2) = 1;
iupdonce = true;
}
for (u32 i = 0; i < viupd.size(); i++) // 0, 1,..., 9
{
if (i < viupd.size()-1)
{
viupd.at(viupd.size()-i-1) = viupd.at(viupd.size()-i-2); // move all forward
}
else
{
viupd.at(0) = viupd.at(viupd.size()-1);
}
// Correction
if (viupd.at(viupd.size()-3) == 1 && viupd.at(viupd.size()-2) == 1 && viupd.at(viupd.size()-1) == 1)
{
viupd.at(0) = 0;
}
if(viupd.at(0) == 0 && viupd.at(1) == 1 && viupd.at(2) == 1 && viupd.at(3) == 0)
{
viupd.at(0) = 1;
}
}
for (u32 i = 0; i < viupd.size(); i++)
{
if(viupd.at(i) == 0)
sbuff = sbuff + " ";
else
sbuff = sbuff + ".";
}
// ================
// =======================================================================================
// Print
// ----------------
#if defined(HAVE_WX) && HAVE_WX
ClearScreen();
#endif
__Log("%s", sbuff.c_str());
sbuff.clear(); strcpy(buffer, "");
// ================
// New values are written so update - DISABLED - It flickered a lot, even worse than a
// console window. So for now only the console windows is updated.
/*
if(m_frame)
{
m_frame->NotifyUpdate();
}
*/
k=0;
j=0;
} // end of if (j>20)
} // end of function

21
Source/Plugins/Plugin_VideoOGL/Src/Logging/Logging.h
View File

@ -1,21 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
// functions
void Logging(int a);

7
Source/Plugins/Plugin_VideoOGL/Src/OS/Win32.cpp
View File

@ -65,7 +65,7 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{ //use wxInitialize() if you don't want GUI instead of the following 12 lines
{ // Use wxInitialize() if you don't want GUI instead of the following 12 lines
wxSetInstance((HINSTANCE)hinstDLL);
int argc = 0;
char **argv = NULL;
@ -76,8 +76,7 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
break;
case DLL_PROCESS_DETACH:
CloseConsole();
wxEntryCleanup(); //use wxUninitialize() if you don't want GUI
wxEntryCleanup(); // Use wxUninitialize() if you don't want GUI
break;
default:
break;
@ -374,4 +373,4 @@ namespace EmuWindow
}
} // EmuWindow
////////////////////////////////////
////////////////////////////////////

21
Source/Plugins/Plugin_VideoOGL/Src/Render.cpp
View File

@ -15,6 +15,10 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// -------------
#include "Globals.h"
#include <list>
#include <vector>
@ -45,17 +49,22 @@
#include "VertexLoader.h"
#include "XFB.h"
#include "Timer.h"
#include "Logging/Logging.h" // for Logging()
#include "Debugger/Logging.h" // for Logging()
#if defined(HAVE_WX) && HAVE_WX
#include "Debugger/Debugger.h" // for the CDebugger class
#include "Debugger/Debugger.h" // for the CDebugger class
#endif
#ifdef _WIN32
#include "OS/Win32.h"
#include "OS/Win32.h"
#else
#endif
/////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Declarations and definitions
// -------------
struct MESSAGE
{
MESSAGE() {}
@ -69,7 +78,7 @@ CGprofile g_cgvProf;
CGprofile g_cgfProf;
#if defined(HAVE_WX) && HAVE_WX
extern CDebugger* m_frame; // the debugging class
extern CDebugger* m_frame; // the debugging class
#endif
static RasterFont* s_pfont = NULL;
@ -96,6 +105,8 @@ bool g_bBlendLogicOp = false;
int frameCount;
void HandleCgError(CGcontext ctx, CGerror err, void *appdata);
/////////////////////////////
bool Renderer::Init()
{
@ -1122,4 +1133,4 @@ void UpdateViewport()
}
glDepthRange((xfregs.rawViewport[5]- xfregs.rawViewport[2])/16777215.0f, xfregs.rawViewport[5]/16777215.0f);
}
}

3
Source/Plugins/Plugin_VideoOGL/Src/SConscript
View File

@ -53,8 +53,7 @@ if gfxenv['HAVE_WX']:
'GUI/ConfigDlg.cpp',
'Debugger/Debugger.cpp',
'Debugger/PBView.cpp',
'Logging/Console.cpp',
'Logging/Logging.cpp',
'Debugger/Logging.cpp',
]
if gfxenv['HAVE_COCOA']:

6
Source/Plugins/Plugin_Wiimote/Plugin_Wiimote.vcproj
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Version="9,00"
Name="Plugin_Wiimote"
ProjectGUID="{8D612734-FAA5-4B8A-804F-4DEA2367D495}"
RootNamespace="Plugin_Wiimote"
@ -527,11 +527,11 @@
Name="Debugging"
>
<File
RelativePath=".\Src\Console.cpp"
RelativePath=".\Src\Logging.cpp"
>
</File>
<File
RelativePath=".\Src\Console.h"
RelativePath=".\Src\Logging.h"
>
</File>
</Filter>

268
Source/Plugins/Plugin_Wiimote/Src/Console.cpp
View File

@ -1,268 +0,0 @@
// Copyright (C) 2003-2008 Dolphin Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
//
#include <string>
#include <stdio.h>
#ifdef _WIN32
#include <windows.h>
#endif
#include "StringUtil.h"
#define HAVE_WX 1
#if defined(HAVE_WX) && HAVE_WX // wxWidgets
#include <wx/datetime.h> // for the timestamps
#endif
///////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
// Settings
//
// On and off
bool g_consoleEnable = true;
bool gSaveFile = true;
#define DEBUG_WIIMOTE // On or off
const int nFiles = 1;
// Create handles
#ifdef DEBUG_WIIMOTE
FILE* __fStdOut[nFiles];
#endif
#ifdef _WIN32
HANDLE __hStdOut = NULL;
#endif
//////////////////////////////
// =======================================================================================
/* Get Timestamp */
// -------------
std::string Tm(bool Ms)
{
#if defined(HAVE_WX) && HAVE_WX
std::string Tmp;
if(Ms)
{
wxDateTime datetime = wxDateTime::UNow(); // Get timestamp
Tmp = StringFromFormat("%02i:%02i:%03i",
datetime.GetMinute(), datetime.GetSecond(), datetime.GetMillisecond());
}
else
{
wxDateTime datetime = wxDateTime::Now(); // Get timestamp
Tmp = StringFromFormat("%02i:%02i",
datetime.GetMinute(), datetime.GetSecond());
}
return Tmp;
#else
std::string Tmp = "";
return Tmp;
#endif
}
// ===========================
// =======================================================================================
/* Start console window - width and height is the size of console window, if you specify
fname, the output will also be written to this file. TODO: Close the file pointer when the app
is closed */
// -------------
void startConsoleWin(int width, int height, char* fname)
{
#if defined(DEBUG_WIIMOTE) && defined(_WIN32)
AllocConsole();
SetConsoleTitle(fname);
__hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD co = {width,height};
SetConsoleScreenBufferSize(__hStdOut, co);
SMALL_RECT coo = {0,0,(width - 1),70}; // top, left, right, bottom
SetConsoleWindowInfo(__hStdOut, TRUE, &coo);
// ---------------------------------------------------------------------------------------
// Create a file for this
if(fname)
{
for(int i = 0; i < nFiles; i++)
{
// Edit the log file name
std::string FileEnding = ".log";
std::string FileName = fname;
char buffer[33]; _itoa(i, buffer, 10); // convert number to string
std::string FullFilename = (FileName + buffer + FileEnding);
__fStdOut[i] = fopen(FullFilename.c_str(), "w");
}
}
// ---------------
#endif
}
// ---------------------------------------------------------------------------------------
// File printf function
int aprintf(int a, char *fmt, ...)
{
#if defined(DEBUG_WIIMOTE) && defined(_WIN32)
if(gSaveFile)
{
char s[500]; // WARNING: mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 500, fmt, argptr); // remember to update this value to
va_end(argptr);
// ---------------------------------------------------------------------------------------
if(__fStdOut[a]) // TODO: make this work, we have to set all default values to NULL
//to make it work
fprintf(__fStdOut[a], s);
fflush(__fStdOut[0]); // Write file now, don't wait
// -------------
return(cnt);
}
else
{
return 0;
}
#else
return 0;
#endif
}
// ---------------------------------------------------------------------------------------
// Printf to screen function
int wprintf(const char *fmt, ...)
{
#if defined(DEBUG_WIIMOTE) && defined(_WIN32)
char s[500]; // WARNING: mind this value
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsnprintf(s, 500, fmt, argptr);
va_end(argptr);
DWORD cCharsWritten; // We will get a value back here
// ------------------------------------------
// Write to console
// ----------------
if(__hStdOut)
{
WriteConsole(__hStdOut, s, strlen(s), &cCharsWritten, NULL);
}
// ----------------------------------------
// Write to file
// ----------------
aprintf(0, s);
return(cnt);
#else
return 0;
#endif
}
// ---------------------------------------------------------------------------------------
// Clear console screen
void ClearScreen()
{
#if defined(_WIN32)
if(g_consoleEnable)
{
COORD coordScreen = { 0, 0 };
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize,
coordScreen, &cCharsWritten);
GetConsoleScreenBufferInfo(hConsole, &csbi);
FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize,
coordScreen, &cCharsWritten);
SetConsoleCursorPosition(hConsole, coordScreen);
}
#endif
}
// ---------------------------------------------------------------------------------------
// Get window handle of console window to be able to resize it
#if defined(_WIN32)
HWND GetConsoleHwnd(void)
{
#define MY_BUFSIZE 1024 // Buffer size for console window titles.
HWND hwndFound; // This is what is returned to the caller.
char pszNewWindowTitle[MY_BUFSIZE]; // Contains fabricated
// WindowTitle.
char pszOldWindowTitle[MY_BUFSIZE]; // Contains original
// WindowTitle.
// Fetch current window title.
GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);
// Format a "unique" NewWindowTitle.
wsprintf(pszNewWindowTitle,"%d/%d",
GetTickCount(),
GetCurrentProcessId());
// Change current window title.
SetConsoleTitle(pszNewWindowTitle);
// Ensure window title has been updated.
Sleep(40);
// Look for NewWindowTitle.
hwndFound = FindWindow(NULL, pszNewWindowTitle);
// Restore original window title.
SetConsoleTitle(pszOldWindowTitle);
return(hwndFound);
}
#endif // win32

14
Source/Plugins/Plugin_Wiimote/Src/DataReports.cpp
View File

@ -63,7 +63,7 @@
#include "EmuSubroutines.h"
#include "EmuDefinitions.h"
#include "Encryption.h" // for extension encryption
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
#include "Config.h" // for g_Config
///////////////////////////////////
@ -91,8 +91,8 @@ void WmDataReporting(u16 _channelID, wm_data_reporting* dr)
LOG(WII_IPC_WIIMOTE, " Continuous: %x", dr->continuous);
LOG(WII_IPC_WIIMOTE, " All The Time: %x (not only on data change)", dr->all_the_time);
LOG(WII_IPC_WIIMOTE, " Mode: 0x%02x", dr->mode);
//wprintf("Data reporting mode: 0x%02x\n", dr->mode);
//wprintf("Data reporting channel: 0x%04x\n", _channelID);
//Console::Print("Data reporting mode: 0x%02x\n", dr->mode);
//Console::Print("Data reporting channel: 0x%04x\n", _channelID);
g_ReportingMode = dr->mode;
g_ReportingChannel = _channelID;
@ -159,7 +159,7 @@ void SendReportCoreAccel(u16 _channelID)
/*if(GetAsyncKeyState('V'))
{
std::string Temp = WiiMoteEmu::ArrayToString(DataFrame, Offset, 0, 30);
wprintf("DataFrame: %s\n", Temp.c_str());
Console::Print("DataFrame: %s\n", Temp.c_str());
}*/
#endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
@ -191,7 +191,7 @@ void SendReportCoreAccelIr12(u16 _channelID) {
/*if(GetAsyncKeyState('V'))
{
std::string Temp = WiiMoteEmu::ArrayToString(DataFrame, Offset, 0, 30);
wprintf("DataFrame: %s\n", Temp.c_str());
Console::Print("DataFrame: %s\n", Temp.c_str());
}*/
#endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
@ -239,7 +239,7 @@ void SendReportCoreAccelExt16(u16 _channelID)
/*if(GetAsyncKeyState('V'))
{
std::string Temp = WiiMoteEmu::ArrayToString(DataFrame, Offset, 0, 30);
wprintf("DataFrame: %s\n", Temp.c_str());
Console::Print("DataFrame: %s\n", Temp.c_str());
}*/
#endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
@ -284,7 +284,7 @@ void SendReportCoreAccelIr10Ext(u16 _channelID)
/*if(GetAsyncKeyState('V'))
{
std::string Temp = ArrayToString(DataFrame, Offset, 0, 30);
wprintf("DataFrame: %s\n", Temp.c_str());
Console::Print("DataFrame: %s\n", Temp.c_str());
}*/
#endif
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);

2
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.cpp
View File

@ -29,7 +29,7 @@
#include "wiimote_hid.h"
#include "EmuDefinitions.h"
#include "Encryption.h"
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
//////////////////////////
extern SWiimoteInitialize g_WiimoteInitialize;

4
Source/Plugins/Plugin_Wiimote/Src/EmuDefinitions.h
View File

@ -27,7 +27,7 @@
#include "wiimote_hid.h"
#include "Encryption.h"
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
extern SWiimoteInitialize g_WiimoteInitialize;
//extern void __Log(int log, const char *format, ...);
@ -158,4 +158,4 @@ static const u8 partially_id[] =
} // namespace
#endif //_EMU_DEFINITIONS_
#endif //_EMU_DEFINITIONS_

8
Source/Plugins/Plugin_Wiimote/Src/EmuMain.cpp
View File

@ -32,7 +32,7 @@
#include "EmuDefinitions.h"
#include "EmuMain.h"
#include "Encryption.h" // for extension encryption
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
#include "Config.h" // for g_Config
////////////////////////////////////
@ -184,7 +184,7 @@ void CheckAckDelay()
}
AckDelay.at(i).Delay--;
//wprintf("%i 0x%04x 0x%02x", i, AckDelay.at(i).ChannelID, AckDelay.at(i).ReportID);
//Console::Print("%i 0x%04x 0x%02x", i, AckDelay.at(i).ChannelID, AckDelay.at(i).ReportID);
}
}
}
@ -238,7 +238,7 @@ void InterruptChannel(u16 _channelID, const void* _pData, u32 _Size)
}
std::string Temp = ArrayToString(data, size + 2, 0, 30);
//LOGV(WII_IPC_WIIMOTE, 3, " Data: %s", Temp.c_str());
wprintf("\n%s: InterruptChannel: %s\n", Tm(true).c_str(), Temp.c_str());*/
Console::Print("\n%s: InterruptChannel: %s\n", Tm(true).c_str(), Temp.c_str());*/
// -----------------------------------
hid_packet* hidp = (hid_packet*) data;
@ -300,7 +300,7 @@ void ControlChannel(u16 _channelID, const void* _pData, u32 _Size)
{
LOG(WII_IPC_WIIMOTE, "Wiimote_ControlChannel");
std::string Temp = ArrayToString(data, 0, _Size);
wprintf("\n%s: ControlChannel: %s\n", Tm().c_str(), Temp.c_str());
Console::Print("\n%s: ControlChannel: %s\n", Tm().c_str(), Temp.c_str());
LOG(WII_IPC_WIIMOTE, " Data: %s", Temp.c_str());
}

44
Source/Plugins/Plugin_Wiimote/Src/EmuSubroutines.cpp
View File

@ -51,7 +51,7 @@
#include "EmuMain.h"
#include "EmuSubroutines.h"
#include "EmuDefinitions.h"
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
#include "Config.h" // for g_Config
/////////////////////////////////
@ -99,7 +99,7 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
case WM_REQUEST_STATUS: // 0x15
WmRequestStatus(_channelID, (wm_request_status*)sr->data);
//Temp = ArrayToString(sr->data, sizeof(wm_request_status), 0);
//wprintf("\n%s: InterruptChannel: %s\n", Tm().c_str(), Temp.c_str());
//Console::Print("\n%s: InterruptChannel: %s\n", Tm().c_str(), Temp.c_str());
break;
case WM_READ_DATA: // 0x17
WmReadData(_channelID, (wm_read_data*)sr->data);
@ -110,7 +110,7 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
case WM_IR_PIXEL_CLOCK: // 0x13
case WM_IR_LOGIC: // 0x1a
LOGV(WII_IPC_WIIMOTE, 0, " IR Enable 0x%02x: 0x%02x", sr->channel, sr->data[0]);
wprintf("IR Enable/Disable 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
Console::Print("IR Enable/Disable 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
if(sr->data[0] == 0x02) g_IR = 0;
else if(sr->data[0] == 0x06) g_IR = 1;
break;
@ -120,13 +120,13 @@ void HidOutputReport(u16 _channelID, wm_report* sr) {
break;
case WM_SPEAKER_ENABLE: // 0x14
LOGV(WII_IPC_WIIMOTE, 1, " WM Speaker Enable 0x%02x: 0x%02x", sr->channel, sr->data[0]);
wprintf("Speaker Enable/Disable 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
Console::Print("Speaker Enable/Disable 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
if(sr->data[0] == 0x02) g_Speaker = 0;
else if(sr->data[0] == 0x06) g_Speaker = 1;
break;
case WM_SPEAKER_MUTE:
LOGV(WII_IPC_WIIMOTE, 1, " WM Mute Enable 0x%02x: 0x%02x", sr->channel, sr->data[0]);
wprintf("Speaker Mute/Unmute 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
Console::Print("Speaker Mute/Unmute 0x%02x: 0x%02x\n", sr->channel, sr->data[0]);
if(sr->data[0] == 0x02) g_SpeakerVoice = 0; // g_SpeakerVoice
else if(sr->data[0] == 0x06) g_SpeakerVoice = 1;
break;
@ -198,13 +198,13 @@ void WmSendAck(u16 _channelID, u8 _reportID, u32 address)
LOGV(WII_IPC_WIIMOTE, 2, " Report ID: %02x", _reportID);
//std::string Temp = ArrayToString(DataFrame, Offset, 0);
//LOGV(WII_IPC_WIIMOTE, 2, " Data: %s", Temp.c_str());
//wprintf("%s: WMSendAck: %s\n", Tm(true).c_str(), Temp.c_str());
//Console::Print("%s: WMSendAck: %s\n", Tm(true).c_str(), Temp.c_str());
/* Debug. Write the report for extension registry writes.
if((_reportID == 0x16 || _reportID == 0x17) && ((address >> 16) & 0xfe) == 0xa4)
{
wprintf("\nWMSendAck Report ID: %02x Encryption: %02x\n", _reportID, g_RegExt[0xf0]);
wprintf("Data: %s\n", Temp.c_str());
Console::Print("\nWMSendAck Report ID: %02x Encryption: %02x\n", _reportID, g_RegExt[0xf0]);
Console::Print("Data: %s\n", Temp.c_str());
}*/
g_WiimoteInitialize.pWiimoteInput(_channelID, DataFrame, Offset);
@ -252,7 +252,7 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xa2: g_RegSpeaker");
//Tmp = ArrayToString(g_RegSpeaker, size, (address & 0xffff));
//LOGV(WII_IPC_WIIMOTE, 0, " Data: %s", Temp.c_str());
//wprintf("Read RegSpkr: Size %i Address %08x Offset %08x\nData %s\n",
//Console::Print("Read RegSpkr: Size %i Address %08x Offset %08x\nData %s\n",
// size, address, (address & 0xffff), Tmp.c_str());
break;
case 0xA4:
@ -261,7 +261,7 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xa4: Read ExtReg ****************************");
//Tmp = ArrayToString(g_RegExt, size, (address & 0xffff));
//LOGV(WII_IPC_WIIMOTE, 0, " Data: %s", Temp.c_str());
//wprintf("Read RegExt: Size %i Address %08x Offset %08x\nData %s\n",
//Console::Print("Read RegExt: Size %i Address %08x Offset %08x\nData %s\n",
// size, address, (address & 0xffff), Tmp.c_str());
break;
case 0xB0:
@ -270,7 +270,7 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
LOGV(WII_IPC_WIIMOTE, 0, " Case: 0xb0 g_RegIr");
//Tmp = ArrayToString(g_RegIr, size, (address & 0xffff));
//LOGV(WII_IPC_WIIMOTE, 0, " Data: %s", Temp.c_str());
//wprintf("Read RegIR: Size %i Address %08x Offset %08x\nData %s\n",
//Console::Print("Read RegIR: Size %i Address %08x Offset %08x\nData %s\n",
// size, address, (address & 0xffff), Tmp.c_str());
break;
default:
@ -285,12 +285,12 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
if(((address >> 16) & 0xfe) == 0xa4)
{
/* Debugging
wprintf("\n\nWmReadData Address: %08x Offset: %08x Size: %i byte\n",
Console::Print("\n\nWmReadData Address: %08x Offset: %08x Size: %i byte\n",
address, address & 0xffff, (u8)size);
// Debugging
u32 offset = address & 0xffff;
std::string Temp = ArrayToString(g_RegExt, size, offset);
wprintf("Unencrypted data:\n%s\n", Temp.c_str());*/
Console::Print("Unencrypted data:\n%s\n", Temp.c_str());*/
// Check if encrypted reads is on
if(g_RegExt[0xf0] == 0xaa)
@ -304,7 +304,7 @@ void WmReadData(u16 _channelID, wm_read_data* rd)
/* Debugging: Show the encrypted data
std::string Temp = ArrayToString(g_RegExtTmp, size, offset);
wprintf("Encrypted data:\n%s\n", Temp.c_str());*/
Console::Print("Encrypted data:\n%s\n", Temp.c_str());*/
// Update the block that SendReadDataReply will eventually send to the Wii
block = g_RegExtTmp;
@ -372,9 +372,9 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
block = g_RegSpeaker;
blockSize = WIIMOTE_REG_SPEAKER_SIZE;
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xa2: RegSpeaker");
//wprintf("Write RegSpeaker: Size: %i, Address: %08x, Offset: %08x\n",
//Console::Print("Write RegSpeaker: Size: %i, Address: %08x, Offset: %08x\n",
// wd->size, address, (address & 0xffff));
//wprintf("Data: %s\n", Temp.c_str());
//Console::Print("Data: %s\n", Temp.c_str());
break;
case 0xA4:
block = g_RegExt; // Extension Controller register
@ -382,17 +382,17 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
//LOGV(WII_IPC_WIIMOTE, 0, " *******************************************************");
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xa4: ExtReg");
//LOGV(WII_IPC_WIIMOTE, 0, " *******************************************************");
/*wprintf("Write RegExt Size: %i Address: %08x Offset: %08x \n",
/*Console::Print("Write RegExt Size: %i Address: %08x Offset: %08x \n",
wd->size, address, (address & 0xffff));
wprintf("Data: %s\n", Temp.c_str());*/
Console::Print("Data: %s\n", Temp.c_str());*/
break;
case 0xB0:
block = g_RegIr;
blockSize = WIIMOTE_REG_IR_SIZE;
LOGV(WII_IPC_WIIMOTE, 0, " Case 0xb0: RegIr");
/*wprintf("Write RegIR Size: %i Address: %08x Offset: %08x \n",
/*Console::Print("Write RegIR Size: %i Address: %08x Offset: %08x \n",
wd->size, address, (address & 0xffff));
wprintf("Data: %s\n", Temp.c_str());*/
Console::Print("Data: %s\n", Temp.c_str());*/
break;
default:
PanicAlert("WmWriteData: bad register block!");
@ -419,8 +419,8 @@ void WmWriteData(u16 _channelID, wm_write_data* wd)
if(blockSize == WIIMOTE_REG_EXT_SIZE)
{
/* Debugging. Write the data.
wprintf("Data: %s\n", Temp.c_str());
wprintf("Current address: %08x\n", address); */
Console::Print("Data: %s\n", Temp.c_str());
Console::Print("Current address: %08x\n", address); */
/* Run the key generation on all writes in the key area, it doesn't matter
that we send it parts of a key, only the last full key will have an

2
Source/Plugins/Plugin_Wiimote/Src/EmuSubroutines.h
View File

@ -32,7 +32,7 @@
#include "wiimote_hid.h" // Local
#include "EmuDefinitions.h"
#include "Encryption.h"
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
////////////////////////////

16
Source/Plugins/Plugin_Wiimote/Src/Encryption.cpp
View File

@ -19,7 +19,7 @@
#include "pluginspecs_wiimote.h"
#include "Common.h"
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // for startConsoleWin, Console::Print, GetConsoleHwnd
#include "Encryption.h"
@ -262,8 +262,8 @@ void wiimote_gen_key(wiimote_key *key, u8 *keydata)
for(int i=0;i<6;i++)
skey[5-i] = keydata[i+10];
wprintf("rand: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", rand[0], rand[1], rand[2], rand[3], rand[4], rand[5], rand[6], rand[7], rand[8], rand[9]);
wprintf("key: %02x %02x %02x %02x %02x %02x\n", skey[0], skey[1], skey[2], skey[3], skey[4], skey[5]);
Console::Print("rand: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", rand[0], rand[1], rand[2], rand[3], rand[4], rand[5], rand[6], rand[7], rand[8], rand[9]);
Console::Print("key: %02x %02x %02x %02x %02x %02x\n", skey[0], skey[1], skey[2], skey[3], skey[4], skey[5]);
for(idx=0;idx<7;idx++)
{
@ -272,12 +272,12 @@ void wiimote_gen_key(wiimote_key *key, u8 *keydata)
break;
}
// default case is idx = 7 which is valid (homebrew uses it for the 0x17 case)
wprintf("idx: %d\n", idx);
Console::Print("idx: %d\n", idx);
gentabs(rand, skey, idx, key->ft, key->sb);
wprintf("ft: %02x %02x %02x %02x %02x %02x %02x %02x\n", key->ft[0], key->ft[1], key->ft[2], key->ft[3], key->ft[4], key->ft[5], key->ft[6], key->ft[7]);
wprintf("sb: %02x %02x %02x %02x %02x %02x %02x %02x\n", key->sb[0], key->sb[1], key->sb[2], key->sb[3], key->sb[4], key->sb[5], key->sb[6], key->sb[7]);
Console::Print("ft: %02x %02x %02x %02x %02x %02x %02x %02x\n", key->ft[0], key->ft[1], key->ft[2], key->ft[3], key->ft[4], key->ft[5], key->ft[6], key->ft[7]);
Console::Print("sb: %02x %02x %02x %02x %02x %02x %02x %02x\n", key->sb[0], key->sb[1], key->sb[2], key->sb[3], key->sb[4], key->sb[5], key->sb[6], key->sb[7]);
// for homebrew, ft and sb are all 0x97 which is equivalent to 0x17
}
@ -290,8 +290,8 @@ void wiimote_encrypt(wiimote_key *key, u8 *data, int addr, u8 len)
{
for(int i = 0; i < len; i++, addr++)
{
//wprintf("data[%i] from %02x ", i, data[i]);
//Console::Print("data[%i] from %02x ", i, data[i]);
data[i] = (data[i] - key->ft[addr%8]) ^ key->sb[addr%8];
//wprintf("to %02x\n", data[i]);
//Console::Print("to %02x\n", data[i]);
}
}

18
Source/Plugins/Plugin_Wiimote/Src/FillReport.cpp
View File

@ -32,7 +32,7 @@
#include "EmuMain.h"
#include "EmuSubroutines.h"
#include "EmuDefinitions.h"
#include "Console.h" // For startConsoleWin, wprintf, GetConsoleHwnd
#include "Logging.h" // For startConsoleWin, Console::Print, GetConsoleHwnd
#include "Config.h" // For g_Config
//////////////////////////////////
@ -271,13 +271,13 @@ void FillReportAcc(wm_accel& _acc)
//if(consoleDisplay == 0)
wprintf("x: %03i | y: %03i | z: %03i | A:%i B:%i C:%i a:%i b:%i c:%i d:%i X:%i Y:%i Z:%i\n",
Console::Print("x: %03i | y: %03i | z: %03i | A:%i B:%i C:%i a:%i b:%i c:%i d:%i X:%i Y:%i Z:%i\n",
_acc.x, _acc.y, _acc.z,
A, B, C,
a, b, c, d,
X, Y, Z
);
wprintf("x: %03i | y: %03i | z: %03i | X:%i Y:%i Z:%i | AX:%i AY:%i AZ:%i \n",
Console::Print("x: %03i | y: %03i | z: %03i | X:%i Y:%i Z:%i | AX:%i AY:%i AZ:%i \n",
_acc.x, _acc.y, _acc.z,
X, Y, Z,
AX, AY, AZ
@ -358,11 +358,11 @@ void FillReportIR(wm_ir_extended& _ir0, wm_ir_extended& _ir1)
//ClearScreen();
//if(consoleDisplay == 1)
wprintf("x0:%03i x1:%03i y0:%03i y1:%03i irx0:%03i y0:%03i x1:%03i y1:%03i | T:%i L:%i R:%i B:%i S:%i\n",
Console::Print("x0:%03i x1:%03i y0:%03i y1:%03i irx0:%03i y0:%03i x1:%03i y1:%03i | T:%i L:%i R:%i B:%i S:%i\n",
x0, x1, y0, y1, _ir0.x, _ir0.y, _ir1.x, _ir1.y, Top, Left, Right, Bottom, SensorBarRadius
);
wprintf("\n");
wprintf("ir0.x:%02x xHi:%02x ir1.x:%02x xHi:%02x | ir0.y:%02x yHi:%02x ir1.y:%02x yHi:%02x | 1.s:%02x 2:%02x\n",
Console::Print("\n");
Console::Print("ir0.x:%02x xHi:%02x ir1.x:%02x xHi:%02x | ir0.y:%02x yHi:%02x ir1.y:%02x yHi:%02x | 1.s:%02x 2:%02x\n",
_ir0.x, _ir0.xHi, _ir1.x, _ir1.xHi,
_ir0.y, _ir0.yHi, _ir1.y, _ir1.yHi,
_ir0.size, _ir1.size
@ -445,11 +445,11 @@ void FillReportIRBasic(wm_ir_basic& _ir0, wm_ir_basic& _ir1)
//ClearScreen();
//if(consoleDisplay == 1)
wprintf("x1:%03i x2:%03i y1:%03i y2:%03i irx1:%02x y1:%02x x2:%02x y2:%02x | T:%i L:%i R:%i B:%i S:%i\n",
Console::Print("x1:%03i x2:%03i y1:%03i y2:%03i irx1:%02x y1:%02x x2:%02x y2:%02x | T:%i L:%i R:%i B:%i S:%i\n",
x1, x2, y1, y2, _ir0.x1, _ir0.y1, _ir1.x2, _ir1.y2, Top, Left, Right, Bottom, SensorBarRadius
);
wprintf("\n");
wprintf("ir0.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir0.y1:%02x y1h:%02x y2:%02x y2h:%02x | ir1.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir1.y1:%02x y1h:%02x y2:%02x y2h:%02x\n",
Console::Print("\n");
Console::Print("ir0.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir0.y1:%02x y1h:%02x y2:%02x y2h:%02x | ir1.x1:%02x x1h:%02x x2:%02x x2h:%02x | ir1.y1:%02x y1h:%02x y2:%02x y2h:%02x\n",
_ir0.x1, _ir0.x1Hi, _ir0.x2, _ir0.x2Hi,
_ir0.y1, _ir0.y1Hi, _ir0.y2, _ir0.y2Hi,
_ir1.x1, _ir1.x1Hi, _ir1.x2, _ir1.x2Hi,

2
Source/Plugins/Plugin_Wiimote/Src/SConscript
View File

@ -18,7 +18,7 @@ files = [
if wmenv['HAVE_WX']:
files += [
"ConfigDlg.cpp",
"Console.cpp",
"Logging.cpp",
"FillReport.cpp",
]

33
Source/Plugins/Plugin_Wiimote/Src/main.cpp
View File

@ -19,9 +19,10 @@
//////////////////////////////////////////////////////////////////////////////////////////
// Includes
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#include "Common.h"
#include "Common.h" // Common
#include "Config.h"
#include "StringUtil.h"
#include "ConsoleWindow.h" // For Start, Print, GetHwnd
#if defined(HAVE_WX) && HAVE_WX
#include <wx/aboutdlg.h>
@ -35,8 +36,6 @@
#if HAVE_WIIUSE
#include "wiimote_real.h"
#endif
#include "Console.h" // for startConsoleWin, wprintf, GetConsoleHwnd
///////////////////////////////////
@ -144,25 +143,25 @@ extern "C" void Initialize(void *init)
// ----------------------------------------
// Debugging window
// ----------
/*startConsoleWin(100, 750, "Wiimote"); // give room for 20 rows
wprintf("Wiimote console opened\n");
/*Console::Open(100, 750, "Wiimote"); // give room for 20 rows
Console::Print("Wiimote console opened\n");
// Move window, TODO: make this
//MoveWindow(GetConsoleHwnd(), 0,400, 100*8,10*14, true); // small window
MoveWindow(GetConsoleHwnd(), 400,0, 100*8,70*14, true); // big window*/
// Move window
//MoveWindow(Console::GetHwnd(), 0,400, 100*8,10*14, true); // small window
MoveWindow(Console::GetHwnd(), 400,0, 100*8,70*14, true); // big window*/
// ---------------
g_WiimoteInitialize = _WiimoteInitialize;
/* We will run WiiMoteReal::Initialize() even if we are not using a
real wiimote, we will initiate wiiuse.dll, but we will return before
creating a new thread for it if we find no real Wiimotes. Then
g_UseRealWiiMote will also be false This function call will be done
instantly if there is no real Wiimote connected. I'm not sure how
long time it takes if a Wiimote is connected. */
#if HAVE_WIIUSE
g_UseRealWiiMote = WiiMoteReal::Initialize() > 0;
#endif
/* We will run WiiMoteReal::Initialize() even if we are not using a real wiimote,
to check if there is a real wiimote connected. We will initiate wiiuse.dll, but
we will return before creating a new thread for it if we find no real Wiimotes.
Then g_UseRealWiiMote will also be false. This function call will be done
instantly if there is no real Wiimote connected. I'm not sure how long time
it takes if a Wiimote is connected. */
#if HAVE_WIIUSE
g_UseRealWiiMote = WiiMoteReal::Initialize() > 0;
#endif
g_Config.Load(); // load config settings
WiiMoteEmu::Initialize();