Initial megacommit.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4 8ced0084-cf51-0410-be5f-012b33b47a6e

Source/Plugins/Plugin_DSP_LLE/Src/DSoundStream.cpp

@@ -0,0 +1,280 @@
+// 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/
+
+#include "stdafx.h"
+
+#include <mmsystem.h>
+#include <dsound.h>
+
+#include "dsoundstream.h"
+
+namespace DSound
+{
+#define BUFSIZE 32768
+#define MAXWAIT 70   //ms
+
+//THE ROCK SOLID SYNCED DSOUND ENGINE :)
+
+
+//v<>ran kritiska sektion och v<>r syncevent-handle
+CRITICAL_SECTION soundCriticalSection;
+HANDLE soundSyncEvent;
+HANDLE hThread;
+
+StreamCallback callback;
+
+//lite mojs
+IDirectSound8* ds;
+IDirectSoundBuffer* dsBuffer;
+
+//tja.. beh<65>vs
+int bufferSize; //i bytes
+int totalRenderedBytes;
+int sampleRate;
+
+//med den h<>r synkar vi st<73>ngning..
+//0=vi spelar ov<6F>sen, 1=st<73>ng tr<74>den NU! 2=japp,tr<74>den <20>r st<73>ngd s<> forts<74>tt
+volatile int threadData;
+
+
+//ser till s<> X kan delas med 32
+inline int FIX32(int x)
+{
+	return(x & (~127));
+}
+
+
+int DSound_GetSampleRate()
+{
+	return(sampleRate);
+}
+
+
+//Dags att skapa v<>r directsound buffert
+bool createBuffer()
+{
+	PCMWAVEFORMAT pcmwf;
+	DSBUFFERDESC dsbdesc;
+
+	//ljudformatet
+	memset(&pcmwf, 0, sizeof(PCMWAVEFORMAT));
+	memset(&dsbdesc, 0, sizeof(DSBUFFERDESC));
+
+	pcmwf.wf.wFormatTag = WAVE_FORMAT_PCM;
+	pcmwf.wf.nChannels = 2;
+	pcmwf.wf.nSamplesPerSec = sampleRate;
+	pcmwf.wf.nBlockAlign = 4;
+	pcmwf.wf.nAvgBytesPerSec = pcmwf.wf.nSamplesPerSec * pcmwf.wf.nBlockAlign;
+	pcmwf.wBitsPerSample = 16;
+
+	//buffer description
+	dsbdesc.dwSize  = sizeof(DSBUFFERDESC);
+	dsbdesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_STICKYFOCUS; //VIKTIGT //DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY;
+	dsbdesc.dwBufferBytes = bufferSize = BUFSIZE; //FIX32(pcmwf.wf.nAvgBytesPerSec);   //<2F>ndra f<>r att st<73>lla in bufferstorlek
+	dsbdesc.lpwfxFormat = (WAVEFORMATEX*)&pcmwf;
+	// nu skapar vi bufferj<72>veln
+
+	if (SUCCEEDED(ds->CreateSoundBuffer(&dsbdesc, &dsBuffer, NULL)))
+	{
+		dsBuffer->SetCurrentPosition(0);
+		return(true);
+	}
+	else
+	{
+		// Failed.
+		dsBuffer = NULL;
+		return(false);
+	}
+}
+
+
+bool writeDataToBuffer(DWORD dwOffset,              // Our own write cursor.
+		char* soundData, // Start of our data.
+		DWORD dwSoundBytes) // Size of block to copy.
+{
+	void* ptr1, * ptr2;
+	DWORD numBytes1, numBytes2;
+	// Obtain memory address of write block. This will be in two parts if the block wraps around.
+	HRESULT hr = dsBuffer->Lock(dwOffset, dwSoundBytes, &ptr1, &numBytes1, &ptr2, &numBytes2, 0);
+
+	// If the buffer was lost, restore and retry lock.
+
+	if (DSERR_BUFFERLOST == hr)
+	{
+		dsBuffer->Restore();
+		hr = dsBuffer->Lock(dwOffset, dwSoundBytes, &ptr1, &numBytes1, &ptr2, &numBytes2, 0);
+	}
+
+	if (SUCCEEDED(hr))
+	{
+		memcpy(ptr1, soundData, numBytes1);
+
+		if (ptr2 != 0)
+		{
+			memcpy(ptr2, soundData + numBytes1, numBytes2);
+		}
+
+		// Release the data back to DirectSound.
+		dsBuffer->Unlock(ptr1, numBytes1, ptr2, numBytes2);
+		return(true);
+	} /*
+        else
+        {
+        char temp[8];
+        sprintf(temp,"%i\n",hr);
+        OutputDebugString(temp);
+        }*/
+
+	return(false);
+}
+
+
+inline int ModBufferSize(int x)
+{
+	return((x + bufferSize) % bufferSize);
+}
+
+
+int currentPos;
+int lastPos;
+short realtimeBuffer[1024 * 1024];
+
+
+DWORD WINAPI soundThread(void*)
+{
+	currentPos = 0;
+	lastPos = 0;
+	//writeDataToBuffer(0,realtimeBuffer,bufferSize);
+	//  dsBuffer->Lock(0, bufferSize, (void **)&p1, &num1, (void **)&p2, &num2, 0);
+
+	dsBuffer->Play(0, 0, DSBPLAY_LOOPING);
+
+	while (!threadData)
+	{
+		EnterCriticalSection(&soundCriticalSection);
+
+		dsBuffer->GetCurrentPosition((DWORD*)&currentPos, 0);
+		int numBytesToRender = FIX32(ModBufferSize(currentPos - lastPos));
+
+		//renderStuff(numBytesToRender/2);
+		//if (numBytesToRender>bufferSize/2) numBytesToRender=0;
+
+		if (numBytesToRender >= 256)
+		{
+			(*callback)(realtimeBuffer, numBytesToRender >> 2, 16, 44100, 2);
+
+			writeDataToBuffer(lastPos, (char*)realtimeBuffer, numBytesToRender);
+
+			currentPos = ModBufferSize(lastPos + numBytesToRender);
+			totalRenderedBytes += numBytesToRender;
+
+			lastPos = currentPos;
+		}
+
+		LeaveCriticalSection(&soundCriticalSection);
+		WaitForSingleObject(soundSyncEvent, MAXWAIT);
+	}
+
+	dsBuffer->Stop();
+
+	threadData = 2;
+	return(0); //hurra!
+}
+
+
+bool DSound_StartSound(HWND window, int _sampleRate, StreamCallback _callback)
+{
+	callback   = _callback;
+	threadData = 0;
+	sampleRate = _sampleRate;
+
+	//no security attributes, automatic resetting, init state nonset, untitled
+	soundSyncEvent = CreateEvent(0, false, false, 0);
+
+	//vi initierar den...........
+	InitializeCriticalSection(&soundCriticalSection);
+
+	//vi vill ha access till DSOUND s<>...
+	if (FAILED(DirectSoundCreate8(0, &ds, 0)))
+	{
+		return(false);
+	}
+
+	//samarbetsvillig? n<><6E> :)
+	ds->SetCooperativeLevel(window, DSSCL_NORMAL); //DSSCL_PRIORITY?
+
+	//s<>.. skapa buffern
+	if (!createBuffer())
+	{
+		return(false);
+	}
+
+	//rensa den.. ?
+	DWORD num1;
+	short* p1;
+
+	dsBuffer->Lock(0, bufferSize, (void* *)&p1, &num1, 0, 0, 0);
+
+	memset(p1, 0, num1);
+	dsBuffer->Unlock(p1, num1, 0, 0);
+	totalRenderedBytes = -bufferSize;
+	DWORD h;
+	hThread = CreateThread(0, 0, soundThread, 0, 0, &h);
+	SetThreadPriority(hThread, THREAD_PRIORITY_ABOVE_NORMAL);
+	return(true);
+}
+
+
+void DSound_UpdateSound()
+{
+	SetEvent(soundSyncEvent);
+}
+
+
+void DSound_StopSound()
+{
+	EnterCriticalSection(&soundCriticalSection);
+	threadData = 1;
+	//kick the thread if it's waiting
+	SetEvent(soundSyncEvent);
+	LeaveCriticalSection(&soundCriticalSection);
+	WaitForSingleObject(hThread, INFINITE);
+	CloseHandle(hThread);
+
+	dsBuffer->Release();
+	ds->Release();
+
+	CloseHandle(soundSyncEvent);
+}
+
+
+int DSound_GetCurSample()
+{
+	EnterCriticalSection(&soundCriticalSection);
+	int playCursor;
+	dsBuffer->GetCurrentPosition((DWORD*)&playCursor, 0);
+	playCursor = ModBufferSize(playCursor - lastPos) + totalRenderedBytes;
+	LeaveCriticalSection(&soundCriticalSection);
+	return(playCursor);
+}
+
+
+float DSound_GetTimer()
+{
+	return((float)DSound_GetCurSample() * (1.0f / (4.0f * 44100.0f)));
+}
+}

Source/Plugins/Plugin_DSP_LLE/Src/DSoundStream.h

@@ -0,0 +1,35 @@
+// 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 __SOUNDSTREAM_H__
+#define __SOUNDSTREAM_H__
+
+namespace DSound
+{
+typedef void (*StreamCallback)(short* buffer, int numSamples, int bits, int rate, int channels);
+
+bool DSound_StartSound(HWND window, int sampleRate, StreamCallback _callback);
+void DSound_UpdateSound();
+void DSound_StopSound();
+
+float DSound_GetTimer();
+int DSound_GetCurSample();
+int DSound_GetSampleRate();
+}
+
+
+#endif //__SOUNDSTREAM_H__

Source/Plugins/Plugin_DSP_LLE/Src/DisAsmDlg.cpp

@@ -0,0 +1,637 @@
+// 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/
+
+#include "stdafx.h"
+#include "../res/resource.h"
+#include "DisAsmDlg.h"
+
+#include "gdsp_memory.h"
+#include "gdsp_interpreter.h"
+#include "disassemble.h"
+#include "RegSettings.h"
+
+CDisAsmDlg::CDisAsmDlg()
+	: m_CachedStepCounter(-1)
+	, m_CachedCR(-1)
+	, m_State(RUN)
+	, m_CachedUCodeCRC(-1)
+{}
+
+
+BOOL CDisAsmDlg::PreTranslateMessage(MSG* pMsg)
+{
+	return(IsDialogMessage(pMsg));
+}
+
+
+BOOL CDisAsmDlg::OnIdle()
+{
+	return(FALSE);
+}
+
+
+LRESULT CDisAsmDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+{
+	CWindowSettings ws;
+
+	if (ws.Load("Software\\Dolphin\\DSP", "DisAsm"))
+	{
+		ws.ApplyTo(CWindow(m_hWnd), SW_SHOW);
+	}
+
+	m_DisAsmListViewCtrl.m_hWnd = GetDlgItem(IDC_DISASM_LIST);
+
+	UIAddChildWindowContainer(m_hWnd);
+
+	m_DisAsmListViewCtrl.AddColumn(_T("BP"),     ColumnBP);
+	m_DisAsmListViewCtrl.AddColumn(_T("Function"),  ColumnFunction);
+	m_DisAsmListViewCtrl.AddColumn(_T("Address"),    ColumnAddress);
+	m_DisAsmListViewCtrl.AddColumn(_T("Menmomic"),   ColumnMenmomic);
+	m_DisAsmListViewCtrl.AddColumn(_T("Opcode"), ColumnOpcode);
+	m_DisAsmListViewCtrl.AddColumn(_T("Ext"),        ColumnExt);
+	m_DisAsmListViewCtrl.AddColumn(_T("Parameter"), ColumnParameter);
+
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnBP,           25);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnFunction,     160);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnAddress,      55);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnMenmomic,     55);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnOpcode,       60);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnExt,          40);
+	m_DisAsmListViewCtrl.SetColumnWidth(ColumnParameter,    500);
+
+	m_DisAsmListViewCtrl.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
+
+	m_RegisterDlg.Create(m_hWnd);
+
+	UpdateDialog();
+
+	return(TRUE);
+}
+
+
+LRESULT CDisAsmDlg::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+{
+	CWindowSettings ws;
+	ws.GetFrom(CWindow(m_hWnd));
+	ws.Save("Software\\Dolphin\\DSP", "DisAsm");
+
+	return(0);
+}
+
+
+LRESULT CDisAsmDlg::OnStep(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
+{
+	m_State = STEP;
+
+	UpdateButtonTexts();
+	return(0);
+}
+
+
+LRESULT CDisAsmDlg::OnGo(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
+{
+	if ((m_State == RUN) || (m_State == RUN_START))
+	{
+		m_State = PAUSE;
+	}
+	else
+	{
+		m_State = RUN_START;
+	}
+
+	UpdateButtonTexts();
+	return(0);
+}
+
+
+LRESULT CDisAsmDlg::OnShowRegisters(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
+{
+	if (m_RegisterDlg.IsWindowVisible())
+	{
+		m_RegisterDlg.ShowWindow(SW_HIDE);
+	}
+	else
+	{
+		m_RegisterDlg.ShowWindow(SW_SHOW);
+	}
+
+	UpdateButtonTexts();
+	return(0);
+}
+
+
+LRESULT CDisAsmDlg::OnDblClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+{
+	int Index = m_DisAsmListViewCtrl.GetSelectedIndex();
+
+	if (Index != -1)
+	{
+		uint16 SelectedPC = static_cast<uint16>(m_DisAsmListViewCtrl.GetItemData(Index));
+		ToggleBreakPoint(SelectedPC);
+	}
+
+	RedrawDisAsmListView();
+	return(0);
+}
+
+
+LRESULT CDisAsmDlg::OnRClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+{
+	int Index = m_DisAsmListViewCtrl.GetSelectedIndex();
+
+	if (Index != -1)
+	{
+		uint16 SelectedPC = static_cast<uint16>(m_DisAsmListViewCtrl.GetItemData(Index));
+		g_dsp.pc = SelectedPC;
+	}
+
+	RedrawDisAsmListView();
+	return(0);
+}
+
+
+void CDisAsmDlg::CloseDialog(int nVal)
+{
+	DestroyWindow();
+	::PostQuitMessage(nVal);
+}
+
+
+int CALLBACK CDisAsmDlg::CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+{
+	return(lParam1 > lParam2);
+}
+
+
+void CDisAsmDlg::RebuildDisAsmListView()
+{
+	m_DisAsmListViewCtrl.ShowWindow(SW_HIDE);
+	m_DisAsmListViewCtrl.DeleteAllItems();
+
+	char Buffer[256];
+	gd_globals_t gdg;
+
+	if (g_dsp.pc & 0x8000)
+	{
+		gdg.binbuf = g_dsp.irom;
+	}
+	else
+	{
+		gdg.binbuf = g_dsp.iram;
+	}
+
+	gdg.buffer = Buffer;
+	gdg.buffer_size   = 256;
+	gdg.ext_separator = (char)0xff;
+
+	gdg.show_pc      = false;
+	gdg.show_hex     = false;
+	gdg.print_tabs   = true;
+	gdg.decode_names = true;
+	gdg.decode_registers = true;
+
+	for (gdg.pc = 0; gdg.pc < DSP_IROM_SIZE;)
+	{
+		uint16 CurrentPC = gdg.pc;
+
+		if (g_dsp.pc & 0x8000)
+		{
+			CurrentPC |= 0x8000;
+		}
+
+		char Temp[256];
+		sprintf_s(Temp, 256, "0x%04x", CurrentPC);
+
+		char Temp2[256];
+		sprintf_s(Temp2, 256, "0x%04x", dsp_imem_read(CurrentPC));
+
+		char* pOpcode = gd_dis_opcode(&gdg);
+		const char* pParameter = NULL;
+		const char* pExtension = NULL;
+
+		size_t WholeString = strlen(pOpcode);
+
+		for (size_t i = 0; i < WholeString; i++)
+		{
+			if (pOpcode[i] == (char)0xff)
+			{
+				pOpcode[i] = 0x00;
+				pExtension = &pOpcode[i + 1];
+			}
+
+			if (pOpcode[i] == 0x09)
+			{
+				pOpcode[i] = 0x00;
+				pParameter = &pOpcode[i + 1];
+			}
+		}
+
+
+		const char* pFunctionName = NULL;
+
+		if (m_SymbolMap.find(CurrentPC) != m_SymbolMap.end())
+		{
+			pFunctionName = m_SymbolMap[CurrentPC].Name.c_str();
+		}
+
+		int Item = m_DisAsmListViewCtrl.AddItem(0, ColumnBP, _T(" "));
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnFunction, pFunctionName);
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnAddress, Temp);
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnMenmomic, Temp2);
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnOpcode, pOpcode);
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnExt, pExtension);
+
+		if (!_stricmp(pOpcode, "CALL"))
+		{
+			uint32 FunctionAddress = -1;
+			sscanf(pParameter, "0x%04x", &FunctionAddress);
+
+			if (m_SymbolMap.find(FunctionAddress) != m_SymbolMap.end())
+			{
+				pParameter = m_SymbolMap[FunctionAddress].Name.c_str();
+			}
+		}
+
+		m_DisAsmListViewCtrl.AddItem(Item, ColumnParameter, pParameter);
+
+		m_DisAsmListViewCtrl.SetItemData(Item, CurrentPC);
+	}
+
+	m_DisAsmListViewCtrl.SortItems(CompareFunc, (LPARAM) this);
+
+	m_DisAsmListViewCtrl.ShowWindow(SW_SHOW);
+}
+
+
+void CDisAsmDlg::UpdateDisAsmListView()
+{
+	if (g_dsp.dram == NULL)
+	{
+		return;
+	}
+
+	// check if we have to rebuild the list view
+	if (m_DisAsmListViewCtrl.GetItemCount() == 0)
+	{
+		RebuildDisAsmListView();
+	}
+	else
+	{
+		uint16 FirstPC = static_cast<uint16>(m_DisAsmListViewCtrl.GetItemData(0));
+
+		if ((FirstPC & 0x8000) != (g_dsp.pc & 0x8000))
+		{
+			RebuildDisAsmListView();
+		}
+	}
+
+	if (m_CachedStepCounter == g_dsp.step_counter)
+	{
+		return;
+	}
+
+	// show PC
+	for (int i = 0; i < m_DisAsmListViewCtrl.GetItemCount(); i++)
+	{
+		if (m_DisAsmListViewCtrl.GetItemData(i) == g_dsp.pc)
+		{
+			m_DisAsmListViewCtrl.EnsureVisible(i - 5, FALSE);
+			m_DisAsmListViewCtrl.EnsureVisible(i + 14, FALSE);
+			break;
+		}
+	}
+
+	m_CachedStepCounter = g_dsp.step_counter;
+
+	RedrawDisAsmListView();
+
+	m_RegisterDlg.UpdateRegisterListView();
+}
+
+
+void CDisAsmDlg::UpdateSymbolMap()
+{
+	if (g_dsp.dram == NULL)
+	{
+		return;
+	}
+
+	if (m_CachedUCodeCRC != g_dsp.iram_crc)
+	{
+		// load symbol map (if there is one)
+		m_CachedUCodeCRC = g_dsp.iram_crc;
+		char FileName[MAX_PATH];
+		sprintf(FileName, "maps\\DSP_%08x.map", m_CachedUCodeCRC);
+		LoadSymbolMap(FileName);
+
+		// rebuild the disasm
+		RebuildDisAsmListView();
+	}
+}
+
+
+void CDisAsmDlg::UpdateRegisterFlags()
+{
+	if (m_CachedCR == g_dsp.cr)
+	{
+		return;
+	}
+
+	CButton ButtonAssertInt(GetDlgItem(IDC_ASSERT_INT));
+	ButtonAssertInt.SetCheck(g_dsp.cr & 0x02 ? BST_CHECKED : BST_UNCHECKED);
+
+	CButton ButtonReset(GetDlgItem(IDC_HALT));
+	ButtonReset.SetCheck(g_dsp.cr & 0x04 ? BST_CHECKED : BST_UNCHECKED);
+
+	CButton ButtonInit(GetDlgItem(IDC_INIT));
+	ButtonInit.SetCheck(g_dsp.cr & 0x800 ? BST_CHECKED : BST_UNCHECKED);
+
+	m_CachedCR = g_dsp.cr;
+}
+
+
+bool CDisAsmDlg::CanDoStep()
+{
+	UpdateSymbolMap(); // update the symbols all the time because there a script cmds like bps
+
+	switch (m_State)
+	{
+	    case RUN_START:
+		    m_State = RUN;
+		    return(true);
+
+	    case RUN:
+
+		    if (IsBreakPoint(g_dsp.pc))
+		    {
+			    UpdateDialog();
+			    m_State = PAUSE;
+			    return(false);
+		    }
+
+		    return(true);
+
+	    case PAUSE:
+		    UpdateDialog();
+		    return(false);
+
+	    case STEP:
+		    UpdateDialog();
+		    m_State = PAUSE;
+		    return(true);
+	}
+
+	return(false);
+}
+
+
+void CDisAsmDlg::DebugBreak()
+{
+	m_State = PAUSE;
+}
+
+
+void CDisAsmDlg::UpdateButtonTexts()
+{
+	// go button
+	{
+		CButton Button(GetDlgItem(ID_GO));
+
+		switch (m_State)
+		{
+		    case RUN_START:
+		    case RUN:
+			    Button.SetWindowText("Pause");
+			    break;
+
+		    case PAUSE:
+		    case STEP:
+			    Button.SetWindowText("Go");
+			    break;
+		}
+	}
+
+	// show register
+	{
+		CButton Button(GetDlgItem(ID_SHOW_REGISTER));
+
+		if (m_RegisterDlg.IsWindowVisible())
+		{
+			Button.SetWindowText("Hide Regs");
+		}
+		else
+		{
+			Button.SetWindowText("Show Regs");
+		}
+	}
+}
+
+
+bool CDisAsmDlg::IsBreakPoint(uint16 _Address)
+{
+	return(std::find(m_BreakPoints.begin(), m_BreakPoints.end(), _Address) != m_BreakPoints.end());
+}
+
+
+void CDisAsmDlg::ToggleBreakPoint(uint16 _Address)
+{
+	if (IsBreakPoint(_Address))
+	{
+		RemoveBreakPoint(_Address);
+	}
+	else
+	{
+		AddBreakPoint(_Address);
+	}
+}
+
+
+void CDisAsmDlg::RemoveBreakPoint(uint16 _Address)
+{
+	CBreakPointList::iterator itr = std::find(m_BreakPoints.begin(), m_BreakPoints.end(), _Address);
+
+	if (itr != m_BreakPoints.end())
+	{
+		m_BreakPoints.erase(itr);
+	}
+}
+
+
+void CDisAsmDlg::AddBreakPoint(uint16 _Address)
+{
+	CBreakPointList::iterator itr = std::find(m_BreakPoints.begin(), m_BreakPoints.end(), _Address);
+
+	if (itr == m_BreakPoints.end())
+	{
+		m_BreakPoints.push_back(_Address);
+	}
+}
+
+
+void CDisAsmDlg::ClearBreakPoints()
+{
+	m_BreakPoints.clear();
+}
+
+
+LRESULT CDisAsmDlg::OnCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& _bHandled)
+{
+	int result = CDRF_DODEFAULT;
+
+	NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pnmh);
+
+	switch (pLVCD->nmcd.dwDrawStage)
+	{
+	    case CDDS_PREPAINT:
+		    result = CDRF_NOTIFYITEMDRAW;
+		    break;
+
+	    case CDDS_ITEMPREPAINT:
+		    result = CDRF_NOTIFYSUBITEMDRAW;
+		    break;
+
+	    case (CDDS_ITEMPREPAINT | CDDS_SUBITEM):
+	    {
+		    pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED | CDIS_FOCUS);
+
+		    uint16 CurrentAddress = static_cast<uint16>(m_DisAsmListViewCtrl.GetItemData((int)pLVCD->nmcd.dwItemSpec));
+		    pLVCD->clrTextBk = FindColor(CurrentAddress);
+
+		    if (CurrentAddress == g_dsp.pc)
+		    {
+			    pLVCD->clrTextBk = RGB(96,  192,  128);
+		    }
+
+		    switch (pLVCD->iSubItem)
+		    {
+			case 0x00:
+			{
+				if (IsBreakPoint(CurrentAddress))
+				{
+					pLVCD->clrTextBk = RGB(255,  64,  64);
+				}
+			}
+				break;
+
+			default:
+				break;
+		    }
+	    }
+	}
+
+	return(result);
+}
+
+
+void CDisAsmDlg::RedrawDisAsmListView()
+{
+	::InvalidateRect(m_DisAsmListViewCtrl.m_hWnd, NULL, FALSE);
+}
+
+
+bool CDisAsmDlg::LoadSymbolMap(const char* _pFileName)
+{
+	m_SymbolMap.clear();
+
+	FILE* pFile = fopen(_pFileName, "r");
+
+	if (!pFile)
+	{
+		return(false);
+	}
+
+	char Name[1024];
+	uint32 AddressStart, AddressEnd;
+
+	while (!feof(pFile))
+	{
+		char line[512];
+		fgets(line, 511, pFile);
+
+		if (strlen(line) < 2)
+		{
+			continue;
+		}
+
+		// check for comment
+		if (line[0] == '.')
+		{
+			continue;
+		}
+
+		// clear all breakpoints
+		if (line[0] == 'C')
+		{
+			ClearBreakPoints();
+			continue;
+		}
+
+		// add breakpoint
+		if (line[0] == 'B')
+		{
+			sscanf(line, "B %04x", &AddressStart);
+			AddBreakPoint(static_cast<uint16>(AddressStart));
+			continue;
+		}
+
+		// default add new symbol
+		sscanf(line, "%04x %04x %s", &AddressStart, &AddressEnd, Name);
+
+		if (m_SymbolMap.find(AddressStart) == m_SymbolMap.end())
+		{
+			m_SymbolMap.insert(std::pair<uint16, SSymbol>(AddressStart, SSymbol(AddressStart, AddressEnd, Name)));
+		}
+		else
+		{
+			m_SymbolMap[AddressStart] = SSymbol(AddressStart, AddressEnd, Name);
+		}
+	}
+
+	fclose(pFile);
+
+	return(true);
+}
+
+
+DWORD CDisAsmDlg::FindColor(uint16 _Address)
+{
+	size_t Color = 0;
+	static int Colors[6] = {0xC0FFFF, 0xFFE0C0, 0xC0C0FF, 0xFFC0FF, 0xC0FFC0, 0xFFFFC0};
+
+	for (CSymbolMap::const_iterator itr = m_SymbolMap.begin(); itr != m_SymbolMap.end(); itr++)
+	{
+		const SSymbol& rSymbol = itr->second;
+
+		if ((rSymbol.AddressStart <= _Address) && (_Address <= rSymbol.AddressEnd))
+		{
+			return(Colors[Color % 6]);
+		}
+
+		Color++;
+	}
+
+	return(GetSysColor(COLOR_3DLIGHT));
+}
+
+
+void CDisAsmDlg::UpdateDialog()
+{
+	UpdateSymbolMap();
+	UpdateDisAsmListView();
+//	UpdateButtonTexts();
+	UpdateRegisterFlags();
+}

Source/Plugins/Plugin_DSP_LLE/Src/DisAsmDlg.h

@@ -0,0 +1,150 @@
+// 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/
+
+#include "Globals.h"
+
+#include <list>
+#include <algorithm>
+
+#include "../res/resource.h"
+#include "DisAsmListView.h"
+#include "RegisterDlg.h"
+
+class CDisAsmDlg
+	: public CDialogImpl<CDisAsmDlg>, public CUpdateUI<CDisAsmDlg>
+{
+	public:
+
+		CDisAsmDlg();
+
+		enum { IDD = IDD_DISASMDLG };
+
+		virtual BOOL PreTranslateMessage(MSG* pMsg);
+		virtual BOOL OnIdle();
+
+
+		BEGIN_UPDATE_UI_MAP(CDisAsmDlg)
+		END_UPDATE_UI_MAP()
+
+		BEGIN_MSG_MAP(CDisAsmDlg)
+		MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
+		MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+		COMMAND_ID_HANDLER(ID_STEP, OnStep)
+		COMMAND_ID_HANDLER(ID_GO, OnGo)
+		COMMAND_ID_HANDLER(ID_SHOW_REGISTER, OnShowRegisters)
+		NOTIFY_CODE_HANDLER(NM_CLICK, OnDblClick)
+		NOTIFY_CODE_HANDLER(NM_RETURN, OnDblClick)
+		NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick)
+		NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
+		END_MSG_MAP()
+
+// Handler prototypes (uncomment arguments if needed):
+//	LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+//	LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
+//	LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
+
+		LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
+		LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
+
+		LRESULT OnStep(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
+		LRESULT OnGo(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
+		LRESULT OnShowRegisters(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL & /*bHandled*/);
+		LRESULT OnCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& _bHandled);
+
+		LRESULT OnDblClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/);
+		LRESULT OnRClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/);
+
+		void CloseDialog(int nVal);
+
+		bool CanDoStep();
+
+		void DebugBreak();
+
+
+	private:
+
+		enum EColumns
+		{
+			ColumnBP = 0,
+			ColumnFunction = 1,
+			ColumnAddress = 2,
+			ColumnMenmomic = 3,
+			ColumnOpcode = 4,
+			ColumnExt = 5,
+			ColumnParameter = 6
+		};
+
+		enum EState
+		{
+			PAUSE,
+			STEP,
+			RUN,
+			RUN_START // ignores breakpoints and switches after one step to RUN
+		};
+		EState m_State;
+
+
+		CListViewCtrl m_DisAsmListViewCtrl;
+		CRegisterDlg m_RegisterDlg;
+
+		uint64 m_CachedStepCounter;
+		uint16 m_CachedCR;
+		uint32 m_CachedUCodeCRC;
+
+		typedef std::list<uint16>CBreakPointList;
+		CBreakPointList m_BreakPoints;
+
+		// break point handling
+		bool IsBreakPoint(uint16 _Address);
+		void ToggleBreakPoint(uint16 _Address);
+		void RemoveBreakPoint(uint16 _Address);
+		void AddBreakPoint(uint16 _Address);
+		void ClearBreakPoints();
+
+
+		// update dialog
+		void UpdateDisAsmListView();
+		void UpdateRegisterFlags();
+		void UpdateSymbolMap();
+		void UpdateButtonTexts();
+
+		void RedrawDisAsmListView();
+		void RebuildDisAsmListView();
+
+
+		struct SSymbol
+		{
+			uint32 AddressStart;
+			uint32 AddressEnd;
+			std::string Name;
+
+			SSymbol(uint32 _AddressStart = 0, uint32 _AddressEnd = 0, char* _Name = NULL)
+				: AddressStart(_AddressStart)
+				, AddressEnd(_AddressEnd)
+				, Name(_Name)
+			{}
+		};
+		typedef std::map<uint16, SSymbol>CSymbolMap;
+		CSymbolMap m_SymbolMap;
+
+		void AddSymbol(uint16 _AddressStart, uint16 _AddressEnd, char* _Name);
+		bool LoadSymbolMap(const char* _pFileName);
+		DWORD FindColor(uint16 _Address);
+		void UpdateDialog();
+
+		static int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
+};

Source/Plugins/Plugin_DSP_LLE/Src/DisAsmListView.h

@@ -0,0 +1,64 @@
+// 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 _MYLISTVIEW_H
+#define _MYLISTVIEW_H
+
+class CDisAsmListView
+	: public CWindowImpl<CDisAsmListView, CListViewCtrl>,
+	public CCustomDraw<CDisAsmListView>
+{
+	public:
+
+		BEGIN_MSG_MAP(CDisAsmListView)
+		CHAIN_MSG_MAP(CCustomDraw<CDisAsmListView>)
+		END_MSG_MAP()
+
+		DWORD OnPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
+		{
+			return(CDRF_NOTIFYITEMDRAW);
+		}
+
+
+		DWORD OnItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW lpNMCustomDraw)
+		{
+			NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(lpNMCustomDraw);
+
+			// This is the prepaint stage for an item. Here's where we set the
+			// item's text color. Our return value will tell Windows to draw the
+			// item itself, but it will use the new color we set here for the background
+
+			COLORREF crText;
+
+			if ((pLVCD->nmcd.dwItemSpec % 2) == 0)
+			{
+				crText = RGB(200, 200, 255);
+			}
+			else
+			{
+				crText = RGB(255, 255, 255);
+			}
+
+			// Store the color back in the NMLVCUSTOMDRAW struct.
+			pLVCD->clrTextBk = crText;
+
+			// Tell Windows to paint the control itself.
+			return(CDRF_DODEFAULT);
+		}
+};
+
+#endif _MYLISTVIEW_H

Source/Plugins/Plugin_DSP_LLE/Src/Globals.cpp

@@ -0,0 +1,59 @@
+// 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/
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "Globals.h"
+
+
+void DebugLog(const char* _fmt, ...)
+{
+#ifdef _DEBUG
+/*	char Msg[512];
+    va_list ap;
+
+    va_start( ap, _fmt );
+    vsprintf( Msg, _fmt, ap );
+    va_end( ap );
+
+    OutputDebugString(Msg);
+
+    g_dspInitialize.pLog(Msg);
+ */
+#endif
+}
+
+
+void ErrorLog(const char* _fmt, ...)
+{
+	char Msg[512];
+	va_list ap;
+
+	va_start(ap, _fmt);
+	vsprintf(Msg, _fmt, ap);
+	va_end(ap);
+
+	g_dspInitialize.pLog(Msg);
+#ifdef _WIN32
+	::MessageBox(NULL, Msg, "Error", MB_OK);
+#endif
+
+	DSP_DebugBreak();
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/Globals.h

@@ -0,0 +1,60 @@
+// 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 _GLOBALS_H
+#define _GLOBALS_H
+
+#include "pluginspecs_dsp.h"
+
+#define WITH_DSP_ON_THREAD 1
+#define DUMP_DSP_IMEM   0
+
+extern DSPInitialize g_dspInitialize;
+void DebugLog(const char* _fmt, ...);
+void ErrorLog(const char* _fmt, ...);
+void DSP_DebugBreak();
+
+
+#ifdef _DEBUG
+
+#define _dbg_assert_(_a_)                   if (!(_a_)){DebugBreak();}
+#define _dbg_assert_msg_(_a_, _desc_, ...)\
+	if (!(_a_)){\
+		if (MessageBox(NULL, _desc_, "*** Fatal Error ***", MB_YESNO | MB_ICONERROR) == IDNO){DebugBreak();}}
+
+#else
+
+#define _dbg_assert_(_a_);
+#define _dbg_assert_msg_(_a_, _desc_, ...);
+
+#endif
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+typedef unsigned int uint;
+
+typedef signed char sint8;
+typedef signed short sint16;
+typedef signed int sint32;
+typedef signed long long sint64;
+
+typedef const uint32 cuint32;
+
+#endif
+

Source/Plugins/Plugin_DSP_LLE/Src/RegSettings.cpp

@@ -0,0 +1,272 @@
+// RegSettings.cpp
+//
+// Copyright (c) 2001 Magomed Abdurakhmanov
+// maq@hotbox.ru, http://mickels.iwt.ru/en
+//
+//
+//
+// No warranties are given. Use at your own risk.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "RegSettings.h"
+
+//////////////////////////////////////////////////////////////////////
+// CWindowSettings
+
+#define S_WINDOW_PLACEMENT_VAL _T("WindowPlacement")
+
+CWindowSettings::CWindowSettings()
+{
+	m_WindowPlacement.length = sizeof(m_WindowPlacement);
+	m_WindowPlacement.flags = 0;
+	m_WindowPlacement.ptMinPosition.x = 0;
+	m_WindowPlacement.ptMinPosition.y = 0;
+	m_WindowPlacement.ptMaxPosition.x = 0;
+	m_WindowPlacement.ptMaxPosition.y = 0;
+
+	CRect rc;
+	SystemParametersInfo(SPI_GETWORKAREA, 0, rc, 0);
+	rc.DeflateRect(100, 100);
+	m_WindowPlacement.rcNormalPosition = rc;
+	m_WindowPlacement.showCmd = SW_SHOWNORMAL;
+}
+
+
+bool CWindowSettings::Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/)
+{
+	CRegKey reg;
+	DWORD err = reg.Open(hkRootKey, szRegKey, KEY_READ);
+
+	if (err == ERROR_SUCCESS)
+	{
+		DWORD dwType = NULL;
+		DWORD dwSize = sizeof(m_WindowPlacement);
+		err = RegQueryValueEx(reg.m_hKey, CString(szPrefix) + S_WINDOW_PLACEMENT_VAL, NULL, &dwType,
+				(LPBYTE)&m_WindowPlacement, &dwSize);
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+
+bool CWindowSettings::Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/) const
+{
+	CRegKey reg;
+	DWORD err = reg.Create(hkRootKey, szRegKey);
+
+	if (err == ERROR_SUCCESS)
+	{
+		err = RegSetValueEx(reg.m_hKey, CString(szPrefix) + S_WINDOW_PLACEMENT_VAL, NULL, REG_BINARY,
+				(LPBYTE)&m_WindowPlacement, sizeof(m_WindowPlacement));
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+
+void CWindowSettings::GetFrom(CWindow& Wnd)
+{
+	ATLASSERT(Wnd.IsWindow());
+	Wnd.GetWindowPlacement(&m_WindowPlacement);
+}
+
+
+void CWindowSettings::ApplyTo(CWindow& Wnd, int nCmdShow /* = SW_SHOWNORMAL*/) const
+{
+	ATLASSERT(Wnd.IsWindow());
+
+	Wnd.SetWindowPlacement(&m_WindowPlacement);
+
+	if (SW_SHOWNORMAL != nCmdShow)
+	{
+		Wnd.ShowWindow(nCmdShow);
+	}
+	else
+	if (m_WindowPlacement.showCmd == SW_MINIMIZE || m_WindowPlacement.showCmd == SW_SHOWMINIMIZED)
+	{
+		Wnd.ShowWindow(SW_SHOWNORMAL);
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// CReBarSettings
+
+#define S_BAR_BANDCOUNT _T("BandCount")
+#define S_BAR_ID_VAL _T("ID")
+#define S_BAR_CX_VAL _T("CX")
+#define S_BAR_BREAKLINE_VAL _T("BreakLine")
+
+CReBarSettings::CReBarSettings()
+{
+	m_pBands = NULL;
+	m_cbBandCount = 0;
+}
+
+
+CReBarSettings::~CReBarSettings()
+{
+	if (m_pBands != NULL)
+	{
+		delete[] m_pBands;
+	}
+}
+
+
+bool CReBarSettings::Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/)
+{
+	if (m_pBands != NULL)
+	{
+		delete[] m_pBands;
+	}
+
+	m_pBands = NULL;
+	m_cbBandCount = 0;
+
+	CRegKey reg;
+	DWORD err = reg.Open(hkRootKey, szRegKey, KEY_READ);
+
+	if (err == ERROR_SUCCESS)
+	{
+		reg.QueryValue(m_cbBandCount, CString(szPrefix) + S_BAR_BANDCOUNT);
+
+		if (m_cbBandCount > 0)
+		{
+			m_pBands = new BandInfo[m_cbBandCount];
+		}
+
+		for (DWORD i = 0; i < m_cbBandCount; i++)
+		{
+			CString s;
+			s.Format(_T("%s%i_"), szPrefix, i);
+			reg.QueryValue(m_pBands[i].ID, s + S_BAR_ID_VAL);
+			reg.QueryValue(m_pBands[i].cx, s + S_BAR_CX_VAL);
+
+			DWORD dw;
+			reg.QueryValue(dw, s + S_BAR_BREAKLINE_VAL);
+			m_pBands[i].BreakLine = dw != 0;
+		}
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+
+bool CReBarSettings::Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/) const
+{
+	CRegKey reg;
+	DWORD err = reg.Create(hkRootKey, szRegKey);
+
+	if (err == ERROR_SUCCESS)
+	{
+		reg.SetValue(m_cbBandCount, CString(szPrefix) + S_BAR_BANDCOUNT);
+
+		for (DWORD i = 0; i < m_cbBandCount; i++)
+		{
+			CString s;
+			s.Format(_T("%s%i_"), szPrefix, i);
+			reg.SetValue(m_pBands[i].ID, s + S_BAR_ID_VAL);
+			reg.SetValue(m_pBands[i].cx, s + S_BAR_CX_VAL);
+
+			DWORD dw = m_pBands[i].BreakLine;
+			reg.SetValue(dw, s + S_BAR_BREAKLINE_VAL);
+		}
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+
+void CReBarSettings::GetFrom(CReBarCtrl& ReBar)
+{
+	ATLASSERT(ReBar.IsWindow());
+
+	if (m_pBands != NULL)
+	{
+		delete[] m_pBands;
+	}
+
+	m_pBands = NULL;
+	m_cbBandCount = ReBar.GetBandCount();
+
+	if (m_cbBandCount > 0)
+	{
+		m_pBands = new BandInfo[m_cbBandCount];
+	}
+
+	for (UINT i = 0; i < m_cbBandCount; i++)
+	{
+		REBARBANDINFO rbi;
+		rbi.cbSize = sizeof(rbi);
+		rbi.fMask = RBBIM_ID | RBBIM_SIZE | RBBIM_STYLE;
+		ReBar.GetBandInfo(i, &rbi);
+		m_pBands[i].ID = rbi.wID;
+		m_pBands[i].cx = rbi.cx;
+		m_pBands[i].BreakLine = (rbi.fStyle & RBBS_BREAK) != 0;
+	}
+}
+
+
+void CReBarSettings::ApplyTo(CReBarCtrl& ReBar) const
+{
+	ATLASSERT(ReBar.IsWindow());
+
+	for (UINT i = 0; i < m_cbBandCount; i++)
+	{
+		ReBar.MoveBand(ReBar.IdToIndex(m_pBands[i].ID), i);
+		REBARBANDINFO rbi;
+		rbi.cbSize = sizeof(rbi);
+		rbi.fMask = RBBIM_ID | RBBIM_SIZE | RBBIM_STYLE;
+		ReBar.GetBandInfo(i, &rbi);
+
+		rbi.cx = m_pBands[i].cx;
+
+		if (m_pBands[i].BreakLine)
+		{
+			rbi.fStyle |= RBBS_BREAK;
+		}
+		else
+		{
+			rbi.fStyle &= (~RBBS_BREAK);
+		}
+
+		ReBar.SetBandInfo(i, &rbi);
+	}
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// CSplitterSettings
+
+#define S_SPLITTER_POS _T("SplitterPos")
+
+bool CSplitterSettings::Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/)
+{
+	CRegKey reg;
+	DWORD err = reg.Open(hkRootKey, szRegKey, KEY_READ);
+
+	if (err == ERROR_SUCCESS)
+	{
+		reg.QueryValue(m_dwPos, CString(szPrefix) + S_SPLITTER_POS);
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+
+bool CSplitterSettings::Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey /* = HKEY_CURRENT_USER*/) const
+{
+	CRegKey reg;
+	DWORD err = reg.Create(hkRootKey, szRegKey);
+
+	if (err == ERROR_SUCCESS)
+	{
+		reg.SetValue(m_dwPos, CString(szPrefix) + S_SPLITTER_POS);
+	}
+
+	return(err == ERROR_SUCCESS);
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/RegSettings.h

@@ -0,0 +1,81 @@
+// RegSettings.h
+//
+// Copyright (c) 2001 Magomed Abdurakhmanov
+// maq@hotbox.ru, http://mickels.iwt.ru/en
+//
+//
+//
+// No warranties are given. Use at your own risk.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined (AFX_REGSETTINGS_H__91E69C67_8104_4819_969A_B5E71A9993D5__INCLUDED_)
+#define AFX_REGSETTINGS_H__91E69C67_8104_4819_969A_B5E71A9993D5__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <AtlMisc.h>
+#include <AtlCtrls.h>
+
+class CWindowSettings
+{
+	public:
+
+		WINDOWPLACEMENT m_WindowPlacement;
+
+		CWindowSettings();
+		void GetFrom(CWindow& Wnd);
+		void ApplyTo(CWindow& Wnd, int nCmdShow = SW_SHOWNORMAL) const;
+
+		bool Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER);
+		bool Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER) const;
+};
+
+class CReBarSettings
+{
+	public:
+
+		struct BandInfo
+		{
+			DWORD ID;
+			DWORD cx;
+			bool BreakLine;
+		}* m_pBands;
+
+		DWORD m_cbBandCount;
+
+		CReBarSettings();
+		~CReBarSettings();
+
+		void GetFrom(CReBarCtrl& ReBar);
+		void ApplyTo(CReBarCtrl& ReBar) const;
+
+		bool Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER);
+		bool Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER) const;
+};
+
+class CSplitterSettings
+{
+	public:
+
+		DWORD m_dwPos;
+
+		template<class T>void GetFrom(const T& Splitter)
+		{
+			m_dwPos = Splitter.GetSplitterPos();
+		}
+
+
+		template<class T>void ApplyTo(T& Splitter) const
+		{
+			Splitter.SetSplitterPos(m_dwPos);
+		}
+
+
+		bool Load(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER);
+		bool Save(LPCTSTR szRegKey, LPCTSTR szPrefix, HKEY hkRootKey = HKEY_CURRENT_USER) const;
+};
+
+#endif // !defined(AFX_REGSETTINGS_H__91E69C67_8104_4819_969A_B5E71A9993D5__INCLUDED_)

Source/Plugins/Plugin_DSP_LLE/Src/RegisterDlg.cpp

@@ -0,0 +1,207 @@
+// 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/
+
+#include "../res/resource.h"
+#include "RegisterDlg.h"
+
+#include "disassemble.h"
+#include "gdsp_interpreter.h"
+#include "RegSettings.h"
+
+CRegisterDlg::CRegisterDlg()
+	: m_CachedCounter(-1)
+{}
+
+
+BOOL CRegisterDlg::PreTranslateMessage(MSG* pMsg)
+{
+	return(IsDialogMessage(pMsg));
+}
+
+
+BOOL CRegisterDlg::OnIdle()
+{
+	return(FALSE);
+}
+
+
+LRESULT CRegisterDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+{
+	CWindowSettings ws;
+
+	if (ws.Load("Software\\Dolphin\\DSP", "Register"))
+	{
+		ws.ApplyTo(CWindow(m_hWnd), SW_SHOW);
+	}
+
+	m_RegisterListViewCtrl.m_hWnd = GetDlgItem(IDC_DISASM_LIST);
+
+	UIAddChildWindowContainer(m_hWnd);
+
+	m_RegisterListViewCtrl.AddColumn(_T("General"), 0);
+	m_RegisterListViewCtrl.AddColumn(_T(" "),        1);
+	m_RegisterListViewCtrl.AddColumn(_T("Special"),  2);
+	m_RegisterListViewCtrl.AddColumn(_T("0"),        3);
+
+	m_RegisterListViewCtrl.SetColumnWidth(0, 50);
+	m_RegisterListViewCtrl.SetColumnWidth(1, 100);
+	m_RegisterListViewCtrl.SetColumnWidth(2, 60);
+	m_RegisterListViewCtrl.SetColumnWidth(3, 100);
+
+	m_RegisterListViewCtrl.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
+	m_RegisterListViewCtrl.SetTextBkColor(GetSysColor(COLOR_3DLIGHT));
+
+
+	for (uint16 i = 0; i < 16; i++)
+	{
+		// 0-15
+		int Item = m_RegisterListViewCtrl.AddItem(0, 0, gd_dis_get_reg_name(i));
+
+		// 16-31
+		m_RegisterListViewCtrl.AddItem(Item, 2, gd_dis_get_reg_name(16 + i));
+
+		// just for easy sort
+		m_RegisterListViewCtrl.SetItemData(Item, i);
+	}
+
+	m_RegisterListViewCtrl.SortItems(CompareFunc, (LPARAM) this);
+
+	UpdateRegisterListView();
+
+	return(TRUE);
+}
+
+
+LRESULT CRegisterDlg::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+{
+	CWindowSettings ws;
+	ws.GetFrom(CWindow(m_hWnd));
+	ws.Save("Software\\Dolphin\\DSP", "Register");
+
+	return(0);
+}
+
+
+void CRegisterDlg::UpdateRegisterListView()
+{
+	if (m_CachedCounter == g_dsp.step_counter)
+	{
+		return;
+	}
+
+	m_CachedCounter = g_dsp.step_counter;
+
+	char Temp[256];
+
+	for (uint16 i = 0; i < 16; i++)
+	{
+		// 0-15
+		if (m_CachedRegs[i] != g_dsp.r[i])
+		{
+			m_CachedRegHasChanged[i] = true;
+		}
+		else
+		{
+			m_CachedRegHasChanged[i] = false;
+		}
+
+		m_CachedRegs[i] = g_dsp.r[i];
+
+		sprintf_s(Temp, 256, "0x%04x", g_dsp.r[i]);
+		m_RegisterListViewCtrl.SetItemText(i, 1, Temp);
+
+		// 16-31
+		if (m_CachedRegs[16 + i] != g_dsp.r[16 + i])
+		{
+			m_CachedRegHasChanged[16 + i] = true;
+		}
+		else
+		{
+			m_CachedRegHasChanged[16 + i] = false;
+		}
+
+		m_CachedRegs[16 + i] = g_dsp.r[16 + i];
+
+		sprintf_s(Temp, 256, "0x%04x", g_dsp.r[16 + i]);
+		m_RegisterListViewCtrl.SetItemText(i, 3, Temp);
+	}
+}
+
+
+int CALLBACK CRegisterDlg::CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
+{
+	return(lParam1 > lParam2);
+}
+
+
+LRESULT CRegisterDlg::OnCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& _bHandled)
+{
+	int result = CDRF_DODEFAULT;
+
+	NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pnmh);
+
+	switch (pLVCD->nmcd.dwDrawStage)
+	{
+	    case CDDS_PREPAINT:
+		    result = CDRF_NOTIFYITEMDRAW;
+		    break;
+
+	    case CDDS_ITEMPREPAINT:
+		    result = CDRF_NOTIFYSUBITEMDRAW;
+		    break;
+
+	    case (CDDS_ITEMPREPAINT | CDDS_SUBITEM):
+	    {
+		    pLVCD->nmcd.uItemState &= ~(CDIS_SELECTED | CDIS_FOCUS);
+
+		    int Offset = static_cast<int>(m_RegisterListViewCtrl.GetItemData((int)pLVCD->nmcd.dwItemSpec));
+
+		    size_t Register = -1;
+
+		    if (pLVCD->iSubItem == 1)
+		    {
+			    Register = Offset;
+		    }
+		    else if (pLVCD->iSubItem == 3)
+		    {
+			    Register = Offset + 16;
+		    }
+
+		    if (Register != -1)
+		    {
+			    if (m_CachedRegHasChanged[Register])
+			    {
+				    pLVCD->clrTextBk = RGB(0xFF,  192,  192);
+			    }
+			    else
+			    {
+				    pLVCD->clrTextBk = RGB(0xF0,  0xF0,  0xF0);
+			    }
+		    }
+		    else
+		    {
+			    pLVCD->clrTextBk = RGB(192,  224,  192);
+		    }
+
+
+		    // uint16 CurrentAddress = static_cast<uint16>(m_DisAsmListViewCtrl.GetItemData((int)pLVCD->nmcd.dwItemSpec));
+	    }
+		    break;
+	}
+
+	return(result);
+}

Source/Plugins/Plugin_DSP_LLE/Src/RegisterDlg.h

@@ -0,0 +1,80 @@
+// 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/
+
+#pragma once
+
+#include "Globals.h"
+
+#include <map>
+#include "DisAsmListView.h"
+
+class CRegisterDlg
+	: public CDialogImpl<CRegisterDlg>, public CUpdateUI<CRegisterDlg>
+{
+	public:
+
+		CRegisterDlg();
+
+		enum { IDD = IDD_REGISTERDLG };
+
+		virtual BOOL PreTranslateMessage(MSG* pMsg);
+		virtual BOOL OnIdle();
+
+
+		BEGIN_UPDATE_UI_MAP(CRegisterDlg)
+		END_UPDATE_UI_MAP()
+
+		BEGIN_MSG_MAP(CRegisterDlg)
+		MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
+		MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+		NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
+
+// 		COMMAND_ID_HANDLER(ID_STEP, OnStep)
+// 		COMMAND_ID_HANDLER(ID_GO, OnGo)
+// 		COMMAND_ID_HANDLER(ID_SHOW_REGISTER, OnShowRegisters)
+		END_MSG_MAP()
+
+// Handler prototypes (uncomment arguments if needed):
+//	LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+//	LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
+//	LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
+
+		LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
+		LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL & /*bHandled*/);
+		LRESULT OnCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& _bHandled);
+
+
+//	LRESULT OnStep(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
+//	LRESULT OnGo(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
+//	LRESULT OnShowRegisters(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
+
+		void CloseDialog(int nVal);
+
+		void UpdateRegisterListView();
+
+
+	private:
+
+		CListViewCtrl m_RegisterListViewCtrl;
+
+		static int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
+
+
+		uint64 m_CachedCounter;
+		uint16 m_CachedRegs[32];
+		bool m_CachedRegHasChanged[32];
+};

Source/Plugins/Plugin_DSP_LLE/Src/SConscript

@@ -0,0 +1,17 @@
+Import('env')
+output = "../../../../Binary/linux/Plugins/temp/dsplle.so"
+files = ["disassemble.cpp",
+		 "gdsp_aram.cpp",
+		 "gdsp_ext_op.cpp",
+         "gdsp_interface.cpp",
+		 "gdsp_interpreter.cpp",
+         "gdsp_memory.cpp",
+         "gdsp_opcodes.cpp",
+         "gdsp_registers.cpp",
+         "Globals.cpp",
+         "opcodes.cpp",
+         "Tools.cpp",
+         "UCode_AX.cpp",
+		 ]
+#env.Append(LINKFLAGS = "-symbolic")
+env.SharedLibrary(output, files)

Source/Plugins/Plugin_DSP_LLE/Src/Tools.cpp

@@ -0,0 +1,87 @@
+// 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/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "Common.h"
+#include "Globals.h"
+
+#include "gdsp_interpreter.h"
+
+bool DumpDSPCode(uint32 _Address, uint32 _Length)
+{
+	FILE* pFile = fopen("d:\\DSP_UCode.bin", "wb");
+
+	if (pFile != NULL)
+	{
+		fwrite(g_dspInitialize.pGetMemoryPointer(_Address), _Length, 1, pFile);
+		fclose(pFile);
+		return(true);
+	}
+
+	return(false);
+}
+
+
+uint32 GenerateCRC(const unsigned char* _pBuffer, int _pLength)
+{
+	unsigned long CRC = 0xFFFFFFFF;
+
+	while (_pLength--)
+	{
+		unsigned long Temp = (unsigned long)((CRC & 0xFF) ^ *_pBuffer++);
+
+		for (int j = 0; j < 8; j++)
+		{
+			if (Temp & 0x1)
+			{
+				Temp = (Temp >> 1) ^ 0xEDB88320;
+			}
+			else
+			{
+				Temp >>= 1;
+			}
+		}
+
+		CRC = (CRC >> 8) ^ Temp;
+	}
+
+	return(CRC ^ 0xFFFFFFFF);
+}
+
+
+bool DumpCWCode(uint32 _Address, uint32 _Length)
+{
+	FILE* pFile = fopen("d:\\DSP_UCode.bin", "wb");
+
+	if (pFile != NULL)
+	{
+		for (size_t i = _Address; i < _Address + _Length; i++)
+		{
+			uint16 val = Common::swap16(g_dsp.iram[i]);
+			fprintf(pFile, "    cw 0x%04x \n", val);
+		}
+
+		fclose(pFile);
+		return(true);
+	}
+
+	return(false);
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/Tools.h

@@ -0,0 +1,50 @@
+// 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/
+
+#pragma once
+
+// UDSPControl
+union UDSPControl
+{
+	uint16 Hex;
+	struct
+	{
+		unsigned DSPReset       : 1; // Write 1 to reset and waits for 0
+		unsigned DSPAssertInt   : 1;
+		unsigned DSPHalt        : 1;
+
+		unsigned AI             : 1;
+		unsigned AI_mask        : 1;
+		unsigned ARAM           : 1;
+		unsigned ARAM_mask      : 1;
+		unsigned DSP            : 1;
+		unsigned DSP_mask       : 1;
+
+		unsigned ARAM_DMAState  : 1; // DSPGetDMAStatus() uses this flag
+		unsigned unk3           : 1;
+		unsigned DSPInit        : 1; // DSPInit() writes to this flag
+		unsigned pad            : 4;
+	};
+
+	UDSPControl(uint16 _Hex = 0)
+		: Hex(_Hex) {}
+};
+
+
+bool DumpDSPCode(uint32 _Address, uint32 _Length);
+uint32 GenerateCRC(const unsigned char* _pBuffer, int _pLength);
+bool DumpCWCode(uint32 _Address, uint32 _Length);

Source/Plugins/Plugin_DSP_LLE/Src/disassemble.cpp

@@ -0,0 +1,619 @@
+/*====================================================================
+
+   filename:     disassemble.cpp
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include <stdio.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "Globals.h"
+
+#include "disassemble.h"
+#include "opcodes.h"
+// #include "gdsp_tool.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable:4996)
+#endif
+
+uint32 unk_opcodes[0x10000];
+
+uint16 swap16(uint16 x);
+
+
+// predefined labels
+typedef struct pdlabel_t
+{
+	uint16 addr;
+	const char* name;
+	const char* description;
+} pdlabels_t;
+
+const pdlabel_t pdlabels[] =
+{
+	{0xffa0, "COEF_A1_0", "COEF_A1_0",},
+	{0xffa1, "COEF_A2_0", "COEF_A2_0",},
+	{0xffa2, "COEF_A1_1", "COEF_A1_1",},
+	{0xffa3, "COEF_A2_1", "COEF_A2_1",},
+	{0xffa4, "COEF_A1_2", "COEF_A1_2",},
+	{0xffa5, "COEF_A2_2", "COEF_A2_2",},
+	{0xffa6, "COEF_A1_3", "COEF_A1_3",},
+	{0xffa7, "COEF_A2_3", "COEF_A2_3",},
+	{0xffa8, "COEF_A1_4", "COEF_A1_4",},
+	{0xffa9, "COEF_A2_4", "COEF_A2_4",},
+	{0xffaa, "COEF_A1_5", "COEF_A1_5",},
+	{0xffab, "COEF_A2_5", "COEF_A2_5",},
+	{0xffac, "COEF_A1_6", "COEF_A1_6",},
+	{0xffad, "COEF_A2_6", "COEF_A2_6",},
+	{0xffae, "COEF_A1_7", "COEF_A1_7",},
+	{0xffaf, "COEF_A2_7", "COEF_A2_7",},
+	{0xffc9, "DSCR", "DSP DMA Control Reg",},
+	{0xffcb, "DSBL", "DSP DMA Block Length",},
+	{0xffcd, "DSPA", "DSP DMA DMEM Address",},
+	{0xffce, "DSMAH", "DSP DMA Mem Address H",},
+	{0xffcf, "DSMAL", "DSP DMA Mem Address L",},
+	{0xffd1, "SampleFormat", "SampleFormat",},
+	{0xffd4, "ACSAH", "Accelerator start address H",},
+	{0xffd5, "ACSAL", "Accelerator start address L",},
+	{0xffd6, "ACEAH", "Accelerator end address H",},
+	{0xffd7, "ACEAL", "Accelerator end address L",},
+	{0xffd8, "ACCAH", "Accelerator current address H",},
+	{0xffd9, "ACCAL", "Accelerator current address L",},
+	{0xffda, "pred_scale", "pred_scale",},
+	{0xffdb, "yn1", "yn1",},
+	{0xffdc, "yn2", "yn2",},
+	{0xffdd, "ARAM", "Direct Read from ARAM (uses ADPCM)",},
+	{0xffde, "GAIN", "Gain",},
+	{0xffef, "AMDM", "ARAM DMA Request Mask",},
+	{0xfffb, "DIRQ", "DSP IRQ Request",},
+	{0xfffc, "DMBH", "DSP Mailbox H",},
+	{0xfffd, "DMBL", "DSP Mailbox L",},
+	{0xfffe, "CMBH", "CPU Mailbox H",},
+	{0xffff, "CMBL", "CPU Mailbox L",},
+};
+
+pdlabel_t regnames[] =
+{
+	{0x00, "R00",       "Register 00",},
+	{0x01, "R01",       "Register 01",},
+	{0x02, "R02",       "Register 02",},
+	{0x03, "R03",       "Register 03",},
+	{0x04, "R04",       "Register 04",},
+	{0x05, "R05",       "Register 05",},
+	{0x06, "R06",       "Register 06",},
+	{0x07, "R07",       "Register 07",},
+	{0x08, "R08",       "Register 08",},
+	{0x09, "R09",       "Register 09",},
+	{0x0a, "R10",       "Register 10",},
+	{0x0b, "R11",       "Register 11",},
+	{0x0c, "ST0",       "Call stack",},
+	{0x0d, "ST1",       "Data stack",},
+	{0x0e, "ST2",       "Loop address stack",},
+	{0x0f, "ST3",       "Loop counter",},
+	{0x00, "ACH0",      "Accumulator High 0",},
+	{0x11, "ACH1",      "Accumulator High 1",},
+	{0x12, "CR",        "Config Register",},
+	{0x13, "SR",        "Special Register",},
+	{0x14, "PROD.L",    "PROD L",},
+	{0x15, "PROD.M1",   "PROD M1",},
+	{0x16, "PROD.H",    "PROD H",},
+	{0x17, "PROD.M2",   "PROD M2",},
+	{0x18, "AX0.L", "Additional Accumulators Low 0",},
+	{0x19, "AX1.L", "Additional Accumulators Low 1",},
+	{0x1a, "AX0.H", "Additional Accumulators High 0",},
+	{0x1b, "AX1.H", "Additional Accumulators High 1",},
+	{0x1c, "AC0.L", "Register 28",},
+	{0x1d, "AC1.L", "Register 29",},
+	{0x1e, "AC0.M", "Register 00",},
+	{0x1f, "AC1.M", "Register 00",},
+
+// additional to resolve special names
+	{0x20, "ACC0",      "Accumulators 0",},
+	{0x21, "ACC1",      "Accumulators 1",},
+	{0x22, "AX0",       "Additional Accumulators 0",},
+	{0x23, "AX1",       "Additional Accumulators 1",},
+};
+
+const char* pdname(uint16 val)
+{
+	static char tmpstr[12]; // nasty
+
+	for (int i = 0; i < (int)(sizeof(pdlabels) / sizeof(pdlabel_t)); i++)
+	{
+		if (pdlabels[i].addr == val)
+		{
+			return(pdlabels[i].name);
+		}
+	}
+
+	sprintf(tmpstr, "0x%04x", val);
+	return(tmpstr);
+}
+
+
+char* gd_dis_params(gd_globals_t* gdg, opc_t* opc, uint16 op1, uint16 op2, char* strbuf)
+{
+	char* buf = strbuf;
+	uint32 val;
+	int j;
+
+	for (j = 0; j < opc->param_count; j++)
+	{
+		if (j > 0)
+		{
+			sprintf(buf, ", ");
+			buf += strlen(buf);
+		}
+
+		if (opc->params[j].loc >= 1)
+		{
+			val = op2;
+		}
+		else
+		{
+			val = op1;
+		}
+
+		val &= opc->params[j].mask;
+
+		if (opc->params[j].lshift < 0)
+		{
+			val = val << (-opc->params[j].lshift);
+		}
+		else
+		{
+			val = val >> opc->params[j].lshift;
+		}
+
+		uint32 type;
+		type = opc->params[j].type;
+
+		if (type & P_REG)
+		{
+			if (type == P_ACCM_D)
+			{
+				val = (~val & 0x1) | ((type & P_REGS_MASK) >> 8);
+			}
+			else
+			{
+				val |= (type & P_REGS_MASK) >> 8;
+			}
+
+			type &= ~P_REGS_MASK;
+		}
+
+		switch (type)
+		{
+		    case P_REG:
+
+			    if (gdg->decode_registers){sprintf(buf, "$%s", regnames[val].name);}
+			    else {sprintf(buf, "$%d", val);}
+
+			    break;
+
+		    case P_PRG:
+
+			    if (gdg->decode_registers){sprintf(buf, "@$%s", regnames[val].name);}
+			    else {sprintf(buf, "@$%d", val);}
+
+			    break;
+
+		    case P_VAL:
+			    sprintf(buf, "0x%04x", val);
+			    break;
+
+		    case P_IMM:
+
+			    if (opc->params[j].size != 2)
+			    {
+				    sprintf(buf, "#0x%02x", val);
+			    }
+			    else
+			    {
+				    sprintf(buf, "#0x%04x", val);
+			    }
+
+			    break;
+
+		    case P_MEM:
+
+			    if (opc->params[j].size != 2)
+			    {
+				    val = (uint16)(sint8)val;
+			    }
+
+			    if (gdg->decode_names)
+			    {
+				    sprintf(buf, "@%s", pdname(val));
+			    }
+			    else
+			    {
+				    sprintf(buf, "@0x%04x", val);
+			    }
+
+			    break;
+
+		    default:
+			    ErrorLog("Unknown parameter type: %x\n", opc->params[j].type);
+			    exit(-1);
+			    break;
+		}
+
+		buf += strlen(buf);
+	}
+
+	return(strbuf);
+}
+
+
+gd_globals_t* gd_init()
+{
+	gd_globals_t* gdg = (gd_globals_t*)malloc(sizeof(gd_globals_t));
+	memset(gdg, 0, sizeof(gd_globals_t));
+	return(gdg);
+}
+
+
+uint16 gd_dis_get_opcode_size(gd_globals_t* gdg)
+{
+	opc_t* opc = 0;
+	opc_t* opc_ext = 0;
+	bool extended;
+
+	if ((gdg->pc & 0x7fff) >= 0x1000)
+	{
+		return(1);
+	}
+
+	uint32 op1 = swap16(gdg->binbuf[gdg->pc & 0x0fff]);
+
+	for (uint32 j = 0; j < opcodes_size; j++)
+	{
+		uint16 mask;
+
+		if (opcodes[j].size & P_EXT)
+		{
+			mask = opcodes[j].opcode_mask & 0xff00;
+		}
+		else
+		{
+			mask = opcodes[j].opcode_mask;
+		}
+
+		if ((op1 & mask) == opcodes[j].opcode)
+		{
+			opc = &opcodes[j];
+			break;
+		}
+	}
+
+	if (!opc)
+	{
+		ErrorLog("get_opcode_size ARGH");
+		exit(0);
+	}
+
+	if (opc->size & P_EXT && op1 & 0x00ff)
+	{
+		extended = true;
+	}
+	else
+	{
+		extended = false;
+	}
+
+	if (extended)
+	{
+		// opcode has an extension
+		// find opcode
+		for (uint32 j = 0; j < opcodes_ext_size; j++)
+		{
+			if ((op1 & opcodes_ext[j].opcode_mask) == opcodes_ext[j].opcode)
+			{
+				opc_ext = &opcodes_ext[j];
+				break;
+			}
+		}
+
+		if (!opc_ext)
+		{
+			ErrorLog("get_opcode_size ext ARGH");
+		}
+
+		return(opc_ext->size);
+	}
+
+	return(opc->size & ~P_EXT);
+}
+
+
+char* gd_dis_opcode(gd_globals_t* gdg)
+{
+	uint32 j;
+	uint32 op1, op2;
+	opc_t* opc;
+	opc_t* opc_ext;
+	uint16 pc;
+	char* buf = gdg->buffer;
+	bool extended;
+
+	pc   = gdg->pc;
+	*buf = '\0';
+
+	if ((pc & 0x7fff) >= 0x1000)
+	{
+		gdg->pc++;
+		return(gdg->buffer);
+	}
+
+	pc &= 0x0fff;
+	op1 = swap16(gdg->binbuf[pc]);
+
+	// find opcode
+	for (j = 0; j < opcodes_size; j++)
+	{
+		uint16 mask;
+
+		if (opcodes[j].size & P_EXT)
+		{
+			mask = opcodes[j].opcode_mask & 0xff00;
+		}
+		else
+		{
+			mask = opcodes[j].opcode_mask;
+		}
+
+		if ((op1 & mask) == opcodes[j].opcode)
+		{
+			opc = &opcodes[j];
+			break;
+		}
+	}
+
+	if (opc->size & P_EXT && op1 & 0x00ff)
+	{
+		extended = true;
+	}
+	else
+	{
+		extended = false;
+	}
+
+	if (extended)
+	{
+		// opcode has an extension
+		// find opcode
+		for (j = 0; j < opcodes_ext_size; j++)
+		{
+			if ((op1 & opcodes_ext[j].opcode_mask) == opcodes_ext[j].opcode)
+			{
+				opc_ext = &opcodes_ext[j];
+				break;
+			}
+		}
+	}
+
+	// printing
+
+	if (gdg->show_pc){sprintf(buf, "%04x ", gdg->pc);}
+
+	buf += strlen(buf);
+
+	if ((opc->size & ~P_EXT) == 2)
+	{
+		op2 = swap16(gdg->binbuf[pc + 1]);
+
+		if (gdg->show_hex){sprintf(buf, "%04x %04x ", op1, op2);}
+	}
+	else
+	{
+		op2 = 0;
+
+		if (gdg->show_hex){sprintf(buf, "%04x      ", op1);}
+	}
+
+	buf += strlen(buf);
+
+	char tmpbuf[20];
+
+	if (extended)
+	{
+		sprintf(tmpbuf, "%s%c%s", opc->name, gdg->ext_separator, opc_ext->name);
+	}
+	else
+	{
+		sprintf(tmpbuf, "%s", opc->name);
+	}
+
+	if (gdg->print_tabs)
+	{
+		sprintf(buf, "%s\t", tmpbuf);
+	}
+	else
+	{
+		sprintf(buf, "%-12s", tmpbuf);
+	}
+
+	buf += strlen(buf);
+
+	if (opc->param_count > 0)
+	{
+		gd_dis_params(gdg, opc, op1, op2, buf);
+	}
+
+	buf += strlen(buf);
+
+	if (extended)
+	{
+		if (opc->param_count > 0)
+		{
+			sprintf(buf, " ");
+		}
+
+		buf += strlen(buf);
+
+		sprintf(buf, ": ");
+		buf += strlen(buf);
+
+		if (opc_ext->param_count > 0)
+		{
+			gd_dis_params(gdg, opc_ext, op1, op2, buf);
+		}
+
+		buf += strlen(buf);
+	}
+
+	if (opc->opcode_mask == 0)
+	{
+		// unknown opcode
+		unk_opcodes[op1]++;
+		sprintf(buf, "\t\t; *** UNKNOWN OPCODE ***");
+	}
+
+	if (extended)
+	{
+		gdg->pc += opc_ext->size;
+	}
+	else
+	{
+		gdg->pc += opc->size & ~P_EXT;
+	}
+
+	return(gdg->buffer);
+}
+
+
+bool gd_dis_file(gd_globals_t* gdg, char* name, FILE* output)
+{
+	FILE* in;
+	uint32 size;
+
+	in = fopen(name, "rb");
+
+	if (in == NULL)
+	{
+		return(false);
+	}
+
+	fseek(in, 0, SEEK_END);
+	size = ftell(in);
+	fseek(in, 0, SEEK_SET);
+	gdg->binbuf = (uint16*)malloc(size);
+	fread(gdg->binbuf, 1, size, in);
+
+	gdg->buffer = (char*)malloc(256);
+	gdg->buffer_size = 256;
+
+	for (gdg->pc = 0; gdg->pc < (size / 2);)
+	{
+		fprintf(output, "%s\n", gd_dis_opcode(gdg));
+	}
+
+	fclose(in);
+
+	free(gdg->binbuf);
+	gdg->binbuf = NULL;
+
+	free(gdg->buffer);
+	gdg->buffer = NULL;
+	gdg->buffer_size = 0;
+
+	return(true);
+}
+
+
+void gd_dis_close_unkop()
+{
+	FILE* uo;
+	int i, j;
+	uint32 count = 0;
+
+	uo = fopen("uo.bin", "wb");
+
+	if (uo)
+	{
+		fwrite(unk_opcodes, 1, sizeof(unk_opcodes), uo);
+		fclose(uo);
+	}
+
+	uo = fopen("unkopc.txt", "w");
+
+	if (uo)
+	{
+		for (i = 0; i < 0x10000; i++)
+		{
+			if (unk_opcodes[i])
+			{
+				count++;
+				fprintf(uo, "OP%04x\t%d", i, unk_opcodes[i]);
+
+				for (j = 15; j >= 0; j--)
+				{
+					if ((j & 0x3) == 3)
+					{
+						fprintf(uo, "\tb");
+					}
+
+					fprintf(uo, "%d", (i >> j) & 0x1);
+				}
+
+				fprintf(uo, "\n");
+			}
+		}
+
+		fprintf(uo, "Unknown opcodes count: %d\n", count);
+		fclose(uo);
+	}
+}
+
+
+void gd_dis_open_unkop()
+{
+	FILE* uo;
+
+	uo = fopen("uo.bin", "rb");
+
+	if (uo)
+	{
+		fread(unk_opcodes, 1, sizeof(unk_opcodes), uo);
+		fclose(uo);
+	}
+	else
+	{
+		int i;
+
+		for (i = 0; i < 0x10000; i++)
+		{
+			unk_opcodes[i] = 0;
+		}
+	}
+}
+
+
+const char* gd_dis_get_reg_name(uint16 reg)
+{
+	return(regnames[reg].name);
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/disassemble.h

@@ -0,0 +1,46 @@
+/*====================================================================
+
+   filename:     opcodes.h
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#pragma once
+
+typedef struct gd_globals_t
+{
+	bool print_tabs;
+	bool show_hex;
+	bool show_pc;
+	bool decode_names;
+	bool decode_registers;
+
+	uint16* binbuf;
+	uint16 pc;
+	char* buffer;
+	uint16 buffer_size;
+	char ext_separator;
+} gd_globals_t;
+
+
+char* gd_dis_opcode(gd_globals_t* gdg);
+bool gd_dis_file(gd_globals_t* gdg, char* name, FILE* output);
+const char* gd_dis_get_reg_name(uint16 reg);

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_aram.cpp

@@ -0,0 +1,114 @@
+// 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/
+#include "Globals.h"
+#include "gdsp_interface.h"
+
+extern uint16 dsp_swap16(uint16 x);
+
+
+// the hardware adpcm decoder :)
+sint16 ADPCM_Step(uint32& _rSamplePos, uint32 _BaseAddress)
+{
+	sint16* pCoefTable = (sint16*)&gdsp_ifx_regs[DSP_COEF_A1_0];
+
+	if (((_rSamplePos) & 15) == 0)
+	{
+		gdsp_ifx_regs[DSP_PRED_SCALE] = g_dspInitialize.pARAM_Read_U8((_rSamplePos & ~15) >> 1);
+		_rSamplePos += 2;
+	}
+
+	int scale = 1 << (gdsp_ifx_regs[DSP_PRED_SCALE] & 0xF);
+	int coef_idx = gdsp_ifx_regs[DSP_PRED_SCALE] >> 4;
+
+	sint32 coef1 = pCoefTable[coef_idx * 2 + 0];
+	sint32 coef2 = pCoefTable[coef_idx * 2 + 1];
+
+	int temp = (_rSamplePos & 1) ?
+		   (g_dspInitialize.pARAM_Read_U8(_rSamplePos >> 1) & 0xF) :
+		   (g_dspInitialize.pARAM_Read_U8(_rSamplePos >> 1) >> 4);
+
+	if (temp >= 8)
+	{
+		temp -= 16; //temp += 0xFFFFFFF0;
+	}
+
+	//0x400 = 0.5  in 11-bit fixed point
+	int val = (scale * temp) + ((0x400 + coef1 * (sint16)gdsp_ifx_regs[DSP_YN1] + coef2 * (sint16)gdsp_ifx_regs[DSP_YN2]) >> 11);
+
+	if (val > 0x7FFF)
+	{
+		val = 0x7FFF;
+	}
+	else if (val < -0x7FFF)
+	{
+		val = -0x7FFF;
+	}
+
+	gdsp_ifx_regs[DSP_YN2] = gdsp_ifx_regs[DSP_YN1];
+	gdsp_ifx_regs[DSP_YN1] = val;
+
+	_rSamplePos++;
+
+	return(val);
+
+    // I think the interpolation (linear, polyphase,...) is done by the UCode
+}
+
+
+uint16 dsp_read_aram()
+{
+	uint32 BaseAddress = (gdsp_ifx_regs[DSP_ACSAH] << 16) | gdsp_ifx_regs[DSP_ACSAL];
+	uint32 EndAddress = (gdsp_ifx_regs[DSP_ACEAH] << 16) | gdsp_ifx_regs[DSP_ACEAL];
+	uint32 Address = (gdsp_ifx_regs[DSP_ACCAH] << 16) | gdsp_ifx_regs[DSP_ACCAL];
+
+	uint16 val;
+
+	// lets the "hardware" decode
+	switch (gdsp_ifx_regs[DSP_FORMAT])
+	{
+	    case 0x00:
+		    val = ADPCM_Step(Address, EndAddress);
+		    break;
+
+	    case 0x0A:
+		    val = (g_dspInitialize.pARAM_Read_U8(Address) << 8) | g_dspInitialize.pARAM_Read_U8(Address + 1);
+
+		    gdsp_ifx_regs[DSP_YN2] = gdsp_ifx_regs[DSP_YN1];
+		    gdsp_ifx_regs[DSP_YN1] = val;
+
+		    Address += 2;
+		    break;
+
+	    default:
+		    val = (g_dspInitialize.pARAM_Read_U8(Address) << 8) | g_dspInitialize.pARAM_Read_U8(Address + 1);
+		    Address += 2;
+		    ErrorLog("Unknown DSP Format %i", gdsp_ifx_regs[DSP_FORMAT]);
+		    break;
+	}
+
+	// check for loop
+	if (Address > EndAddress)
+	{
+		Address = (gdsp_ifx_regs[DSP_ACSAH] << 16) | gdsp_ifx_regs[DSP_ACSAL];
+		//ErrorLog("Should we generate a lvl5 exception !??!");
+		//gdsp_exception(5);
+	}
+
+	gdsp_ifx_regs[DSP_ACCAH] = Address >> 16;
+	gdsp_ifx_regs[DSP_ACCAL] = Address & 0xffff;
+	return(val);
+}

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_aram.h

@@ -0,0 +1,19 @@
+// 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/
+#pragma once
+
+uint16 dsp_read_aram();

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_ext_op.cpp

@@ -0,0 +1,288 @@
+/*====================================================================
+
+   filename:     opcodes.h
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+//
+//
+// At the moment just ls and sl are using the prolog
+// perhaps all actions on r03 must be in the prolog
+//
+#include "Globals.h"
+
+#include "gdsp_ext_op.h"
+#include "gdsp_interpreter.h"
+#include "gdsp_memory.h"
+
+extern inline void dsp_op_write_reg(uint8 reg, uint16 val);
+
+
+//
+void dsp_op_ext_r_epi(uint16 _Opcode)
+{
+	uint8 op  = (_Opcode >> 2) & 0x3;
+	uint8 reg = _Opcode & 0x3;
+
+	switch (op)
+	{
+	    case 0x00:
+		    ErrorLog("dsp_op_ext_r_epi");
+		    break;
+
+	    case 0x01:
+		    g_dsp.r[reg]--;
+		    break;
+
+	    case 0x02:
+		    g_dsp.r[reg]++;
+		    break;
+
+	    case 0x03:
+		    g_dsp.r[reg] += g_dsp.r[reg + 4];
+		    break;
+	}
+}
+
+
+void dsp_op_ext_mv(uint16 _Opcode)
+{
+	uint8 sreg = _Opcode & 0x3;
+	uint8 dreg = ((_Opcode >> 2) & 0x3);
+
+	g_dsp.r[dreg + 0x18] = g_dsp.r[sreg + 0x1c];
+}
+
+
+void dsp_op_ext_s(uint16 _Opcode)
+{
+	uint8 dreg = _Opcode & 0x3;
+	uint8 sreg = ((_Opcode >> 3) & 0x3) + 0x1c;
+
+	dsp_dmem_write(g_dsp.r[dreg], g_dsp.r[sreg]);
+
+	if (_Opcode & 0x04)
+	{
+		g_dsp.r[dreg] += g_dsp.r[dreg + 4];
+	}
+	else
+	{
+		g_dsp.r[dreg]++;
+	}
+}
+
+
+void dsp_op_ext_l(uint16 _Opcode)
+{
+	uint8 sreg = _Opcode & 0x3;
+	uint8 dreg = ((_Opcode >> 3) & 0x7) + 0x18;
+
+	uint16 val = dsp_dmem_read(g_dsp.r[sreg]);
+	g_dsp.r[dreg] = val;
+
+	if (_Opcode & 0x04)
+	{
+		g_dsp.r[sreg] += g_dsp.r[sreg + 4];
+	}
+	else
+	{
+		g_dsp.r[sreg]++;
+	}
+}
+
+
+void dsp_op_ext_ls_pro(uint16 _Opcode)
+{
+	uint8 areg = (_Opcode & 0x1) + 0x1e;
+	dsp_dmem_write(g_dsp.r[0x03], g_dsp.r[areg]);
+
+	if (_Opcode & 0x8)
+	{
+		g_dsp.r[0x03] += g_dsp.r[0x07];
+	}
+	else
+	{
+		g_dsp.r[0x03]++;
+	}
+}
+
+
+void dsp_op_ext_ls_epi(uint16 _Opcode)
+{
+	uint8 dreg = ((_Opcode >> 4) & 0x3) + 0x18;
+	uint16 val = dsp_dmem_read(g_dsp.r[0x00]);
+	dsp_op_write_reg(dreg, val);
+
+	if (_Opcode & 0x4)
+	{
+		g_dsp.r[0x00] += g_dsp.r[0x04];
+	}
+	else
+	{
+		g_dsp.r[0x00]++;
+	}
+}
+
+
+void dsp_op_ext_sl_pro(uint16 _Opcode)
+{
+	uint8 areg = (_Opcode & 0x1) + 0x1e;
+	dsp_dmem_write(g_dsp.r[0x00], g_dsp.r[areg]);
+
+	if (_Opcode & 0x4)
+	{
+		g_dsp.r[0x00] += g_dsp.r[0x04];
+	}
+	else
+	{
+		g_dsp.r[0x00]++;
+	}
+}
+
+
+void dsp_op_ext_sl_epi(uint16 _Opcode)
+{
+	uint8 dreg = ((_Opcode >> 4) & 0x3) + 0x18;
+	uint16 val = dsp_dmem_read(g_dsp.r[0x03]);
+	dsp_op_write_reg(dreg, val);
+
+	if (_Opcode & 0x8)
+	{
+		g_dsp.r[0x03] += g_dsp.r[0x07];
+	}
+	else
+	{
+		g_dsp.r[0x03]++;
+	}
+}
+
+
+void dsp_op_ext_ld(uint16 _Opcode)
+{
+	uint8 dreg1 = (((_Opcode >> 5) & 0x1) << 1) + 0x18;
+	uint8 dreg2 = (((_Opcode >> 4) & 0x1) << 1) + 0x19;
+	uint8 sreg = _Opcode & 0x3;
+	g_dsp.r[dreg1] = dsp_dmem_read(g_dsp.r[sreg]);
+	g_dsp.r[dreg2] = dsp_dmem_read(g_dsp.r[0x03]);
+
+	if (_Opcode & 0x04)
+	{
+		g_dsp.r[sreg] += g_dsp.r[sreg + 0x04];
+	}
+	else
+	{
+		g_dsp.r[sreg]++;
+	}
+
+	if (_Opcode & 0x08)
+	{
+		g_dsp.r[0x03] += g_dsp.r[0x07];
+	}
+	else
+	{
+		g_dsp.r[0x03]++;
+	}
+}
+
+
+// ================================================================================
+//
+//
+//
+// ================================================================================
+
+void dsp_op_ext_ops_pro(uint16 _Opcode)
+{
+	if ((_Opcode & 0xFF) == 0){return;}
+
+	switch ((_Opcode >> 4) & 0xf)
+	{
+	    case 0x00:
+		    dsp_op_ext_r_epi(_Opcode);
+		    break;
+
+	    case 0x01:
+		    dsp_op_ext_mv(_Opcode);
+		    break;
+
+	    case 0x02:
+	    case 0x03:
+		    dsp_op_ext_s(_Opcode);
+		    break;
+
+	    case 0x04:
+	    case 0x05:
+	    case 0x06:
+	    case 0x07:
+		    dsp_op_ext_l(_Opcode);
+		    break;
+
+	    case 0x08:
+	    case 0x09:
+	    case 0x0a:
+	    case 0x0b:
+
+		    if (_Opcode & 0x2)
+		    {
+			    dsp_op_ext_sl_pro(_Opcode);
+		    }
+		    else
+		    {
+			    dsp_op_ext_ls_pro(_Opcode);
+		    }
+
+		    return;
+
+	    case 0x0c:
+	    case 0x0d:
+	    case 0x0e:
+	    case 0x0f:
+		    dsp_op_ext_ld(_Opcode);
+		    break;
+	}
+}
+
+
+void dsp_op_ext_ops_epi(uint16 _Opcode)
+{
+	if ((_Opcode & 0xFF) == 0){return;}
+
+	switch ((_Opcode >> 4) & 0xf)
+	{
+	    case 0x08:
+	    case 0x09:
+	    case 0x0a:
+	    case 0x0b:
+
+		    if (_Opcode & 0x2)
+		    {
+			    dsp_op_ext_sl_epi(_Opcode);
+		    }
+		    else
+		    {
+			    dsp_op_ext_ls_epi(_Opcode);
+		    }
+
+		    return;
+	}
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_ext_op.h

@@ -0,0 +1,33 @@
+/*====================================================================
+
+   filename:     opcodes.h
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#ifndef _GDSP_EXT_OP_H
+#define _GDSP_EXT_OP_H
+
+void dsp_op_ext_ops_pro(uint16 _Opcode);
+void dsp_op_ext_ops_epi(uint16 _Opcode);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_ifx.h

@@ -0,0 +1,35 @@
+/*====================================================================
+
+   filename:     gdsp_ifx.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+// ADPCM hw
+
+#ifndef _GDSP_IFX_H
+#define _GDSP_IFX_H
+
+void gdsp_ifx_write(uint16 addr, uint16 val);
+uint16 gdsp_ifx_read(uint16 addr);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_interface.cpp

@@ -0,0 +1,350 @@
+/*====================================================================
+
+   filename:     gdsp_interface.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include <stdlib.h>
+#include "Globals.h"
+
+#include "gdsp_aram.h"
+#include "gdsp_interpreter.h"
+#include "gdsp_interface.h"
+
+#include "Tools.h"
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifndef _WIN32
+#undef WITH_DSP_ON_THREAD
+//TODO FIX
+#endif
+
+const char* reg_names[] =
+{
+	// a0
+	"COEF_A1_0", "COEF_A2_0", "COEF_A1_1", "COEF_A2_1", "COEF_A1_2", "COEF_A2_2", "COEF_A1_3", "COEF_A2_3",
+	"COEF_A1_4", "COEF_A2_4", "COEF_A1_5", "COEF_A2_5", "COEF_A1_6", "COEF_A2_6", "COEF_A1_7", "COEF_A2_7",
+	// b0
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,
+	// c0
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,
+	NULL,   "DSCR",  NULL,   "DSBL",  NULL,   "DSPA",  "DSMAH", "DSMAL",
+	// d0
+	NULL,       "SampleFormat",  NULL,           NULL,   "ACSAH", "ACSAL", "ACEAH", "ACEAL",
+	"ACCAH", "ACCAL",     "PRED_SCALE",    "YN1",   "YN2",       "ARAM",      "GAIN",      NULL,
+	// e0
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "AMDM",
+	// f0
+	NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,
+	NULL,   NULL,   NULL,   NULL,   "DMBH", "DMBL", "CMBH", "CMBL",
+};
+
+
+void gdsp_dma();
+
+
+#ifdef _WIN32
+extern CRITICAL_SECTION g_CriticalSection;
+#endif
+
+static volatile uint16 gdsp_mbox[2][2];
+
+uint16 gdsp_ifx_regs[256];
+
+void gdsp_ifx_init()
+{
+	int i;
+
+	for (i = 0; i < 256; i++)
+	{
+		gdsp_ifx_regs[i] = 0;
+	}
+
+	gdsp_mbox[0][0] = 0;
+	gdsp_mbox[0][1] = 0;
+	gdsp_mbox[1][0] = 0;
+	gdsp_mbox[1][1] = 0;
+}
+
+
+uint32 gdsp_mbox_peek(uint8 mbx)
+{
+	return((gdsp_mbox[mbx][0] << 16) | gdsp_mbox[mbx][1]);
+}
+
+
+void gdsp_mbox_write_h(uint8 mbx, uint16 val)
+{
+#if WITH_DSP_ON_THREAD
+	EnterCriticalSection(&g_CriticalSection);
+#endif
+
+	gdsp_mbox[mbx][0] = val & 0x7fff;
+
+#if WITH_DSP_ON_THREAD
+	LeaveCriticalSection(&g_CriticalSection);
+#endif
+}
+
+
+void gdsp_mbox_write_l(uint8 mbx, uint16 val)
+{
+#if WITH_DSP_ON_THREAD
+	EnterCriticalSection(&g_CriticalSection);
+#endif
+
+	gdsp_mbox[mbx][1]  = val;
+	gdsp_mbox[mbx][0] |= 0x8000;
+
+#if WITH_DSP_ON_THREAD
+	LeaveCriticalSection(&g_CriticalSection);
+#endif
+
+	if (mbx == GDSP_MBOX_DSP)
+	{
+		DebugLog("- Write DSP Mail: 0x%08x (pc=0x%04x)\n", gdsp_mbox_peek(GDSP_MBOX_DSP), g_dsp.err_pc);
+	}
+}
+
+
+uint16 gdsp_mbox_read_h(uint8 mbx)
+{
+	return(gdsp_mbox[mbx][0]);
+}
+
+
+uint16 gdsp_mbox_read_l(uint8 mbx)
+{
+	uint16 val;
+#if WITH_DSP_ON_THREAD
+	EnterCriticalSection(&g_CriticalSection);
+#endif
+
+	val = gdsp_mbox[mbx][1];
+	gdsp_mbox[mbx][0] &= ~0x8000;
+
+#if WITH_DSP_ON_THREAD
+	LeaveCriticalSection(&g_CriticalSection);
+#endif
+	return(val);
+}
+
+
+void gdsp_ifx_write(uint16 addr, uint16 val)
+{
+	addr &= 0xff;
+
+	switch (addr & 0xff)
+	{
+	    case 0xfb: // DIRQ
+
+		    if (val & 0x1)
+		    {
+			    g_dsp.irq_request();
+		    }
+
+		    break;
+
+	    case 0xfc: // DMBH
+		    gdsp_mbox_write_h(GDSP_MBOX_DSP, val);
+		    break;
+
+	    case 0xfd: // DMBL
+		    gdsp_mbox_write_l(GDSP_MBOX_DSP, val);
+		    break;
+
+	    case 0xcb: // DSBL
+		    gdsp_ifx_regs[addr] = val;
+		    gdsp_dma();
+		    gdsp_ifx_regs[DSP_DSCR] &= ~0x0004;
+		    break;
+
+	    case 0xcd:
+	    case 0xce:
+	    case 0xcf:
+	    case 0xc9:
+		    gdsp_ifx_regs[addr] = val;
+		    break;
+
+	    default:
+/*		if ((addr & 0xff) >= 0xa0 && reg_names[addr - 0xa0])
+   	    DebugLog("%04x MW %s (%04x)\n", g_dsp.pc, reg_names[addr - 0xa0], val);
+   	else
+   	    DebugLog("%04x MW %04x (%04x)\n", g_dsp.pc, addr, val);*/
+		    gdsp_ifx_regs[addr] = val;
+		    break;
+	}
+}
+
+
+uint16 gdsp_ifx_read(uint16 addr)
+{
+	uint16 val;
+
+	addr &= 0xff;
+
+	switch (addr & 0xff)
+	{
+	    case 0xfc: // DMBH
+		    val = gdsp_mbox_read_h(GDSP_MBOX_DSP);
+		    break;
+
+	    case 0xfe: // CMBH
+		    val = gdsp_mbox_read_h(GDSP_MBOX_CPU);
+		    break;
+
+	    case 0xff: // CMBL
+		    val = gdsp_mbox_read_l(GDSP_MBOX_CPU);
+		    break;
+
+	    case 0xc9:
+		    val = gdsp_ifx_regs[addr];
+		    break;
+
+	    case 0xdd:
+		    val = dsp_read_aram();
+		    break;
+
+	    default:
+		    val = gdsp_ifx_regs[addr];
+/*		if ((addr & 0xff) >= 0xc0 && reg_names[addr & 0x3f])
+   	    printf("%04x MR %s (%04x)\n", g_dsp.pc, reg_names[addr & 0x3f], val);
+   	else
+   	    printf("%04x MR %04x (%04x)\n", g_dsp.pc, addr, val);*/
+		    break;
+	}
+
+	return(val);
+}
+
+
+void gdsp_idma_in(uint16 dsp_addr, uint32 addr, uint32 size)
+{
+#if DUMP_DSP_IMEM
+	DumpDSPCode(addr, size);
+#endif
+
+	uint8* dst = ((uint8*)g_dsp.iram);
+
+	for (uint32 i = 0; i < size; i += 2)
+	{
+		*(uint16*)&dst[dsp_addr + i] = *(uint16*)&g_dsp.cpu_ram[(addr + i) & 0x0fffffff];
+	}
+
+	g_dsp.iram_crc = GenerateCRC(g_dsp.cpu_ram + (addr & 0x0fffffff), size);
+	DebugLog("*** Copy new UCode from 0x%08x to 0x%04x (crc: %8x)\n", addr, dsp_addr, g_dsp.iram_crc);
+}
+
+
+void gdsp_idma_out(uint16 dsp_addr, uint32 addr, uint32 size)
+{
+	ErrorLog("*** idma_out IRAM_DSP (0x%04x) -> RAM (0x%08x) : size (0x%08x)\n", dsp_addr / 2, addr, size);
+}
+
+
+void gdsp_ddma_in(uint16 dsp_addr, uint32 addr, uint32 size)
+{
+	if ((addr & 0x7FFFFFFF) > 0x01FFFFFF)
+	{
+		ErrorLog("*** ddma_in read from invalid addr (0x%08x)\n", addr);
+		return;
+	}
+
+	uint8* dst = ((uint8*)g_dsp.dram);
+
+	for (uint32 i = 0; i < size; i += 2)
+	{
+		*(uint16*)&dst[dsp_addr + i] = *(uint16*)&g_dsp.cpu_ram[(addr + i) & 0x7FFFFFFF];
+	}
+
+	DebugLog("*** ddma_in RAM (0x%08x) -> DRAM_DSP (0x%04x) : size (0x%08x)\n", addr, dsp_addr / 2, size);
+}
+
+
+void gdsp_ddma_out(uint16 dsp_addr, uint32 addr, uint32 size)
+{
+	if ((addr & 0x7FFFFFFF) > 0x01FFFFFF)
+	{
+		ErrorLog("*** gdsp_ddma_out to invalid addr (0x%08x)\n", addr);
+		return;
+	}
+
+	uint8* src = ((uint8*)g_dsp.dram);
+
+	for (uint32 i = 0; i < size; i += 2)
+	{
+		*(uint16*)&g_dsp.cpu_ram[(addr + i) & 0x7FFFFFFF] = *(uint16*)&src[dsp_addr + i];
+	}
+
+	DebugLog("*** ddma_out DRAM_DSP (0x%04x) -> RAM (0x%08x) : size (0x%08x)\n", dsp_addr / 2, addr, size);
+}
+
+
+#define DSP_CR_IMEM     (2)
+#define DSP_CR_DMEM     (0)
+#define DSP_CR_TO_CPU   (1)
+#define DSP_CR_FROM_CPU (0)
+
+void gdsp_dma()
+{
+	uint16 ctl;
+	uint32 addr;
+	uint16 dsp_addr;
+	uint16 len;
+
+	addr = (gdsp_ifx_regs[DSP_DSMAH] << 16) | gdsp_ifx_regs[DSP_DSMAL];
+	ctl = gdsp_ifx_regs[DSP_DSCR];
+	dsp_addr = gdsp_ifx_regs[DSP_DSPA] * 2;
+	len = gdsp_ifx_regs[DSP_DSBL];
+
+	if ((ctl > 3) || (len > 0x4000))
+	{
+		ErrorLog("DMA ERROR pc: %04x ctl: %04x addr: %08x da: %04x size: %04x\n", g_dsp.pc, ctl, addr, dsp_addr, len);
+		exit(0);
+	}
+
+	switch (ctl & 0x3)
+	{
+	    case (DSP_CR_DMEM | DSP_CR_TO_CPU):
+		    gdsp_ddma_out(dsp_addr, addr, len);
+		    break;
+
+	    case (DSP_CR_DMEM | DSP_CR_FROM_CPU):
+		    gdsp_ddma_in(dsp_addr, addr, len);
+		    break;
+
+	    case (DSP_CR_IMEM | DSP_CR_TO_CPU):
+		    gdsp_idma_out(dsp_addr, addr, len);
+		    break;
+
+	    case (DSP_CR_IMEM | DSP_CR_FROM_CPU):
+		    gdsp_idma_in(dsp_addr, addr, len);
+		    break;
+	}
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_interface.h

@@ -0,0 +1,67 @@
+/*====================================================================
+
+   filename:     gdsp_interface.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+#ifndef _GDSP_INTERFACE_H
+#define _GDSP_INTERFACE_H
+
+#include "Globals.h"
+
+#define GDSP_MBOX_CPU   0
+#define GDSP_MBOX_DSP   1
+
+#define DSP_DSMAH   0xce
+#define DSP_DSMAL   0xcf
+#define DSP_DSCR    0xc9
+#define DSP_DSPA    0xcd
+#define DSP_DSBL    0xcb
+#define DSP_ACSAH   0xd4
+#define DSP_ACSAL   0xd5
+#define DSP_ACEAH   0xd6
+#define DSP_ACEAL   0xd7
+#define DSP_ACCAH   0xd8
+#define DSP_ACCAL   0xd9
+
+#define DSP_COEF_A1_0   0xa0
+#define DSP_FORMAT      0xd1
+#define DSP_PRED_SCALE  0xda
+#define DSP_YN1         0xdb
+#define DSP_YN2         0xdc
+#define DSP_ARAM        0xdd
+#define DSP_GAIN        0xde
+
+extern uint16 gdsp_ifx_regs[256];
+
+uint32  gdsp_mbox_peek(uint8 mbx);
+void    gdsp_mbox_write_h(uint8 mbx, uint16 val);
+void    gdsp_mbox_write_l(uint8 mbx, uint16 val);
+uint16  gdsp_mbox_read_h(uint8 mbx);
+uint16  gdsp_mbox_read_l(uint8 mbx);
+
+void    gdsp_ifx_init();
+
+void    gdsp_idma_in(uint16 dsp_addr, uint32 addr, uint32 size);
+
+
+#endif
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_interpreter.cpp

@@ -0,0 +1,344 @@
+/*====================================================================
+
+   filename:     gdsp_interpreter.cpp
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "gdsp_opcodes.h"
+#include "gdsp_interpreter.h"
+#include "gdsp_memory.h"
+#include "gdsp_registers.h"
+#include "gdsp_interface.h"
+#include "Tools.h"
+
+//-------------------------------------------------------------------------------
+
+SDSP g_dsp;
+
+uint16 SDSP::r[32];
+uint16 SDSP::pc = 0;
+uint16 SDSP::err_pc = 0;
+uint16* SDSP::iram   = 0;
+uint16* SDSP::dram   = 0;
+uint16* SDSP::irom   = 0;
+uint16* SDSP::drom   = 0;
+uint16* SDSP::coef   = 0;
+uint8* SDSP::cpu_ram = 0;
+uint16 SDSP::cr = 0;
+uint8 SDSP::reg_stack_ptr[4];
+// lets make stack depth to 32 for now
+uint16 SDSP::reg_stack[4][DSP_STACK_DEPTH];
+void (*SDSP::irq_request)() = NULL;
+bool SDSP::exception_in_progress_hack = false;
+
+// for debugger only
+uint32 SDSP::iram_crc = 0;
+uint64 SDSP::step_counter = 0;
+
+
+//-------------------------------------------------------------------------------
+
+static bool CR_HALT = true;
+static bool CR_EXTERNAL_INT = false;
+
+void UpdateCachedCR()
+{
+	CR_HALT = (g_dsp.cr & 0x4) != 0;
+	CR_EXTERNAL_INT = (g_dsp.cr & 0x02) != 0;
+}
+
+
+
+//-------------------------------------------------------------------------------
+void (*dsp_op[])(uint16 opc) =
+{
+	dsp_op0, dsp_op1, dsp_op2, dsp_op3,
+	dsp_op4, dsp_op5, dsp_op6, dsp_op7,
+	dsp_op8, dsp_op9, dsp_opab, dsp_opab,
+	dsp_opcd, dsp_opcd, dsp_ope, dsp_opf,
+};
+
+void dbg_error(char* err_msg)
+{
+	return;
+}
+
+
+void gdsp_init()
+{
+	g_dsp.irom = (uint16*)malloc(DSP_IROM_SIZE * sizeof(uint16));
+	g_dsp.iram = (uint16*)malloc(DSP_IRAM_SIZE * sizeof(uint16));
+	g_dsp.drom = (uint16*)malloc(DSP_DROM_SIZE * sizeof(uint16));
+	g_dsp.dram = (uint16*)malloc(DSP_DRAM_SIZE * sizeof(uint16));
+	g_dsp.coef = (uint16*)malloc(DSP_COEF_SIZE * sizeof(uint16));
+
+	for (int i = 0; i < DSP_IRAM_SIZE; i++)
+	{
+		g_dsp.iram[i] = 0x0021; // HALT opcode
+	}
+
+	for (int i = 0; i < DSP_DRAM_SIZE; i++)
+	{
+		g_dsp.dram[i] = 0x0021; // HALT opcode
+	}
+
+	for (int i = 0; i < 32; i++)
+	{
+		g_dsp.r[i] = 0;
+	}
+
+	for (int i = 0; i < 4; i++)
+	{
+		g_dsp.reg_stack_ptr[i] = 0;
+
+		for (int j = 0; j < DSP_STACK_DEPTH; j++)
+		{
+			g_dsp.reg_stack[i][j] = 0;
+		}
+	}
+
+	// copied from a real console after the custom UCode has been loaded
+	g_dsp.r[0x08] = 0xffff;
+	g_dsp.r[0x09] = 0xffff;
+	g_dsp.r[0x0a] = 0xffff;
+	g_dsp.r[0x0b] = 0xffff;
+
+	g_dsp.cr = 0x804;
+	gdsp_ifx_init();
+
+	UpdateCachedCR();
+}
+
+
+void gdsp_reset()
+{
+//	_dbg_assert_msg_(0, "gdsp_reset()");
+	_dbg_assert_msg_(!g_dsp.exception_in_progress_hack, "assert while exception");
+	g_dsp.pc = DSP_RESET_VECTOR;
+	g_dsp.exception_in_progress_hack = false;
+}
+
+
+void gdsp_generate_exception(uint8 level)
+{
+	_dbg_assert_msg_(!g_dsp.exception_in_progress_hack, "assert while exception");
+
+	dsp_reg_store_stack(DSP_STACK_C, g_dsp.pc);
+	dsp_reg_store_stack(DSP_STACK_D, g_dsp.r[R_SR]);
+
+	g_dsp.pc = level * 2;
+
+	g_dsp.exception_in_progress_hack = true;
+}
+
+
+uint32 gdsp_exception_ready = 0;
+
+void gdsp_exception(uint8 level)
+{
+	switch (level & 0x7)
+	{
+	    case 0x5: // ACCA > ACCH exception
+
+		    if (g_dsp.r[R_SR] & 0x200)
+		    {
+			    gdsp_exception_ready = level;
+		    }
+
+		    break;
+
+	    default:
+		    break;
+	}
+}
+
+
+bool gdsp_load_rom(char* fname)
+{
+	FILE* pFile = fopen(fname, "rb");
+
+	if (pFile)
+	{
+		fread(g_dsp.irom, 1, DSP_IRAM_SIZE, pFile);
+		fclose(pFile);
+		return(true);
+	}
+
+	return(false);
+}
+
+
+bool gdsp_load_coef(char* fname)
+{
+	FILE* pFile = fopen(fname, "rb");
+
+	if (pFile)
+	{
+		fread(g_dsp.coef, 1, DSP_COEF_SIZE, pFile);
+		fclose(pFile);
+		return(true);
+	}
+
+	return(false);
+}
+
+
+void gdsp_write_cr(uint16 val)
+{
+	// reset
+	if (val & 0x0001)
+	{
+		gdsp_reset();
+	}
+
+	val &= ~0x0001;
+
+	// update cr
+	g_dsp.cr = val;
+
+	UpdateCachedCR();
+}
+
+
+uint16  gdsp_read_cr()
+{
+	if (g_dsp.pc & 0x8000)
+	{
+		g_dsp.cr |= 0x800;
+	}
+	else
+	{
+		g_dsp.cr &= ~0x800;
+	}
+
+	UpdateCachedCR();
+
+	return(g_dsp.cr);
+}
+
+
+// special loop step.. because exception in loop or loopi fails
+// dunno how we have to fix it
+// atm we execute this instructions directly inside the loop command
+// so it cant be interrupted by an exception
+void gdsp_loop_step()
+{
+	g_dsp.err_pc = g_dsp.pc;
+	uint16 opc = dsp_fetch_code();
+	dsp_op[opc >> 12](opc);
+}
+
+
+void gdsp_step()
+{
+	g_dsp.step_counter++;
+
+	g_dsp.err_pc = g_dsp.pc;
+	uint16 opc = dsp_fetch_code();
+	dsp_op[opc >> 12](opc);
+
+	uint16& rLoopCounter = g_dsp.r[DSP_REG_ST0 + 3];
+
+	if (rLoopCounter > 0)
+	{
+		const uint16& rCallAddress = g_dsp.r[DSP_REG_ST0 + 0];
+		const uint16& rLoopAddress = g_dsp.r[DSP_REG_ST0 + 2];
+
+		if (g_dsp.pc == (rLoopAddress + 1))
+		{
+			rLoopCounter--;
+
+			if (rLoopCounter > 0)
+			{
+				g_dsp.pc = rCallAddress;
+			}
+			else
+			{
+				// end of loop
+				dsp_reg_load_stack(0);
+				dsp_reg_load_stack(2);
+				dsp_reg_load_stack(3);
+			}
+		}
+	}
+
+	// check if there is an external interrupt
+	if  (CR_EXTERNAL_INT)
+	{
+		if (dsp_SR_is_flag_set(FLAG_ENABLE_INTERUPT) && (g_dsp.exception_in_progress_hack == false))
+		{
+			gdsp_generate_exception(7);
+			g_dsp.cr &= ~0x0002;
+			UpdateCachedCR();
+		}
+
+		// level 7 is the interrupt exception
+		gdsp_exception_ready = 7;
+	}
+
+}
+
+
+bool gdsp_running;
+extern volatile uint32 dsp_running;
+
+bool gdsp_run()
+{
+	gdsp_running = true;
+
+	while (!CR_HALT)
+	{
+		gdsp_step();
+	}
+
+	gdsp_running = false;
+	return(true);
+}
+
+
+bool gdsp_runx(uint16 cnt)
+{
+	gdsp_running = true;
+
+	while (!(g_dsp.cr & 0x4) && gdsp_running)
+	{
+		gdsp_step();
+		cnt--;
+
+		if (cnt == 0)
+		{
+			break;
+		}
+	}
+
+	gdsp_running = false;
+	return(true);
+}
+
+
+void gdsp_stop()
+{
+	gdsp_running = false;
+}
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_interpreter.h

@@ -0,0 +1,95 @@
+/*====================================================================
+
+   filename:     gdsp_interpreter.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#ifndef _GDSP_INTERPRETER_H
+#define _GDSP_INTERPRETER_H
+
+#include "Globals.h"
+
+#define DSP_IRAM_SIZE   (0x1000)
+#define DSP_IRAM_MASK   (0x0fff)
+#define DSP_IROM_SIZE   (0x1000)
+#define DSP_IROM_MASK   (0x0fff)
+#define DSP_DRAM_SIZE   (0x1000)
+#define DSP_DRAM_MASK   (0x0fff)
+#define DSP_DROM_SIZE   (0x1000)
+#define DSP_DROM_MASK   (0x0fff)
+#define DSP_COEF_SIZE   (0x1000)
+#define DSP_COEF_MASK   (0x0fff)
+
+#define DSP_RESET_VECTOR    (0x8000)
+
+#define DSP_STACK_DEPTH 0x20
+#define DSP_STACK_MASK  0x1f
+
+struct SDSP
+{
+	static uint16 r[32];
+	static uint16 pc;
+	static uint16 err_pc;
+	static uint16* iram;
+	static uint16* dram;
+	static uint16* irom;
+	static uint16* drom;
+	static uint16* coef;
+	static uint8* cpu_ram;
+	static uint16 cr;
+	static uint8 reg_stack_ptr[4];
+	// lets make stack depth to 32 for now
+	static uint16 reg_stack[4][DSP_STACK_DEPTH];
+	static void (* irq_request)(void);
+
+	// for debugger only
+	static uint32 iram_crc;
+	static uint64 step_counter;
+	static bool exception_in_progress_hack;
+};
+
+extern SDSP g_dsp;
+
+
+void gdsp_init(void);
+void gdsp_reset(void);
+bool gdsp_load_rom(char* fname);
+bool gdsp_load_coef(char* fname);
+
+
+// steps through DSP code, returns false if error occured
+void gdsp_step(void);
+void gdsp_loop_step();
+bool gdsp_run(void);
+bool gdsp_runx(uint16 cnt);
+void gdsp_stop(void);
+
+void    gdsp_write_cr(uint16 val);
+uint16  gdsp_read_cr(void);
+
+uint16* gdsp_get_iram(void);
+uint16* gdsp_get_irom(void);
+uint16* gdsp_get_dram(void);
+uint16* gdsp_get_drom(void);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_memory.cpp

@@ -0,0 +1,156 @@
+/*====================================================================
+
+   filename:     gdsp_memory.cpp
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include <stdio.h>
+#include "Globals.h"
+#include "gdsp_interpreter.h"
+#include "gdsp_memory.h"
+#include "gdsp_ifx.h"
+
+uint16 dsp_swap16(uint16 x)
+{
+	return((x >> 8) | (x << 8));
+}
+
+
+uint16* gdsp_get_iram(void)
+{
+	return(g_dsp.iram);
+}
+
+
+uint16* gdsp_get_irom(void)
+{
+	return(g_dsp.irom);
+}
+
+
+uint16* gdsp_get_dram(void)
+{
+	return(g_dsp.dram);
+}
+
+
+uint16* gdsp_get_drom(void)
+{
+	return(g_dsp.drom);
+}
+
+
+uint16 dsp_imem_read(uint16 addr)
+{
+	uint16 opc;
+
+	if (g_dsp.pc & 0x8000)
+	{
+		opc = g_dsp.irom[addr & DSP_IROM_MASK];
+	}
+	else
+	{
+		opc = g_dsp.iram[addr & DSP_IRAM_MASK];
+	}
+
+	return(dsp_swap16(opc));
+}
+
+
+uint16  dsp_dmem_read(uint16 addr)
+{
+	uint16 val;
+
+	switch (addr >> 12)
+	{
+	    case 0x1: // 1xxx COEF
+		    val = g_dsp.coef[addr & DSP_DROM_MASK];
+		    val = dsp_swap16(val);
+		    break;
+
+	    case 0x8: // 8xxx DROM
+		    DebugLog("someone reads from ROM\n");
+		    val = g_dsp.drom[addr & DSP_DROM_MASK];
+		    val = dsp_swap16(val);
+		    break;
+
+	    case 0xf: // Fxxx HW regs
+		    val = gdsp_ifx_read(addr);
+		    break;
+
+	    case 0x0: // 0xxx DRAM
+		    val = g_dsp.dram[addr & DSP_DRAM_MASK];
+		    val = dsp_swap16(val);
+		    break;
+
+	    default: // error
+//		ErrorLog("%04x DSP ERROR: Read from UNKNOWN (%04x) memory\n", g_dsp.pc, addr);
+		    val = 0;
+		    break;
+	}
+
+	return(val);
+}
+
+
+bool dsp_dmem_write(uint16 addr, uint16 val)
+{
+	switch (addr >> 12)
+	{
+	    case 0x8: // 8xxx DROM
+		    DebugLog("someone writes to ROM\n");
+		    /* val = dsp_swap16(val);
+		       g_dsp.drom[addr & DSP_DROM_MASK] = val;*/
+		    break;
+
+	    case 0xf: // Fxxx HW regs
+		    gdsp_ifx_write(addr, val);
+		    break;
+
+	    case 0x0: // 0xxx DRAM
+		    val = dsp_swap16(val);
+		    g_dsp.dram[addr & DSP_DRAM_MASK] = val;
+		    break;
+
+	    default: // error
+		    DebugLog("%04x DSP ERROR: Write to UNKNOWN (%04x) memory\n", g_dsp.pc, addr);
+		    break;
+	}
+
+	return(true);
+}
+
+
+uint16 dsp_fetch_code(void)
+{
+	uint16 opc = dsp_imem_read(g_dsp.pc);
+	g_dsp.pc++;
+	return(opc);
+}
+
+
+uint16 dsp_peek_code(void)
+{
+	return(dsp_imem_read(g_dsp.pc));
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_memory.h

@@ -0,0 +1,37 @@
+/*====================================================================
+
+   filename:     gdsp_memory.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+#ifndef _GDSP_MEMORY_H
+#define _GDSP_MEMORY_H
+
+#include "Globals.h"
+
+uint16  dsp_fetch_code(void);
+uint16 dsp_peek_code(void);
+uint16  dsp_imem_read(uint16 addr);
+bool    dsp_dmem_write(uint16 addr, uint16 val);
+uint16  dsp_dmem_read(uint16 addr);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_opcodes.h

@@ -0,0 +1,53 @@
+/*====================================================================
+
+   filename:     gdsp_opcodes.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+#ifndef _GDSP_OPCODES_H
+#define _GDSP_OPCODES_H
+
+#include "Globals.h"
+
+void dsp_op0(uint16 opc);
+void dsp_op1(uint16 opc);
+void dsp_op2(uint16 opc);
+void dsp_op3(uint16 opc);
+void dsp_op4(uint16 opc);
+void dsp_op5(uint16 opc);
+void dsp_op6(uint16 opc);
+void dsp_op7(uint16 opc);
+void dsp_op8(uint16 opc);
+void dsp_op9(uint16 opc);
+void dsp_opab(uint16 opc);
+void dsp_opcd(uint16 opc);
+void dsp_ope(uint16 opc);
+void dsp_opf(uint16 opc);
+
+
+#define R_SR            0x13
+
+#define FLAG_ENABLE_INTERUPT    11
+
+extern inline bool dsp_SR_is_flag_set(uint8 flag);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_opcodes_helper.h

@@ -0,0 +1,227 @@
+/*====================================================================
+
+   filename:     opcodes.h
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#ifndef _GDSP_OPCODES_HELPER_H
+#define _GDSP_OPCODES_HELPER_H
+
+#include "Globals.h"
+// ---------------------------------------------------------------------------------------
+//
+// --- SR
+//
+// ---------------------------------------------------------------------------------------
+
+inline void dsp_SR_set_flag(uint8 flag)
+{
+	g_dsp.r[R_SR] |= (1 << flag);
+}
+
+
+inline bool dsp_SR_is_flag_set(uint8 flag)
+{
+	return((g_dsp.r[R_SR] & (1 << flag)) > 0);
+}
+
+
+// ---------------------------------------------------------------------------------------
+//
+// --- reg
+//
+// ---------------------------------------------------------------------------------------
+
+inline uint16 dsp_op_read_reg(uint8 reg)
+{
+	uint16 val;
+
+	switch (reg & 0x1f)
+	{
+	    case 0x0c:
+	    case 0x0d:
+	    case 0x0e:
+	    case 0x0f:
+		    val = dsp_reg_load_stack(reg - 0x0c);
+		    break;
+
+	    default:
+		    val = g_dsp.r[reg];
+		    break;
+	}
+
+	return(val);
+}
+
+
+inline void dsp_op_write_reg(uint8 reg, uint16 val)
+{
+	switch (reg & 0x1f)
+	{
+	    case 0x0c:
+	    case 0x0d:
+	    case 0x0e:
+	    case 0x0f:
+		    dsp_reg_store_stack(reg - 0x0c, val);
+		    break;
+
+	    default:
+		    g_dsp.r[reg] = val;
+		    break;
+	}
+}
+
+
+// ---------------------------------------------------------------------------------------
+//
+// --- prod
+//
+// ---------------------------------------------------------------------------------------
+
+
+inline sint64 dsp_get_long_prod()
+{
+	sint64 val;
+	sint64 low_prod;
+	val   = (sint8)g_dsp.r[0x16];
+	val <<= 32;
+	low_prod  = g_dsp.r[0x15];
+	low_prod += g_dsp.r[0x17];
+	low_prod <<= 16;
+	low_prod |= g_dsp.r[0x14];
+	val += low_prod;
+	return(val);
+}
+
+
+inline void dsp_set_long_prod(sint64 val)
+{
+	g_dsp.r[0x14] = (uint16)val;
+	val >>= 16;
+	g_dsp.r[0x15] = (uint16)val;
+	val >>= 16;
+	g_dsp.r[0x16] = (uint16)val;
+	g_dsp.r[0x17] = 0;
+}
+
+
+// ---------------------------------------------------------------------------------------
+//
+// --- acc
+//
+// ---------------------------------------------------------------------------------------
+
+inline sint64 dsp_get_long_acc(uint8 reg)
+{
+	_dbg_assert_(reg < 2);
+	sint64 val;
+	sint64 low_acc;
+	val       = (sint8)g_dsp.r[0x10 + reg];
+	val     <<= 32;
+	low_acc   = g_dsp.r[0x1e + reg];
+	low_acc <<= 16;
+	low_acc  |= g_dsp.r[0x1c + reg];
+	val |= low_acc;
+	return(val);
+}
+
+
+inline uint64 dsp_get_ulong_acc(uint8 reg)
+{
+	_dbg_assert_(reg < 2);
+	uint64 val;
+	uint64 low_acc;
+	val       = (uint8)g_dsp.r[0x10 + reg];
+	val     <<= 32;
+	low_acc   = g_dsp.r[0x1e + reg];
+	low_acc <<= 16;
+	low_acc  |= g_dsp.r[0x1c + reg];
+	val |= low_acc;
+	return(val);
+}
+
+
+inline void dsp_set_long_acc(uint8 _reg, sint64 val)
+{
+	_dbg_assert_(_reg < 2);
+	g_dsp.r[0x1c + _reg] = (uint16)val;
+	val >>= 16;
+	g_dsp.r[0x1e + _reg] = (uint16)val;
+	val >>= 16;
+	g_dsp.r[0x10 + _reg] = (uint16)val;
+}
+
+
+inline sint16 dsp_get_acc_l(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	return(g_dsp.r[0x1c + _reg]);
+}
+
+
+inline sint16 dsp_get_acc_m(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	return(g_dsp.r[0x1e + _reg]);
+}
+
+
+sint16 dsp_get_acc_h(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	return(g_dsp.r[0x10 + _reg]);
+}
+
+
+// ---------------------------------------------------------------------------------------
+//
+// --- acx
+//
+// ---------------------------------------------------------------------------------------
+
+
+inline sint64 dsp_get_long_acx(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	sint64 val = (sint16)g_dsp.r[0x1a + _reg];
+	val <<= 16;
+	sint64 low_acc = g_dsp.r[0x18 + _reg];
+	val |= low_acc;
+	return(val);
+}
+
+
+inline sint16 dsp_get_ax_l(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	return(g_dsp.r[0x18 + _reg]);
+}
+
+
+inline sint16 dsp_get_ax_h(uint8 _reg)
+{
+	_dbg_assert_(_reg < 2);
+	return(g_dsp.r[0x1a + _reg]);
+}
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_registers.cpp

@@ -0,0 +1,62 @@
+/*====================================================================
+
+   filename:     gdsp_registers.cpp
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include "Globals.h"
+#include "gdsp_registers.h"
+#include "gdsp_interpreter.h"
+
+
+
+void dsp_reg_stack_push(uint8 stack_reg)
+{
+	g_dsp.reg_stack_ptr[stack_reg]++;
+	g_dsp.reg_stack_ptr[stack_reg] &= DSP_STACK_MASK;
+	g_dsp.reg_stack[stack_reg][g_dsp.reg_stack_ptr[stack_reg]] = g_dsp.r[DSP_REG_ST0 + stack_reg];
+}
+
+
+void dsp_reg_stack_pop(uint8 stack_reg)
+{
+	g_dsp.r[DSP_REG_ST0 + stack_reg] = g_dsp.reg_stack[stack_reg][g_dsp.reg_stack_ptr[stack_reg]];
+	g_dsp.reg_stack_ptr[stack_reg]--;
+	g_dsp.reg_stack_ptr[stack_reg] &= DSP_STACK_MASK;
+}
+
+
+void dsp_reg_store_stack(uint8 stack_reg, uint16 val)
+{
+	dsp_reg_stack_push(stack_reg);
+	g_dsp.r[DSP_REG_ST0 + stack_reg] = val;
+}
+
+
+uint16 dsp_reg_load_stack(uint8 stack_reg)
+{
+	uint16 val = g_dsp.r[DSP_REG_ST0 + stack_reg];
+	dsp_reg_stack_pop(stack_reg);
+	return(val);
+}
+
+

Source/Plugins/Plugin_DSP_LLE/Src/gdsp_registers.h

@@ -0,0 +1,42 @@
+/*====================================================================
+
+   filename:     gdsp_registers.h
+   project:      GCemu
+   created:      2004-6-18
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie & Tratax
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+#ifndef _GDSP_REGISTERS_H
+#define _GDSP_REGISTERS_H
+
+#include "Globals.h"
+
+#define DSP_REG_ST0 0x0c
+#define DSP_REG_ST1 0x0c
+#define DSP_REG_ST2 0x0c
+#define DSP_REG_ST3 0x0c
+
+#define DSP_STACK_C 0
+#define DSP_STACK_D 1
+
+void dsp_reg_store_stack(uint8 stack_reg, uint16 val);
+uint16 dsp_reg_load_stack(uint8 stack_reg);
+
+
+#endif

Source/Plugins/Plugin_DSP_LLE/Src/main.cpp

@@ -0,0 +1,291 @@
+// 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/
+
+#include "Globals.h"
+
+#include "gdsp_interpreter.h"
+#include "gdsp_interface.h"
+#include "disassemble.h"
+
+#ifdef _WIN32
+#include "DisAsmDlg.h"
+#include "DSoundStream.h"
+
+HINSTANCE g_hInstance = NULL;
+HANDLE g_hDSPThread = NULL;
+CRITICAL_SECTION g_CriticalSection;
+#endif
+
+DSPInitialize g_dspInitialize;
+CDisAsmDlg g_Dialog;
+
+#define GDSP_MBOX_CPU   0
+#define GDSP_MBOX_DSP   1
+
+
+uint32 g_LastDMAAddress = 0;
+uint32 g_LastDMASize = 0;
+
+BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
+		DWORD dwReason,             // reason called
+		LPVOID lpvReserved)         // reserved
+{
+	switch (dwReason)
+	{
+	    case DLL_PROCESS_ATTACH:
+		    break;
+
+	    case DLL_PROCESS_DETACH:
+		    break;
+
+	    default:
+		    break;
+	}
+
+	g_hInstance = hinstDLL;
+	return(TRUE);
+}
+
+
+void GetDllInfo(PLUGIN_INFO* _PluginInfo)
+{
+	_PluginInfo->Version = 0x0100;
+	_PluginInfo->Type = PLUGIN_TYPE_DSP;
+
+#ifndef _DEBUG
+	sprintf(_PluginInfo->Name, "Dolphin DSP-LLE Plugin  (DSound)");
+#else
+	sprintf(_PluginInfo->Name, "Dolphin DSP-LLE Plugin  Debug (DSound)");
+#endif
+}
+
+
+void DllAbout(HWND _hParent)
+{}
+
+
+void DllConfig(HWND _hParent)
+{}
+
+
+void DllDebugger(HWND _hParent)
+{
+#if defined (_DEBUG) && defined (_WIN32)
+	g_Dialog.Create(NULL); //_hParent);
+	g_Dialog.ShowWindow(SW_SHOW);
+#endif
+
+}
+
+
+DWORD WINAPI dsp_thread(LPVOID lpParameter)
+{
+	while (1)
+	{
+		if (!gdsp_run())
+		{
+			ErrorLog("*** DSP: CRITICAL ERROR ***\n");
+			//return 0;
+			exit(0);
+		}
+	}
+}
+
+
+DWORD WINAPI dsp_thread_debug(LPVOID lpParameter)
+{
+	while (1)
+	{
+		if (g_Dialog.CanDoStep())
+		{
+			gdsp_runx(1);
+		}
+		else
+		{
+			Sleep(100);
+		}
+	}
+}
+
+
+void DSP_DebugBreak()
+{
+#ifdef _WIN32
+#ifdef _DEBUG
+	g_Dialog.DebugBreak();
+#endif
+#endif
+}
+
+
+void dspi_req_dsp_irq()
+{
+	g_dspInitialize.pGenerateDSPInterrupt();
+}
+
+
+void Mixer(short* buffer, int numSamples, int bits, int rate, int channels)
+{}
+
+
+void DSP_Initialize(DSPInitialize _dspInitialize)
+{
+	{
+		g_dspInitialize = _dspInitialize;
+
+		gdsp_init();
+		g_dsp.step_counter = 0;
+		g_dsp.cpu_ram = g_dspInitialize.pGetMemoryPointer(0);
+		g_dsp.irq_request = dspi_req_dsp_irq;
+		gdsp_reset();
+
+		if (!gdsp_load_rom("data\\dsp_rom.bin"))
+		{
+			ErrorLog("Cannot load DSP ROM\n");
+		}
+
+		if (!gdsp_load_coef("data\\dsp_coef.bin"))
+		{
+			ErrorLog("Cannot load DSP COEF\n");
+		}
+
+
+/*		Dump UCode to file...
+   	FILE* t = fopen("e:\\hmm.txt", "wb");
+   	gd_globals_t gdg;
+   	gd_dis_file(&gdg, "D:\\DSP_UCode.bin", t);
+   	fclose(t);  */
+	}
+
+
+#if _DEBUG
+	g_hDSPThread = CreateThread(NULL, 0, dsp_thread_debug, 0, 0, NULL);
+
+#else
+	g_hDSPThread = CreateThread(NULL, 0, dsp_thread, 0, 0, NULL);
+#endif
+
+
+
+	InitializeCriticalSection(&g_CriticalSection);
+
+	DSound::DSound_StartSound((HWND)g_dspInitialize.hWnd, 32000, Mixer);
+}
+
+
+void DSP_Shutdown(void)
+{
+	if (g_hDSPThread != NULL)
+	{
+		TerminateThread(g_hDSPThread, 0);
+	}
+}
+
+
+unsigned __int16 DSP_WriteControlRegister(unsigned __int16 _uFlag)
+{
+	gdsp_write_cr(_uFlag);
+	return(gdsp_read_cr());
+}
+
+
+unsigned __int16 DSP_ReadControlRegister()
+{
+	return(gdsp_read_cr());
+}
+
+
+unsigned __int16 DSP_ReadMailboxHigh(bool _CPUMailbox)
+{
+	if (_CPUMailbox)
+	{
+		return(gdsp_mbox_read_h(GDSP_MBOX_CPU));
+	}
+	else
+	{
+		return(gdsp_mbox_read_h(GDSP_MBOX_DSP));
+	}
+}
+
+
+unsigned __int16 DSP_ReadMailboxLow(bool _CPUMailbox)
+{
+	if (_CPUMailbox)
+	{
+		return(gdsp_mbox_read_l(GDSP_MBOX_CPU));
+	}
+	else
+	{
+		return(gdsp_mbox_read_l(GDSP_MBOX_DSP));
+	}
+}
+
+
+void DSP_WriteMailboxHigh(bool _CPUMailbox, unsigned __int16 _uHighMail)
+{
+	if (_CPUMailbox)
+	{
+		if (gdsp_mbox_peek(GDSP_MBOX_CPU) & 0x80000000)
+		{
+			ErrorLog("Mailbox isnt empty ... strange");
+		}
+
+		gdsp_mbox_write_h(GDSP_MBOX_CPU, _uHighMail);
+	}
+	else
+	{
+		ErrorLog("CPU cant write to DSP mailbox");
+	}
+}
+
+
+void DSP_WriteMailboxLow(bool _CPUMailbox, unsigned __int16 _uLowMail)
+{
+	if (_CPUMailbox)
+	{
+		gdsp_mbox_write_l(GDSP_MBOX_CPU, _uLowMail);
+
+		DebugLog("Write CPU Mail: 0x%08x (pc=0x%04x)\n", gdsp_mbox_peek(GDSP_MBOX_CPU), g_dsp.err_pc);
+	}
+	else
+	{
+		ErrorLog("CPU cant write to DSP mailbox");
+	}
+}
+
+
+void DSP_Update()
+{
+	if (g_hDSPThread)
+	{
+		return;
+	}
+
+	if (g_Dialog.CanDoStep())
+	{
+		gdsp_runx(100);
+	}
+}
+
+
+void DSP_SendAIBuffer(unsigned __int32 _Address, unsigned __int32 _Size)
+{
+	uint32 Size = _Size * 16 * 2; // 16bit per sample, two channels
+
+	g_LastDMAAddress = _Address;
+	g_LastDMASize = Size;
+}

Source/Plugins/Plugin_DSP_LLE/Src/opcodes.cpp

@@ -0,0 +1,237 @@
+/*====================================================================
+
+   filename:     opcodes.cpp
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+
+#include "Globals.h"
+#include "opcodes.h"
+
+opc_t opcodes[] =
+{
+	{"NOP", 0x0000, 0xffff, 1, 0, {},},
+	{"HALT",    0x0021, 0xffff, 1, 0, {},},
+	{"RET", 0x02df, 0xffff, 1, 0, {},},
+	{"RETEQ",   0x02d5, 0xffff, 1, 0, {},},
+	{"RETNZ",   0x02dd, 0xffff, 1, 0, {},},
+	{"RTI", 0x02ff, 0xffff, 1, 0, {},},
+	{"CALL",    0x02bf, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+
+	{"CALLNE",  0x02b4, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+
+	{"IF_0",    0x0270, 0xffff, 1, 0, {},},
+	{"IF_1",    0x0271, 0xffff, 1, 0, {},},
+	{"IF_2",    0x0272, 0xffff, 1, 0, {},},
+	{"IF_3",    0x0273, 0xffff, 1, 0, {},},
+	{"IF_E",    0x0274, 0xffff, 1, 0, {},},
+	{"IF_Q",    0x0275, 0xffff, 1, 0, {},},
+	{"IF_R",    0x027c, 0xffff, 1, 0, {},},
+	{"IF_Z",    0x027d, 0xffff, 1, 0, {},},
+	{"IF_P",    0x027f, 0xffff, 1, 0, {},},
+
+	{"JX0", 0x0290, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JX1", 0x0291, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JX2", 0x0292, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JX3", 0x0293, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JNE", 0x0294, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JEQ", 0x0295, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JZR", 0x029c, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JNZ", 0x029d, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+	{"JMP", 0x029f, 0xffff, 2, 1, {{P_VAL, 2, 1, 0, 0xffff}},},
+
+	{"DAR", 0x0004, 0xfffc, 1, 1, {{P_REG, 1, 0, 0, 0x0003}},},
+	{"IAR", 0x0008, 0xfffc, 1, 1, {{P_REG, 1, 0, 0, 0x0003}},},
+
+	{"CALLR",   0x171f, 0xff1f, 1, 1, {{P_REG, 1, 0, 5, 0x00e0}},},
+	{"JMPR",    0x170f, 0xff1f, 1, 1, {{P_REG, 1, 0, 5, 0x00e0}},},
+
+	{"SBCLR",   0x1200, 0xfff8, 1, 1, {{P_IMM, 1, 0, 0, 0x0007}},},
+	{"SBSET",   0x1300, 0xfff8, 1, 1, {{P_IMM, 1, 0, 0, 0x0007}},},
+
+	{"LSL", 0x1400, 0xfec0, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x003f}},},
+	{"LSR", 0x1440, 0xfec0, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x003f}},},
+	{"ASL", 0x1480, 0xfec0, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x007f}},},
+	{"ASR", 0x14c0, 0xfec0, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x007f}},},
+
+
+	{"LRI", 0x0080, 0xffe0, 2, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_IMM, 2, 1, 0, 0xffff}},},
+	{"LR",      0x00c0, 0xffe0, 2, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_MEM, 2, 1, 0, 0xffff}},},
+	{"SR",      0x00e0, 0xffe0, 2, 2, {{P_MEM, 2, 1, 0, 0xffff}, {P_REG, 1, 0, 0, 0x001f}},},
+
+	{"MRR", 0x1c00, 0xfc00, 1, 2, {{P_REG, 1, 0, 5, 0x03e0}, {P_REG, 1, 0, 0, 0x001f}},},
+
+	{"SI",      0x1600, 0xff00, 2, 2, {{P_MEM, 1, 0, 0, 0x00ff}, {P_IMM, 2, 1, 0, 0xffff}},},
+
+	{"LRS", 0x2000, 0xf800, 1, 2, {{P_REG18, 1, 0, 8, 0x0700}, {P_MEM, 1, 0, 0, 0x00ff}},},
+	{"SRS", 0x2800, 0xf800, 1, 2, {{P_MEM, 1, 0, 0, 0x00ff}, {P_REG18, 1, 0, 8, 0x0700}},},
+
+	{"LRIS",    0x0800, 0xf800, 1, 2, {{P_REG18, 1, 0, 8, 0x0700}, {P_IMM, 1, 0, 0, 0x00ff}},},
+
+	{"ADDIS",   0x0400, 0xfe00, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x00ff}},},
+	{"CMPIS",   0x0600, 0xfe00, 1, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 1, 0, 0, 0x00ff}},},
+
+	{"ANDI",    0x0240, 0xfeff, 2, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+	{"ANDF",    0x02c0, 0xfeff, 2, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+
+	{"XORI",    0x0220, 0xfeff, 2, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+	{"ANDCF",   0x02a0, 0xfeff, 2, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+
+	{"ORI", 0x0260, 0xfeff, 2, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+	{"ORF", 0x02e0, 0xfeff, 2, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},},
+
+	{"ADDI",    0x0200, 0xfeff, 2, 2, {{P_ACC, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},}, // missing S64
+	{"CMPI",    0x0280, 0xfeff, 2, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_IMM, 2, 1, 0, 0xffff}},}, // missing S64
+
+	{"ILRR",    0x0210, 0xfedc, 1, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"ILRRI",   0x0218, 0xfedc, 1, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_PRG, 1, 0, 0, 0x0003}},},
+
+	// load and store value pointed by indexing reg and increment; LRR/SRR variants
+	{"LRRI",    0x1900, 0xff80, 1, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_PRG, 1, 0, 5, 0x0060}},},
+	{"LRRD",    0x1880, 0xff80, 1, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_PRG, 1, 0, 5, 0x0060}},},
+	{"LRRN",    0x1980, 0xff80, 1, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_PRG, 1, 0, 5, 0x0060}},},
+	{"LRR", 0x1800, 0xff80, 1, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_PRG, 1, 0, 5, 0x0060}},},
+	{"SRRI",    0x1b00, 0xff80, 1, 2, {{P_PRG, 1, 0, 5, 0x0060}, {P_REG, 1, 0, 0, 0x001f}},},
+	{"SRRD",    0x1a80, 0xff80, 1, 2, {{P_PRG, 1, 0, 5, 0x0060}, {P_REG, 1, 0, 0, 0x001f}},},
+	{"SRRN",    0x1b80, 0xff80, 1, 2, {{P_PRG, 1, 0, 5, 0x0060}, {P_REG, 1, 0, 0, 0x001f}},},
+	{"SRR", 0x1a00, 0xff80, 1, 2, {{P_PRG, 1, 0, 5, 0x0060}, {P_REG, 1, 0, 0, 0x001f}},},
+
+	{"LOOPI",   0x1000, 0xff00, 1, 1, {{P_IMM, 1, 0, 0, 0x00ff}},},
+	{"BLOOPI",  0x1100, 0xff00, 2, 2, {{P_IMM, 1, 0, 0, 0x00ff}, {P_VAL, 2, 1, 0, 0xffff}},},
+	{"LOOP",    0x0040, 0xffe0, 1, 1, {{P_REG, 1, 0, 0, 0x001f}},},
+	{"BLOOP",   0x0060, 0xffe0, 2, 2, {{P_REG, 1, 0, 0, 0x001f}, {P_VAL, 2, 1, 0, 0xffff}},},
+
+
+
+	// opcodes that can be extended
+	// extended opcodes, note size of opcode will be set to 0
+
+	{"NX",      0x8000, 0xffff, 1 | P_EXT, 0, {},},
+
+	{"S40", 0x8e00, 0xffff, 1 | P_EXT, 0, {},},
+	{"S16", 0x8f00, 0xffff, 1 | P_EXT, 0, {},},
+	{"M2",      0x8a00, 0xffff, 1 | P_EXT, 0, {},},
+	{"M0",      0x8b00, 0xffff, 1 | P_EXT, 0, {},},
+	{"CLR15",   0x8c00, 0xffff, 1 | P_EXT, 0, {},},
+	{"SET15",   0x8d00, 0xffff, 1 | P_EXT, 0, {},},
+
+	{"DECM",    0x7800, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"INCM",    0x7400, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"DEC", 0x7a00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"INC", 0x7600, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"NEG", 0x7c00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"TST", 0xb100, 0xf7ff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 11, 0x0800}},},
+	{"TSTAXH",  0x8600, 0xfeff, 1 | P_EXT, 1, {{P_REG1A, 1, 0, 8, 0x0100}},},
+	{"CMP", 0x8200, 0xffff, 1 | P_EXT, 0, {},},
+	{"CMPAXH",  0xc100, 0xe7ff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 12, 0x1000}, {P_REG1A, 1, 0, 11, 0x0800}},},
+
+	{"CLR", 0x8100, 0xf7ff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 11, 0x0800}},},
+	{"CLRP",    0x8400, 0xffff, 1 | P_EXT, 0, {},},
+
+	{"MOV", 0x6c00, 0xfeff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_ACCM_D, 1, 0, 8, 0x0100}},},
+	{"MOVAX",   0x6800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0200}},},
+	{"MOVR",    0x6000, 0xf8ff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0600}},},
+	{"MOVP",    0x6e00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MOVPZ",   0xfe00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"ADDPAXZ", 0xf800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 9, 0x0200}, {P_REG1A, 1, 0, 8, 0x0100}},},
+	{"ADDP",    0x4e00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"LSL16",   0xf000, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"LSR16",   0xf400, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"ASR16",   0x9100, 0xf7ff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 11, 0x0800}},},
+
+	{"XORR",    0x3000, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG1A, 1, 0, 9, 0x0200}},},
+	{"ANDR",    0x3400, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG1A, 1, 0, 9, 0x0200}},},
+	{"ORR", 0x3800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG1A, 1, 0, 9, 0x0200}},},
+	{"ANDC",    0x3C00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+	{"ORC", 0x3E00, 0xfeff, 1 | P_EXT, 1, {{P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"MULX",    0xa000, 0xe7ff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 11, 0x1000}, {P_REG19, 1, 0, 10, 0x0800}},},
+	{"MULXAC",  0xa400, 0xe6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x1000}, {P_REG19, 1, 0, 10, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULXMV",  0xa600, 0xe6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x1000}, {P_REG19, 1, 0, 10, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULXMVZ", 0xa200, 0xe6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x1000}, {P_REG19, 1, 0, 10, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"MUL", 0x9000, 0xf7ff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 11, 0x0800}, {P_REG1A, 1, 0, 11, 0x0800}},},
+	{"MULAC",   0x9400, 0xf6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x0800}, {P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULMV",   0x9600, 0xf6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x0800}, {P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULMVZ",  0x9200, 0xf6ff, 1 | P_EXT, 3, {{P_REG18, 1, 0, 11, 0x0800}, {P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"MULC",    0xc000, 0xe7ff, 1 | P_EXT, 2, {{P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 12, 0x1000}},},
+	{"MULCAC",  0xc400, 0xe6ff, 1 | P_EXT, 3, {{P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 12, 0x1000}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULCMV",  0xc600, 0xe6ff, 1 | P_EXT, 3, {{P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 12, 0x1000}, {P_ACCM, 1, 0, 8, 0x0100}},},
+	{"MULCMVZ", 0xc200, 0xe6ff, 1 | P_EXT, 3, {{P_REG1A, 1, 0, 11, 0x0800}, {P_ACCM, 1, 0, 12, 0x1000}, {P_ACCM, 1, 0, 8, 0x0100}},},
+
+	{"ADDR",    0x4000, 0xf8ff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0600}},},
+	{"ADDAX",   0x4800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0200}},},
+	{"ADD", 0x4c00, 0xfeff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_ACCM_D, 1, 0, 8, 0x0100}},},
+	{"ADDAXL",  0x7000, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0200}},},
+
+	{"SUBR",    0x5000, 0xf8ff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0600}},},
+	{"SUBAX",   0x5800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_REG18, 1, 0, 9, 0x0200}},},
+	{"SUB", 0x5c00, 0xfeff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 8, 0x0100}, {P_ACCM_D, 1, 0, 8, 0x0100}},},
+
+	{"MADD",    0xf200, 0xfeff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 8, 0x0100}, {P_REG1A, 1, 0, 8, 0x0100}},},
+	{"MSUB",    0xf600, 0xfeff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 8, 0x0100}, {P_REG1A, 1, 0, 8, 0x0100}},},
+	{"MADDX",   0xe000, 0xfcff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 8, 0x0200}, {P_REG19, 1, 0, 7, 0x0100}},},
+	{"MSUBX",   0xe400, 0xfcff, 1 | P_EXT, 2, {{P_REG18, 1, 0, 8, 0x0200}, {P_REG19, 1, 0, 7, 0x0100}},},
+	{"MADDC",   0xe800, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 9, 0x0200}, {P_REG19, 1, 0, 7, 0x0100}},},
+	{"MSUBC",   0xec00, 0xfcff, 1 | P_EXT, 2, {{P_ACCM, 1, 0, 9, 0x0200}, {P_REG19, 1, 0, 7, 0x0100}},},
+
+	// assemble CW
+	{"CW",      0x0000, 0xffff, 1, 1, {{P_VAL, 2, 0, 0, 0xffff}},},
+	// unknown opcode for disassemble
+	{"CW",      0x0000, 0x0000, 1, 1, {{P_VAL, 2, 0, 0, 0xffff}},},
+};
+opc_t opcodes_ext[] =
+{
+	{"L",       0x0040, 0x00c4, 1, 2, {{P_REG18, 1, 0, 3, 0x0038}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"LN",      0x0044, 0x00c4, 1, 2, {{P_REG18, 1, 0, 3, 0x0038}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"LS",      0x0080, 0x00ce, 1, 2, {{P_REG18, 1, 0, 4, 0x0030}, {P_ACCM, 1, 0, 0, 0x0001}},},
+	{"LSN", 0x0084, 0x00ce, 1, 2, {{P_REG18, 1, 0, 4, 0x0030}, {P_ACCM, 1, 0, 0, 0x0001}},},
+	{"LSM", 0x0088, 0x00ce, 1, 2, {{P_REG18, 1, 0, 4, 0x0030}, {P_ACCM, 1, 0, 0, 0x0001}},},
+	{"LSNM",    0x008c, 0x00ce, 1, 2, {{P_REG18, 1, 0, 4, 0x0030}, {P_ACCM, 1, 0, 0, 0x0001}},},
+	{"SL",      0x0082, 0x00ce, 1, 2, {{P_ACCM, 1, 0, 0, 0x0001}, {P_REG18, 1, 0, 4, 0x0030}},},
+	{"SLN", 0x0086, 0x00ce, 1, 2, {{P_ACCM, 1, 0, 0, 0x0001}, {P_REG18, 1, 0, 4, 0x0030}},},
+	{"SLM", 0x008a, 0x00ce, 1, 2, {{P_ACCM, 1, 0, 0, 0x0001}, {P_REG18, 1, 0, 4, 0x0030}},},
+	{"SLNM",    0x008e, 0x00ce, 1, 2, {{P_ACCM, 1, 0, 0, 0x0001}, {P_REG18, 1, 0, 4, 0x0030}},},
+	{"S",       0x0020, 0x00e4, 1, 2, {{P_PRG, 1, 0, 0, 0x0003}, {P_REG1C, 1, 0, 3, 0x0018}},},
+	{"SN",      0x0024, 0x00e4, 1, 2, {{P_PRG, 1, 0, 0, 0x0003}, {P_REG1C, 1, 0, 3, 0x0018}},},
+	{"LDX", 0x00c0, 0x00cf, 1, 3, {{P_REG18, 1, 0, 4, 0x0010}, {P_REG1A, 1, 0, 4, 0x0010}, {P_PRG, 1, 0, 5, 0x0020}},},
+	{"LDXN",    0x00c4, 0x00cf, 1, 3, {{P_REG18, 1, 0, 4, 0x0010}, {P_REG1A, 1, 0, 4, 0x0010}, {P_PRG, 1, 0, 5, 0x0020}},},
+	{"LDXM",    0x00c8, 0x00cf, 1, 3, {{P_REG18, 1, 0, 4, 0x0010}, {P_REG1A, 1, 0, 4, 0x0010}, {P_PRG, 1, 0, 5, 0x0020}},},
+	{"LDXNM",   0x00cc, 0x00cf, 1, 3, {{P_REG18, 1, 0, 4, 0x0010}, {P_REG1A, 1, 0, 4, 0x0010}, {P_PRG, 1, 0, 5, 0x0020}},},
+	{"LD",      0x00c0, 0x00cc, 1, 3, {{P_REG18, 1, 0, 4, 0x0020}, {P_REG19, 1, 0, 3, 0x0010}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"LDN", 0x00c4, 0x00cc, 1, 3, {{P_REG18, 1, 0, 4, 0x0020}, {P_REG19, 1, 0, 3, 0x0010}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"LDM", 0x00c8, 0x00cc, 1, 3, {{P_REG18, 1, 0, 4, 0x0020}, {P_REG19, 1, 0, 3, 0x0010}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"LDNM",    0x00cc, 0x00cc, 1, 3, {{P_REG18, 1, 0, 4, 0x0020}, {P_REG19, 1, 0, 3, 0x0010}, {P_PRG, 1, 0, 0, 0x0003}},},
+	{"MV",      0x0010, 0x00f0, 1, 2, {{P_REG18, 1, 0, 2, 0x000c}, {P_REG1C, 1, 0, 0, 0x0003}},},
+	{"DR",      0x0004, 0x00fc, 1, 1, {{P_REG, 1, 0, 0, 0x0003}},},
+	{"IR",      0x0008, 0x00fc, 1, 1, {{P_REG, 1, 0, 0, 0x0003}},},
+	{"NR",      0x000c, 0x00fc, 1, 1, {{P_REG, 1, 0, 0, 0x0003}},},
+	{"XXX", 0x0000, 0x0000, 1, 1, {{P_VAL, 1, 0, 0, 0x00ff}},},
+};
+
+const uint32 opcodes_size = sizeof(opcodes) / sizeof(opc_t);
+const uint32 opcodes_ext_size = sizeof(opcodes_ext) / sizeof(opc_t);
+

Source/Plugins/Plugin_DSP_LLE/Src/opcodes.h

@@ -0,0 +1,86 @@
+/*====================================================================
+
+   filename:     opcodes.h
+   project:      GameCube DSP Tool (gcdsp)
+   created:      2005.03.04
+   mail:		  duddie@walla.com
+
+   Copyright (c) 2005 Duddie
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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 for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+   ====================================================================*/
+#ifndef _OPCODES_H
+#define _OPCODES_H
+
+typedef enum partype_t
+{
+	P_NONE = 0x0000,
+	P_VAL = 0x0001,
+	P_IMM = 0x0002,
+	P_MEM = 0x0003,
+	P_STR = 0x0004,
+	P_REG = 0x8000,
+	P_REG08 = P_REG | 0x0800,
+	P_REG10 = P_REG | 0x1000,
+	P_REG18 = P_REG | 0x1800,
+	P_REG19 = P_REG | 0x1900,
+	P_REG1A = P_REG | 0x1a00,
+	P_REG1C = P_REG | 0x1c00,
+	P_ACCM = P_REG | 0x1e00,
+	P_ACCM_D = P_REG | 0x1e80,
+	P_ACC = P_REG | 0x2000,
+	P_ACC_D = P_REG | 0x2080,
+	P_AX = P_REG | 0x2200,
+	P_AX_D = P_REG | 0x2280,
+	P_REGS_MASK = 0x03f80,
+	P_REF       = P_REG | 0x4000,
+	P_PRG       = P_REF | P_REG,
+};
+
+#define P_EXT   0x80
+
+typedef struct opcpar_t
+{
+	partype_t type;
+	uint8 size;
+	uint8 loc;
+	sint8 lshift;
+	uint16 mask;
+} opcpar_t;
+
+typedef struct opc_t
+{
+	const char* name;
+	uint16 opcode;
+	uint16 opcode_mask;
+	uint8 size;
+	uint8 param_count;
+	opcpar_t params[8];
+} opc_t;
+
+extern opc_t opcodes[];
+extern const uint32 opcodes_size;
+extern opc_t opcodes_ext[];
+extern const uint32 opcodes_ext_size;
+
+inline uint16 swap16(uint16 x)
+{
+	return((x >> 8) | (x << 8));
+}
+
+
+#endif
+

Source/Plugins/Plugin_DSP_LLE/Src/stdafx.cpp

@@ -0,0 +1,19 @@
+// 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/
+
+#include "stdafx.h"
+

Source/Plugins/Plugin_DSP_LLE/Src/stdafx.h

@@ -0,0 +1,36 @@
+// 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/
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN     // Exclude rarely-used stuff from Windows headers
+#define _CRT_SECURE_NO_DEPRECATE 1
+
+#include <windows.h>
+#include <tchar.h>
+
+// WTL
+#include <atlbase.h>
+#include <atlapp.h>
+
+#include <atlwin.h>
+#include <atlframe.h>
+#include <atlctrls.h>
+#include <atldlgs.h>
+
+#include "PluginSpecs_DSP.h"
+