ShuriZma
/
melonDS
mirror of https://github.com/melonDS-emu/melonDS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

sadadssa

This commit is contained in:
Arisotura 2020-05-30 02:59:45 +02:00
parent 5eb01f1f15 58c2790ea3
commit 61799c35bd
6 changed files with 833 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
melonDS.cbp
View File

@ -53,6 +53,24 @@
<Add option="-m64" />
</Linker>
</Target>
<Target title="DebugFast-Cap Windows">
<Option platforms="Windows;" />
<Option output="bin/DebugFast_Cap/melonDS" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/DebugFast_Cap/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-O3" />
<Add option="-m64" />
<Add option="-D_FILE_OFFSET_BITS=64" />
<Add option="-DMELONCAP" />
</Compiler>
<Linker>
<Add option="-m64" />
<Add library="winusb" />
<Add library="setupapi" />
</Linker>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
@ -161,6 +179,12 @@
<Unit filename="src/libui_sdl/LAN_PCap.h" />
<Unit filename="src/libui_sdl/LAN_Socket.cpp" />
<Unit filename="src/libui_sdl/LAN_Socket.h" />
<Unit filename="src/libui_sdl/MelonCap.cpp">
<Option target="DebugFast-Cap Windows" />
</Unit>
<Unit filename="src/libui_sdl/MelonCap.h">
<Option target="DebugFast-Cap Windows" />
</Unit>
<Unit filename="src/libui_sdl/OSD.cpp" />
<Unit filename="src/libui_sdl/OSD.h" />
<Unit filename="src/libui_sdl/Platform.cpp" />

771
src/GPU2D.cpp
View File

File diff suppressed because it is too large Load Diff

19
src/GPU2D.h
View File

@ -63,7 +63,7 @@ public:
void OBJExtPalDirty();
u16* GetBGExtPal(u32 slot, u32 pal);
u16* GetOBJExtPal(u32 pal);
u16* GetOBJExtPal();
private:
u32 Num;
@ -111,7 +111,11 @@ private:
u8 BGMosaicSize[2];
u8 OBJMosaicSize[2];
u8 BGMosaicY, BGMosaicYMax;
u8 OBJMosaicY, OBJMosaicYMax;
u8 OBJMosaicYCount, OBJMosaicY, OBJMosaicYMax;
u8 MosaicTable[16][256];
u8* CurBGXMosaicTable;
u8* CurOBJXMosaicTable;
u16 BlendCnt;
u16 BlendAlpha;
@ -133,6 +137,8 @@ private:
u32 ColorBrightnessDown(u32 val, u32 factor);
u32 ColorComposite(int i, u32 val1, u32 val2);
void UpdateMosaicCounters(u32 line);
template<u32 bgmode> void DrawScanlineBGMode(u32 line);
void DrawScanlineBGMode6(u32 line);
void DrawScanlineBGMode7(u32 line);
@ -143,11 +149,12 @@ private:
void (*DrawPixel)(u32* dst, u16 color, u32 flag);
void DrawBG_3D();
void DrawBG_Text(u32 line, u32 bgnum);
void DrawBG_Affine(u32 line, u32 bgnum);
void DrawBG_Extended(u32 line, u32 bgnum);
void DrawBG_Large(u32 line);
template<bool mosaic> void DrawBG_Text(u32 line, u32 bgnum);
template<bool mosaic> void DrawBG_Affine(u32 line, u32 bgnum);
template<bool mosaic> void DrawBG_Extended(u32 line, u32 bgnum);
template<bool mosaic> void DrawBG_Large(u32 line);
void ApplySpriteMosaicX();
void InterleaveSprites(u32 prio);
template<bool window> void DrawSprite_Rotscale(u16* attrib, u16* rotparams, u32 boundwidth, u32 boundheight, u32 width, u32 height, s32 xpos, s32 ypos);
template<bool window> void DrawSprite_Normal(u16* attrib, u32 width, s32 xpos, s32 ypos);

347
src/libui_sdl/MelonCap.cpp Normal file
View File

@ -0,0 +1,347 @@
/*
Copyright 2016-2019 Arisotura
This file is part of melonDS.
melonDS 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 3 of the License, or (at your option)
any later version.
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
*/
#include <stdio.h>
#include <string.h>
#include "MelonCap.h"
#include "libui/ui.h"
#include "../NDS.h"
#include "../GPU.h"
#include <windows.h>
#include <setupapi.h>
#include <guiddef.h>
#include <winusb.h>
namespace MelonCap
{
uiWindow* Window;
uiArea* Area;
uiAreaHandler AreaHandler;
uiDrawBitmap* WinBitmap;
bool WinBitmapInited;
u32* WinBitmapData;
// this crap was built from the reverse-engineering of ds_capture.exe
// mixed in with their Linux capture sample code
GUID InterfaceClass = {0xA0B880F6, 0xD6A5, 0x4700, {0xA8, 0xEA, 0x22, 0x28, 0x2A, 0xCA, 0x55, 0x87}};
HANDLE CapHandle;
WINUSB_INTERFACE_HANDLE CapUSBHandle;
void OnAreaDraw(uiAreaHandler* handler, uiArea* area, uiAreaDrawParams* params)
{
if (!WinBitmapInited)
{
if (WinBitmap) uiDrawFreeBitmap(WinBitmap);
WinBitmapInited = true;
WinBitmap = uiDrawNewBitmap(params->Context, 768, 384, 0);
}
if (!WinBitmap) return;
if (!WinBitmapData) return;
uiRect rc = {0, 0, 768, 384};
uiDrawBitmapUpdate(WinBitmap, WinBitmapData);
uiDrawBitmapDraw(params->Context, WinBitmap, &rc, &rc, 0);
}
void OnAreaMouseEvent(uiAreaHandler* handler, uiArea* area, uiAreaMouseEvent* evt)
{
}
void OnAreaMouseCrossed(uiAreaHandler* handler, uiArea* area, int left)
{
}
void OnAreaDragBroken(uiAreaHandler* handler, uiArea* area)
{
}
int OnAreaKeyEvent(uiAreaHandler* handler, uiArea* area, uiAreaKeyEvent* evt)
{
return 1;
}
void OnAreaResize(uiAreaHandler* handler, uiArea* area, int width, int height)
{
}
void Init()
{
printf("MelonCap init\n");
HDEVINFO devinfo = SetupDiGetClassDevsW(&InterfaceClass, NULL, NULL, DIGCF_DEVICEINTERFACE|DIGCF_PRESENT);
if (devinfo == INVALID_HANDLE_VALUE) return;
int member = 0;
bool good = false;
for (;;)
{
SP_DEVICE_INTERFACE_DATA interfacedata;
memset(&interfacedata, 0, sizeof(interfacedata));
interfacedata.cbSize = sizeof(interfacedata);
BOOL ret = SetupDiEnumDeviceInterfaces(devinfo, NULL, &InterfaceClass, member, &interfacedata);
if (!ret)
{
printf("found %d interfaces\n", member);
break;
}
DWORD requiredsize = 0;
SetupDiGetDeviceInterfaceDetailW(devinfo, &interfacedata, NULL, NULL, &requiredsize, NULL);
printf("%d: required size %d\n", member, requiredsize);
PSP_DEVICE_INTERFACE_DETAIL_DATA_W interfacedetail = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)new u8[requiredsize];
interfacedetail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA_W);
ret = SetupDiGetDeviceInterfaceDetailW(devinfo, &interfacedata, interfacedetail, requiredsize, NULL, NULL);
if (ret)
{
printf("got interface detail: path=%S\n", interfacedetail->DevicePath);
HANDLE file = CreateFileW(interfacedetail->DevicePath, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
if (file != INVALID_HANDLE_VALUE)
{
WINUSB_INTERFACE_HANDLE usbhandle;
ret = WinUsb_Initialize(file, &usbhandle);
if (ret)
{
int val;
val = 0x1E;
WinUsb_SetPipePolicy(usbhandle, 0x00, PIPE_TRANSFER_TIMEOUT, 4, &val);
val = 0x32;
WinUsb_SetPipePolicy(usbhandle, 0x82, PIPE_TRANSFER_TIMEOUT, 4, &val);
val = 0x01;
WinUsb_SetPipePolicy(usbhandle, 0x82, RAW_IO, 1, &val);
printf("looking good\n");
good = true;
CapHandle = file;
CapUSBHandle = usbhandle;
}
else
CloseHandle(file);
}
}
delete[] (u8*)interfacedetail;
if (good) break;
member++;
}
SetupDiDestroyDeviceInfoList(devinfo);
AreaHandler.Draw = OnAreaDraw;
AreaHandler.MouseEvent = OnAreaMouseEvent;
AreaHandler.MouseCrossed = OnAreaMouseCrossed;
AreaHandler.DragBroken = OnAreaDragBroken;
AreaHandler.KeyEvent = OnAreaKeyEvent;
AreaHandler.Resize = OnAreaResize;
WinBitmapInited = false;
WinBitmapData = new u32[768*384];
Window = uiNewWindow("melonDS - topnotch pixel checker", 768, 384, 0, 0, 0);
Area = uiNewArea(&AreaHandler);
uiWindowSetChild(Window, uiControl(Area));
uiControlShow(uiControl(Window));
}
void DeInit()
{
uiControlDestroy(uiControl(Window));
uiDrawFreeBitmap(WinBitmap);
WinBitmapInited = false;
delete[] WinBitmapData;
WinUsb_Free(CapUSBHandle);
CloseHandle(CapHandle);
}
int VendorIn(u8 req, u16 len, u8* buf)
{
WINUSB_SETUP_PACKET pkt;
pkt.RequestType = 0xC0; // device to host
pkt.Request = req;
pkt.Value = 0; // ?????
pkt.Index = 0;
pkt.Length = len;
ULONG ret = 0;
BOOL res = WinUsb_ControlTransfer(CapUSBHandle, pkt, buf, len, &ret, NULL);
if (!res) return -1;
return ret;
}
int VendorOut(u8 req, u16 val, u16 len, u8* buf)
{
WINUSB_SETUP_PACKET pkt;
pkt.RequestType = 0x40; // host to device
pkt.Request = req;
pkt.Value = val;
pkt.Index = 0;
pkt.Length = len;
ULONG ret = 0;
BOOL res = WinUsb_ControlTransfer(CapUSBHandle, pkt, buf, len, &ret, NULL);
if (!res) return -1;
return ret;
}
int BulkIn(u8* buf, u32 len)
{
ULONG ret = 0;
BOOL res = WinUsb_ReadPipe(CapUSBHandle, 0x82, buf, len, &ret, NULL);
if (!res) return -1;
return ret;
}
u32 ConvertColor(u16 col)
{
u32 b = col & 0x001F;
u32 g = (col & 0x07E0) >> 5;
u32 r = (col & 0xF800) >> 11;
u32 ret = 0xFF000000;
ret |= ((r << 3) | (r >> 2)) << 16;
ret |= ((g << 2) | (g >> 4)) << 8;
ret |= (b << 3) | (b >> 2);
return ret;
}
void CaptureFrame()
{
u32 ret;
u8 derp;
u32 framelen = 256*384*2;
u16 frame[framelen/2];
u32 framepos = 0;
u8 frameinfo[64];
ret = VendorOut(0x30, 0, 0, &derp);
if (ret < 0) return;
int tries = 0;
while (framepos < framelen)
{
ret = BulkIn((u8*)&frame[framepos/2], framelen-framepos);
if (ret < 0) break;
if (ret == 0)
{
tries++;
if (tries >= 100) break;
continue;
}
framepos += ret;
}
ret = VendorIn(0x30, 64, frameinfo);
if (ret < 0) return;
if ((frameinfo[0] & 0x03) != 0x03) return;
if (!frameinfo[52]) return;
u16* in = &frame[0];
u32* out = &WinBitmapData[256];
for (int y = 0; y < 384; y++)
{
u32* out = &WinBitmapData[((y/2)*768) + ((y&1)*128) + 256];
if (!(frameinfo[y>>3] & (1<<(y&7))))
{
continue;
}
for (int x = 0; x < 256/2; x++)
{
out[0] = ConvertColor(in[1]);
out[768*192] = ConvertColor(in[0]);
out++;
in += 2;
}
}
}
void Update()
{
// melonDS output
int frontbuf = GPU::FrontBuffer;
u32* topbuf = GPU::Framebuffer[frontbuf][0];
if (topbuf)
{
for (int y = 0; y < 192; y++)
{
memcpy(&WinBitmapData[y*768], &topbuf[y*256], 256*4);
}
}
u32* botbuf = GPU::Framebuffer[frontbuf][1];
if (botbuf)
{
for (int y = 0; y < 192; y++)
{
memcpy(&WinBitmapData[(y+192)*768], &botbuf[y*256], 256*4);
}
}
// DS capture
CaptureFrame();
// compare
for (int y = 0; y < 384; y++)
{
for (int x = 0; x < 256; x++)
{
u32 colA = WinBitmapData[(y*768) + x + 0];
u32 colB = WinBitmapData[(y*768) + x + 256];
// best we get from the capture card is RGB565
// so we'll ignore the lower bits
const u32 mask = 0x00F8FCF8;
colA &= mask;
colB &= mask;
if (colA == colB) WinBitmapData[(y*768) + x + 512] = 0xFF00FF00;
else WinBitmapData[(y*768) + x + 512] = 0xFFFF0000;
}
}
uiAreaQueueRedrawAll(Area);
}
}

34
src/libui_sdl/MelonCap.h Normal file
View File

@ -0,0 +1,34 @@
/*
Copyright 2016-2019 Arisotura
This file is part of melonDS.
melonDS 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 3 of the License, or (at your option)
any later version.
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
*/
#ifndef MELONCAP_H
#define MELONCAP_H
#include "types.h"
namespace MelonCap
{
void Init();
void DeInit();
void Update();
}
#endif // MELONCAP_H

16
src/libui_sdl/main.cpp
View File

@ -48,6 +48,10 @@
#include "OSD.h"
#ifdef MELONCAP
#include "MelonCap.h"
#endif // MELONCAP
// savestate slot mapping
// 1-8: regular slots (quick access)
@ -999,6 +1003,10 @@ int EmuThreadFunc(void* burp)
// emulate
u32 nlines = NDS::RunFrame();
#ifdef MELONCAP
MelonCap::Update();
#endif // MELONCAP
if (EmuRunning == 0) break;
if (Screen_UseGL)
@ -2737,6 +2745,10 @@ int main(int argc, char** argv)
uiMenuItemSetChecked(MenuItem_AudioSync, Config::AudioSync==1);
uiMenuItemSetChecked(MenuItem_ShowOSD, Config::ShowOSD==1);
#ifdef MELONCAP
MelonCap::Init();
#endif // MELONCAP
AudioSync = SDL_CreateCond();
AudioSyncLock = SDL_CreateMutex();
@ -2820,6 +2832,10 @@ int main(int argc, char** argv)
if (MicWavBuffer) delete[] MicWavBuffer;
#ifdef MELONCAP
MelonCap::DeInit();
#endif // MELONCAP
if (ScreenBitmap[0]) uiDrawFreeBitmap(ScreenBitmap[0]);
if (ScreenBitmap[1]) uiDrawFreeBitmap(ScreenBitmap[1]);