3600b17

diff --git a/custom.cpp b/custom.cpp
index d71f7d18692321836d74870e3ef25bc3d726d088..59d3119ea2d5ad6de60391f8d4e82eb75d05a255 100644 (file)
--- a/custom.cpp
+++ b/custom.cpp
@@ -8072,7 +8072,8 @@ static void hsync_scandoubler (void)
        debug_dma = 0;
 #endif
 
-       if (lof_store && (vpos & 1) && vpos == plflastline - 1) {
+       // this is not correct
+       if (0 && lof_store && (vpos & 1) && vpos == plflastline - 1) {
                // blank last line if it is odd line
                dmacon &= ~DMA_BITPLANE;
        }
@@ -10089,10 +10090,10 @@ uae_u8 *save_custom_extra (int *len, uae_u8 *dstptr)
        SB(currprefs.cs_bytecustomwritebug ? 1 : 0);
        SB(currprefs.cs_color_burst ? 1 : 0);
        SB(currprefs.cs_toshibagary ? 1 : 0);
+       SB(currprefs.cs_romisslow ? 1 : 0);
        SB(currprefs.cs_ciatype[0]);
        SB(currprefs.cs_ciatype[1]);
 
-
        *len = dst - dstbak;
        return dstbak;
 }

diff --git a/od-win32/direct3d11.cpp b/od-win32/direct3d11.cpp
index fe664c8f630f2ce4b23e3b9128751dd59c025358..cc114a401e7c890baf24ebd9732c5109ab157f2a 100644 (file)
--- a/od-win32/direct3d11.cpp
+++ b/od-win32/direct3d11.cpp
@@ -63,11 +63,9 @@ void(*D3D_resize)(int);
 void (*D3D_change)(int);
 bool(*D3D_getscalerect)(float *mx, float *my, float *sx, float *sy);
 
-static volatile int presentthread_mode, vblankthread_mode;
+static volatile int vblankthread_mode;
 static HMODULE hd3d11, hdxgi, hd3dcompiler, dwmapi;
-static HANDLE flipevent, flipevent2, vblankevent;
-static CRITICAL_SECTION present_cs;
-static bool present_cs_init;
+static HANDLE vblankevent;
 
 static struct gfx_filterdata *filterd3d;
 static int filterd3didx;
@@ -234,6 +232,7 @@ struct d3d11struct
        DWM_FRAME_COUNT lastframe;
        int frames_since_init;
        bool needvblankevent;
+       bool resizeretry;
 
        struct d3d11sprite osd;
        struct d3d11sprite hwsprite;
@@ -251,7 +250,7 @@ struct d3d11struct
        RECT sr2, dr2, zr2;
        int guimode;
        int delayedfs;
-       int device_removed;
+       int device_errors;
        bool delayedrestore;
        bool reloadshaders;
        int ledwidth, ledheight;
@@ -1447,8 +1446,8 @@ static void setupscenecoords(struct d3d11struct *d3d)
        float w = sr.right - sr.left;
        float h = sr.bottom - sr.top;
 
-       int tx = dw * d3d->m_bitmapWidth / d3d->m_screenWidth / 2;
-       int ty = dh * d3d->m_bitmapHeight / d3d->m_screenHeight / 2;
+       int tx = ((dr.right - dr.left) * d3d->m_bitmapWidth) / (d3d->m_screenWidth * 2);
+       int ty = ((dr.bottom - dr.top) * d3d->m_bitmapHeight) / (d3d->m_screenHeight * 2);
 
        float sw = dw / d3d->m_screenWidth;
        float sh = dh / d3d->m_screenHeight;
@@ -1621,17 +1620,43 @@ static void freesprite(struct d3d11sprite *s)
        if (s->matrixbuffer)
                s->matrixbuffer->Release();
 
-       s->pixelshader = NULL;
-       s->vertexshader = NULL;
-       s->layout = NULL;
-       s->vertexbuffer = NULL;
-       s->indexbuffer = NULL;
-       s->matrixbuffer = NULL;
-
        memset(s, 0, sizeof(struct d3d11sprite));
 }
 
-static void FreeTexture(struct d3d11struct *d3d)
+static void FreeShaderTex(struct shadertex *t)
+{
+       FreeTexture2D(&t->tex, &t->rv);
+       if (t->rt)
+               t->rt->Release();
+       t->rt = NULL;
+}
+
+static void freeshaderdata(struct shaderdata11 *s)
+{
+       if (s->effect) {
+               s->effect->Release();
+               s->effect = NULL;
+       }
+       FreeTexture2D(&s->masktexture, &s->masktexturerv);
+       FreeShaderTex(&s->lpWorkTexture1);
+       FreeShaderTex(&s->lpWorkTexture2);
+       FreeShaderTex(&s->lpTempTexture);
+       if (s->lpHq2xLookupTexture)
+               s->lpHq2xLookupTexture->Release();
+       if (s->lpHq2xLookupTexturerv)
+               s->lpHq2xLookupTexturerv->Release();
+       for (int j = 0; j < MAX_TECHNIQUE_LAYOUTS; j++) {
+               if (s->layouts[j])
+                       s->layouts[j]->Release();
+       }
+       if (s->vertexBuffer)
+               s->vertexBuffer->Release();
+       if (s->indexBuffer)
+               s->indexBuffer->Release();
+       memset(s, 0, sizeof(struct shaderdata11));
+}
+
+static void FreeTextures(struct d3d11struct *d3d)
 {
        FreeTexture2D(&d3d->texture2d, &d3d->texture2drv);
        FreeTexture2D(&d3d->texture2dstaging, NULL);
@@ -1643,8 +1668,7 @@ static void FreeTexture(struct d3d11struct *d3d)
        freesprite(&d3d->blanksprite);
 
        for (int i = 0; i < MAX_SHADERS; i++) {
-               FreeTexture2D(&d3d->shaders[i].masktexture, &d3d->shaders[i].masktexturerv);
-               memset(&d3d->shaders[i], 0, sizeof(struct shaderdata11));
+               freeshaderdata(&d3d->shaders[i]);
        }
 }
 
@@ -1790,7 +1814,7 @@ static bool CreateTexture(struct d3d11struct *d3d)
        memset(&d3d->dr2, 0, sizeof(RECT));
        memset(&d3d->zr2, 0, sizeof(RECT));
 
-       FreeTexture(d3d);
+       FreeTextures(d3d);
 
        memset(&desc, 0, sizeof desc);
        desc.Width = d3d->m_bitmapWidth;
@@ -1870,6 +1894,8 @@ static bool CreateTexture(struct d3d11struct *d3d)
        d3d->cursor_scale = false;
        allocsprite(d3d, &d3d->hwsprite, CURSORMAXWIDTH, CURSORMAXHEIGHT, true);
 
+       write_log(_T("D3D11: %dx%d main texture allocated\n"), d3d->m_bitmapWidth, d3d->m_bitmapHeight);
+
        return true;
 }
 
@@ -2770,11 +2796,11 @@ static void setswapchainmode(struct d3d11struct *d3d, int fs)
        struct apmode *apm = picasso_on ? &currprefs.gfx_apmode[APMODE_RTG] : &currprefs.gfx_apmode[APMODE_NATIVE];
        // It is recommended to always use the tearing flag when it is supported.
        d3d->swapChainDesc.Flags &= ~DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
-       // tearing flag is not fullscreen compatible
        if (d3d->m_tearingSupport && (d3d->swapChainDesc.SwapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL || d3d->swapChainDesc.SwapEffect == DXGI_SWAP_EFFECT_FLIP_DISCARD) && !apm->gfx_vflip && apm->gfx_backbuffers == 0) {
                d3d->swapChainDesc.Flags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
        }
        d3d->swapChainDesc.Flags &= ~DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+       // tearing flag is not fullscreen compatible
        if (fs) {
                d3d->swapChainDesc.Flags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
                d3d->swapChainDesc.Flags &= ~DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
@@ -2882,13 +2908,21 @@ int can_D3D11(bool checkdevice)
        return ret;
 }
 
+static bool device_error(struct d3d11struct *d3d)
+{
+       d3d->device_errors++;
+       if (d3d->device_errors > 2) {
+               d3d->delayedfs = -1;
+               return true;
+       }
+       return false;
+}
+
 static void do_present(struct d3d11struct *d3d, int black)
 {
        HRESULT hr;
        UINT presentFlags = 0;
 
-       EnterCriticalSection(&present_cs);
-
        if (black) {
                float color[4];
                color[0] = 0;
@@ -2916,22 +2950,16 @@ static void do_present(struct d3d11struct *d3d, int black)
        }
        d3d->syncinterval = syncinterval;
        hr = d3d->m_swapChain->Present(syncinterval, presentFlags);
-       SetEvent(flipevent2);
        if (currprefs.turbo_emulation && hr == DXGI_ERROR_WAS_STILL_DRAWING)
                hr = S_OK;
        if (FAILED(hr) && hr != DXGI_STATUS_OCCLUDED) {
                if (hr == DXGI_ERROR_DEVICE_REMOVED) {
-                       d3d->device_removed++;
-                       if (d3d->device_removed > 2) {
-                               d3d->delayedfs = -1;
-                       }
+                       device_error(d3d);
                } else if (hr == E_OUTOFMEMORY) {
                        d3d->invalidmode = true;
                }
                write_log(_T("D3D11 Present %08x\n"), hr);
        }
-
-       LeaveCriticalSection(&present_cs);
 }
 
 static unsigned int __stdcall vblankthread(void *dummy)
@@ -2944,50 +2972,19 @@ static unsigned int __stdcall vblankthread(void *dummy)
                if (FAILED(hr)) {
                        Sleep(10);
                } else {
-                       if (d3d->blackscreen && (d3d->framecount & 1)) {
-                               do_present(d3d, 1);
-                       } else {
-                               SetEvent(vblankevent);
-                       }
-                       d3d->framecount++;
+                       SetEvent(vblankevent);
                }
+               d3d->framecount++;
        }
        vblankthread_mode = -1;
        write_log(_T("vblankthread exited\n"));
        return 0;
 }
 
-static unsigned int __stdcall presentthread(void *dummy)
-{
-       struct d3d11struct *d3d = &d3d11data[0];
-
-       SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
-       while (presentthread_mode) {
-               WaitForSingleObject(flipevent, INFINITE);
-               if (presentthread_mode == 0)
-                       break;
-               do_present(d3d, 0);
-       }
-       presentthread_mode = -1;
-       write_log(_T("presentthread exited\n"));
-       return 0;
-}
-
 static void initthread(struct d3d11struct *d3d)
 {
        unsigned int th;
 
-       if (!present_cs_init) {
-               present_cs_init = true;
-               InitializeCriticalSection(&present_cs);
-       }
-
-       if (!presentthread_mode) {
-               flipevent = CreateEvent(NULL, FALSE, FALSE, NULL);
-               flipevent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
-               presentthread_mode = 1;
-               _beginthreadex(NULL, 0, presentthread, 0, 0, &th);
-       }
        if (!vblankthread_mode && d3d->outputAdapter && d3d->needvblankevent) {
                vblankevent = CreateEvent(NULL, FALSE, FALSE, NULL);
                vblankthread_mode = 1;
@@ -2997,18 +2994,6 @@ static void initthread(struct d3d11struct *d3d)
 
 static void freethread(struct d3d11struct *d3d)
 {
-       if (presentthread_mode) {
-               presentthread_mode = 0;
-               while (presentthread_mode == 0) {
-                       SetEvent(flipevent);
-                       Sleep(10);
-               }
-               presentthread_mode = 0;
-               CloseHandle(flipevent);
-               CloseHandle(flipevent2);
-               flipevent = NULL;
-               flipevent2 = NULL;
-       }
        if (vblankthread_mode) {
                vblankthread_mode = 0;
                while (vblankthread_mode == 0) {
@@ -3037,13 +3022,13 @@ static int xxD3D11_init2(HWND ahwnd, int w_w, int w_h, int t_w, int t_h, int dep
        DXGI_MODE_DESC1* displayModeList;
        DXGI_ADAPTER_DESC adapterDesc;
 
-       write_log(_T("D3D11 init start\n"));
+       write_log(_T("D3D11: init start. (%d*%d) (%d*%d) RTG=%d Depth=%d.\n"), w_w, w_h, t_w, t_h, picasso_on, depth);
 
        filterd3didx = picasso_on;
        filterd3d = &currprefs.gf[filterd3didx];
 
        d3d->delayedfs = 0;
-       d3d->device_removed = 0;
+       d3d->device_errors = 0;
 
        if (depth != 32 && depth != 16)
                return 0;
@@ -3375,22 +3360,16 @@ static int xxD3D11_init2(HWND ahwnd, int w_w, int w_h, int t_w, int t_h, int dep
 
        initthread(d3d);
 
+       write_log(_T("D3D11: %d %08x %08x\n"), d3d->swapChainDesc.BufferCount, d3d->swapChainDesc.Flags, d3d->swapChainDesc.Format);
+
        if (isfs(d3d) > 0)
                D3D_resize(1);
        D3D_resize(0);
 
-       write_log(_T("D3D11 init end\n"));
+       write_log(_T("D3D11: init end\n"));
        return 1;
 }
 
-static void FreeShaderTex(struct shadertex *t)
-{
-       FreeTexture2D(&t->tex, &t->rv);
-       if (t->rt)
-               t->rt->Release();
-       t->rt = NULL;
-}
-
 static void freed3d(struct d3d11struct *d3d)
 {
        write_log(_T("D3D11 freed3d start\n"));
@@ -3464,36 +3443,13 @@ static void freed3d(struct d3d11struct *d3d)
                d3d->m_matrixBuffer = 0;
        }
 
-       FreeTexture(d3d);
+       FreeTextures(d3d);
        FreeTexture2D(&d3d->sltexture, &d3d->sltexturerv);
        FreeShaderTex(&d3d->lpPostTempTexture);
 
        for (int i = 0; i < MAX_SHADERS; i++) {
                struct shaderdata11 *s = &d3d->shaders[i];
-               if (s->effect) {
-                       s->effect->Release();
-                       s->effect = NULL;
-               }
-               if (s->masktexture) {
-                       s->masktexture->Release();
-                       s->masktexture = NULL;
-               }
-               FreeShaderTex(&s->lpWorkTexture1);
-               FreeShaderTex(&s->lpWorkTexture2);
-               FreeShaderTex(&s->lpTempTexture);
-               if (s->lpHq2xLookupTexture)
-                       s->lpHq2xLookupTexture->Release();
-               if (s->lpHq2xLookupTexturerv)
-                       s->lpHq2xLookupTexturerv->Release();
-               for (int j = 0; j < MAX_TECHNIQUE_LAYOUTS; j++) {
-                       if (s->layouts[j])
-                               s->layouts[j]->Release();
-               }
-               if (s->vertexBuffer)
-                       s->vertexBuffer->Release();
-               if (s->indexBuffer)
-                       s->indexBuffer->Release();
-               memset(s, 0, sizeof(struct shaderdata11));
+               freeshaderdata(s);
        }
 
        if (d3d->filenotificationhandle)
@@ -3510,7 +3466,7 @@ static void xD3D11_free(bool immediate)
 {
        struct d3d11struct *d3d = &d3d11data[0];
 
-       write_log(_T("D3D11 free start\n"));
+       write_log(_T("D3D11: free start\n"));
 
        freethread(d3d);
 
@@ -3539,12 +3495,12 @@ static void xD3D11_free(bool immediate)
                d3d->outputAdapter = NULL;
        }
 
-       d3d->device_removed = 0;
+       d3d->device_errors = 0;
 
        changed_prefs.leds_on_screen &= ~STATUSLINE_TARGET;
        currprefs.leds_on_screen &= ~STATUSLINE_TARGET;
 
-       write_log(_T("D3D11 free end\n"));
+       write_log(_T("D3D11: free end\n"));
 }
 
 static int xxD3D11_init(HWND ahwnd, int w_w, int w_h, int depth, int *freq, int mmult)
@@ -3619,11 +3575,14 @@ static void RenderBuffers(struct d3d11struct *d3d, ID3D11Buffer *vertexbuffer, I
 
 static void EndScene(struct d3d11struct *d3d)
 {
+#if 0
        if ((d3d->syncinterval || (d3d->swapChainDesc.SwapEffect == DXGI_SWAP_EFFECT_DISCARD)) && d3d->flipped) {
                WaitForSingleObject(flipevent2, 100);
                d3d->flipped = false;
        }
        SetEvent(flipevent);
+#endif
+       do_present(d3d, 0);
 }
 
 static void TextureShaderClass_RenderShader(struct d3d11struct *d3d)
@@ -3921,13 +3880,9 @@ static bool GraphicsClass_Render(struct d3d11struct *d3d, float rotation)
        // Generate the view matrix based on the camera's position.
        CameraClass_Render(d3d);
 
-       EnterCriticalSection(&present_cs);
-
        // Render the bitmap with the texture shader.
        result = TextureShaderClass_Render(d3d);
 
-       LeaveCriticalSection(&present_cs);
-
        if (!result)
                return false;
 
@@ -4050,6 +4005,8 @@ static bool restore(struct d3d11struct *d3d)
                }
        }
 
+       write_log(_T("D3D11: Shader and extra textures restored\n"));
+
        return true;
 }
 
@@ -4141,6 +4098,10 @@ static void xD3D11_refresh(void)
 
 static void recheck(struct d3d11struct *d3d)
 {
+       if (d3d->resizeretry) {
+               resizemode(d3d);
+               return;
+       }
        if (!d3d->delayedfs)
                return;
        xD3D11_free(d3d);
@@ -4196,13 +4157,9 @@ static uae_u8 *xD3D11_locktexture(int *pitch, int *height, bool fullupdate)
        if (d3d->invalidmode || !d3d->texture2d)
                return NULL;
 
-       EnterCriticalSection(&present_cs);
-
        D3D11_MAPPED_SUBRESOURCE map;
        HRESULT hr = d3d->m_deviceContext->Map(d3d->texture2dstaging, 0, D3D11_MAP_WRITE, 0, &map);
 
-       LeaveCriticalSection(&present_cs);
-
        if (FAILED(hr)) {
                write_log(_T("D3D11 Map() %08x\n"), hr);
                return NULL;
@@ -4222,8 +4179,6 @@ static void xD3D11_unlocktexture(void)
                return;
        d3d->texturelocked--;
 
-       EnterCriticalSection(&present_cs);
-
        d3d->m_deviceContext->Unmap(d3d->texture2dstaging, 0);
 
        if (currprefs.leds_on_screen & (STATUSLINE_CHIPSET | STATUSLINE_RTG)) {
@@ -4238,8 +4193,6 @@ static void xD3D11_unlocktexture(void)
        box.top = 0;
        box.bottom = d3d->m_bitmapHeight;
        d3d->m_deviceContext->CopySubresourceRegion(d3d->texture2d, 0, 0, 0, 0, d3d->texture2dstaging, 0, &box);
-
-       LeaveCriticalSection(&present_cs);
 }
 
 static void xD3D11_flushtexture(int miny, int maxy)
@@ -4249,10 +4202,6 @@ static void xD3D11_flushtexture(int miny, int maxy)
 
 static void xD3D11_restore(void)
 {
-       struct d3d11struct *d3d = &d3d11data[0];
-       if (!d3d->texture2d)
-               return;
-       createscanlines(d3d, 0);
 }
 
 static void xD3D11_vblank_reset(double freq)
@@ -4276,14 +4225,19 @@ static void xD3D11_change(int temp)
 
 static void resizemode(struct d3d11struct *d3d)
 {
+       d3d->resizeretry = false;
        if (!d3d->invalidmode) {
                freed3d(d3d);
-               write_log(_T("D3D11 resize %d %d, %d %d\n"), d3d->m_screenWidth, d3d->m_screenHeight, d3d->m_bitmapWidth, d3d->m_bitmapHeight);
-               setswapchainmode(d3d, d3d->fsmode);
+               int fs = isfs(d3d);
+               setswapchainmode(d3d, fs);
+               write_log(_T("D3D11 resize %dx%d, %dx%d %d %08x FS=%d\n"), d3d->m_screenWidth, d3d->m_screenHeight, d3d->m_bitmapWidth, d3d->m_bitmapHeight,
+                       d3d->swapChainDesc.BufferCount, d3d->swapChainDesc.Flags, fs);
                HRESULT hr = d3d->m_swapChain->ResizeBuffers(d3d->swapChainDesc.BufferCount, d3d->m_screenWidth, d3d->m_screenHeight, d3d->scrformat, d3d->swapChainDesc.Flags);
                if (FAILED(hr)) {
                        write_log(_T("ResizeBuffers %08x\n"), hr);
-                       d3d->invalidmode = true;
+                       if (!device_error(d3d)) {
+                               d3d->resizeretry = true;
+                       }
                }
                if (!d3d->invalidmode) {
                        if (!initd3d(d3d)) {
@@ -4321,7 +4275,7 @@ static void xD3D11_resize(int activate)
 
        if (d3d->m_swapChain && quit_program == -UAE_QUIT) {
                d3d->m_swapChain->SetFullscreenState(FALSE, NULL);
-               FreeTexture(d3d);
+               FreeTextures(d3d);
                d3d->fsmode = 0;
                d3d->invalidmode = true;
                d3d->fsmodechange = 0;

diff --git a/od-win32/hardfile_win32.cpp b/od-win32/hardfile_win32.cpp
index a70af9fe071fb020df5018869a06469e4779c3d5..aa6c1ee4cf98e5841b9a8180ba2be36baa15208c 100644 (file)
--- a/od-win32/hardfile_win32.cpp
+++ b/od-win32/hardfile_win32.cpp
@@ -754,16 +754,49 @@ static bool hd_get_meta_hack(HWND hDlg, HANDLE h, uae_u8 *data, uae_u8 *inq)
        return false;
 }
 
-static bool do_scsi_read10_chs(HANDLE handle, int c, int h, int s, uae_u8 *data)
+static bool do_scsi_read10_chs(HANDLE handle, uae_u32 lba, int c, int h, int s, uae_u8 *data)
 {
        uae_u8 cmd[10] = { 0 };
+
        cmd[0] = 0x28;
-       cmd[2] = h & 15;
-       cmd[3] = c >> 8;
-       cmd[4] = c;
-       cmd[5] = s;
+       cmd[2] = 0;
+       cmd[3] = 0;
+       cmd[4] = 0;
+       cmd[5] = 1;
        cmd[8] = 1;
-       return do_scsi_in(handle, cmd, 10, data, 512) > 0;
+       do_scsi_in(handle, cmd, 10, data, 512);
+
+       cmd[0] = 0x28;
+       if (lba != 0xffffffff) {
+               cmd[2] = lba >> 24;
+               cmd[3] = lba >> 16;
+               cmd[4] = lba >> 8;
+               cmd[5] = lba >> 0;
+       } else {
+               cmd[2] = h & 15;
+               cmd[3] = c >> 8;
+               cmd[4] = c;
+               cmd[5] = s;
+       }
+       cmd[8] = 1;
+       bool r = do_scsi_in(handle, cmd, 10, data, 512) > 0;
+       if (r) {
+               int s = 32;
+               int o = 0;
+               for (int i = 0; i < 512; i += s) {
+                       for (int j = 0; j < s; j++) {
+                               write_log(_T("%02x"), data[o + j]);
+                       }
+                       write_log(_T(" "));
+                       for (int j = 0; j < s; j++) {
+                               uae_u8 v = data[o + j];
+                               write_log(_T("%c"), v >= 32 && v <= 126 ? v : '.');
+                       }
+                       write_log(_T("\n"));
+                       o += s;
+               }
+       }
+       return r;
 }
 
 static bool hd_get_meta_satl(HWND hDlg, HANDLE h, uae_u8 *data, TCHAR *text, struct ini_data *ini, bool *atapi)
@@ -948,47 +981,45 @@ static bool hd_get_meta_satl(HWND hDlg, HANDLE h, uae_u8 *data, TCHAR *text, str
        }
 
        if (invalidcapacity) {
-               bool chs0 = do_scsi_read10_chs(h, 0, 0, 0, data);
-               bool chs1 = do_scsi_read10_chs(h, 0, 0, 1, data);
+               bool chs0 = do_scsi_read10_chs(h, 0xffffffff, 0, 0, 0, data);
+               bool chs1 = do_scsi_read10_chs(h, 0xffffffff, 0, 0, 1, data);
                write_log(_T("CHS0=%d CHS1=%d\n"), chs0, chs1);
-               if (!chs0 && chs1) {
-                       int hh, ss;
-                       for (ss = 1; ss < 256; ss++) {
-                               if (!do_scsi_read10_chs(h, 0, 0, ss, data)) {
-                                       ss--;
-                                       break;
-                               }
-                       }
-                       write_log(_T("Sectors=%d\n"), ss);
-                       for (hh = 0; hh < 16; hh++) {
-                               if (!do_scsi_read10_chs(h, 0, hh, 1, data)) {
-                                       break;
-                               }
+               int hh, ss;
+               for (ss = 1; ss < 256; ss++) {
+                       if (!do_scsi_read10_chs(h, 0xffffffff, 0, 0, ss, data)) {
+                               ss--;
+                               break;
                        }
-                       write_log(_T("Heads=%d\n"), hh);
-                       if (hh <= 0 || ss <= 1 || ss >= 256) {
-                               write_log(_T("Invalid H and/or S value.\n"));
-                               goto end;
+               }
+               write_log(_T("Sectors=%d\n"), ss);
+               for (hh = 0; hh < 16; hh++) {
+                       if (!do_scsi_read10_chs(h, 0xffffffff, 0, hh, 1, data)) {
+                               break;
                        }
+               }
+               write_log(_T("Heads=%d\n"), hh);
+               if (hh <= 0 || ss <= 1 || ss >= 256) {
+                       write_log(_T("Invalid H and/or S value.\n"));
+                       goto end;
+               }
 #if 0
-                       int cc;
-                       for (cc = 0; cc < 10000; cc++) {
-                               write_log(_T("%d "), cc);
-                               for (int hhh = 0; hhh < hh; hhh++) {
-                                       for(int sss = 1; sss < ss; sss++) {
-                                               if (!do_scsi_read10_chs(h, cc, hhh, sss, data)) {
-                                                       write_log("\n\n");
-                                                       if (hhh != 0 || sss != 1) {
-                                                               write_log(_T("Read error when not first head and sector! %d:%d:%d\n"), cc, hhh, sss);
-                                                       }
-                                                       goto end;
+               int cc;
+               for (cc = 0; cc < 10000; cc++) {
+                       write_log(_T("%d "), cc);
+                       for (int hhh = 0; hhh < hh; hhh++) {
+                               for (int sss = 1; sss < ss; sss++) {
+                                       if (!do_scsi_read10_chs(h, cc, hhh, sss, data)) {
+                                               write_log("\n\n");
+                                               if (hhh != 0 || sss != 1) {
+                                                       write_log(_T("Read error when not first head and sector! %d:%d:%d\n"), cc, hhh, sss);
                                                }
+                                               goto end;
                                        }
                                }
                        }
+               }
 #endif
 end:;
-               }
        }
 
        return ret;

diff --git a/od-win32/mman.cpp b/od-win32/mman.cpp
index d935d5f0b1a407032ff7e577c9014b260625233f..40d930550d088e35779d5712b08b2fe6537caa2a 100644 (file)
--- a/od-win32/mman.cpp
+++ b/od-win32/mman.cpp
@@ -736,9 +736,7 @@ bool uae_mman_info(addrbank *ab, struct uae_mman_data *md)
                got = true;
                if (!expansion_get_autoconfig_by_address(&currprefs, 0x00200000) && currprefs.chipmem_size == 2 * 1024 * 1024)
                        barrier = true;
-               if (currprefs.chipmem_size > 2 * 1024 * 1024)
-                       barrier = true;
-               if (currprefs.chipmem_size < 2 * 1024 * 1024 && !currprefs.cpu_compatible)
+               if (currprefs.chipmem_size != 2 * 1024 * 1024)
                        barrier = true;
        } else if (!_tcscmp(ab->label, _T("kick"))) {
                start = 0xf80000;

diff --git a/od-win32/win32.h b/od-win32/win32.h
index dde0b07c46f75b1e48ed7590768519fd9d9a265d..0c7d037a455edb0130d325ad091df0ee9fac91f1 100644 (file)
--- a/od-win32/win32.h
+++ b/od-win32/win32.h
@@ -20,12 +20,12 @@
 #define LANG_DLL_FULL_VERSION_MATCH 1
 
 #if WINUAEPUBLICBETA
-#define WINUAEBETA _T("16")
+#define WINUAEBETA _T("17")
 #else
 #define WINUAEBETA _T("")
 #endif
 
-#define WINUAEDATE MAKEBD(2018, 1, 1)
+#define WINUAEDATE MAKEBD(2018, 1, 6)
 
 //#define WINUAEEXTRA _T("AmiKit Preview")
 //#define WINUAEEXTRA _T("Amiga Forever Edition")

diff --git a/od-win32/winuaechangelog.txt b/od-win32/winuaechangelog.txt
index d171166446e1a561a1bf41f8d9e797ee304bd5cc..d2ead9676f171c57de9b37b1a93c65e2dfbcef08 100644 (file)
--- a/od-win32/winuaechangelog.txt
+++ b/od-win32/winuaechangelog.txt
@@ -4,6 +4,23 @@ JIT Direct current rules are less complex now. It automatically switches off onl
   - RTG VRAM is outside of reserved natmem space. Workaround: Move RTG in earlier position using Hardware info GUI panel.\r
   Note that in 64-bit version RTG VRAM must be inside of reserved natmem space. (Outside = error message and return back to GUI)\r
 \r
+\r
+Beta 17:\r
+\r
+- Added Profex HD3300 emulation and boot ROM.\r
+- Fixed rounding issue in D3D11 mode screen position calculation. (Single pixel offset in some situations)\r
+- 68040+ "cycle exact" could have appear hung if all running code and data fit in caches.\r
+- Geometry file parsing memory free bug fix.\r
+- Interlace artifact removal last flickering line fixed (b1)\r
+- Allow JIT direct in CSPPC configuration. This disables CSPPC Map ROM address mapping completely.\r
+- D3D11 threaded Present() calls removed, it is not compatible with some systems. (Caused blank screens when switching modes)\r
+- Re-initialize D3D11 display mode if ResizeBuffers() return an error instead of showing blank screen.\r
+- End of chip ram didn't have safety barrier if chip ram size was less than 2M. Unaligned long or word access from the very end of chip ram could have caused crash.\r
+\r
+Profex HD3300:\r
+- Yet another basic OMTI based HD controller.\r
+- "omti55.device 22.0 (17-Apr-1989) (c) 1988,1989 by Thomas Rudloff for Intelligent Memory Frankfurt, W. Germany"\r
+\r
 Beta 16:\r
 \r
 - Fixed statefile memory corruption if CPU is 68060. (Introduced when 68040/060 data cache support was added)\r

diff --git a/scsitape.cpp b/scsitape.cpp
index d3a9ee62c909c172ef6aefac77663bc48d3dd45d..22b310e1e21b01eae82083aac1dea7eb8bc5aaa3 100644 (file)
--- a/scsitape.cpp
+++ b/scsitape.cpp
@@ -531,8 +531,10 @@ int scsi_tape_emulate (struct scsi_data_tape *tape, uae_u8 *cmdbuf, int scsi_cmd
                if (tape->wp)
                        goto writeprot;
                // sanity check
-               if (len > 256)
+               if (len > 256) {
+                       write_log(_T("TAPEEMU: WRITE FILEMARK too many filemarks (%d)\n"), len);
                        len = 256;
+               }
                while (len > 0) {
                        tape_write_filemark(tape);
                        len--;