sadadssa

melonDS.cbp

@@ -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" />

src/GPU2D.h

@@ -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);
+    template<bool mosaic> void DrawBG_Text(u32 line, u32 bgnum);
-    void DrawBG_Affine(u32 line, u32 bgnum);
+    template<bool mosaic> void DrawBG_Affine(u32 line, u32 bgnum);
-    void DrawBG_Extended(u32 line, u32 bgnum);
+    template<bool mosaic> void DrawBG_Extended(u32 line, u32 bgnum);
-    void DrawBG_Large(u32 line);
+    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);

src/libui_sdl/MelonCap.cpp

@@ -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);
+}
+
+}

src/libui_sdl/MelonCap.h

@@ -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

src/libui_sdl/main.cpp

@@ -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]);