Return to nd_sdl.cpp CVS log

Up to [Previous NeXT emulator] / previous_trunk / src / dimension

Annotation of previous_trunk/src/dimension/nd_sdl.cpp, revision 1.1.1.1

1.1       root        1: #include "main.h"
                      2: #include "nd_sdl.hpp"
                      3: #include "configuration.h"
                      4: #include "dimension.hpp"
                      5: #include "screen.h"
                      6: #include "host.h"
                      7: #include "cycInt.h"
                      8: #include "NextBus.hpp"
                      9: 
                     10: /* Because of SDL time (in)accuracy, timing is very approximative */
                     11: const int DISPLAY_VBL_MS = 1000 / 68; // main display at 68Hz, actually this is 71.42 Hz because (int)1000/(int)68Hz=14ms
                     12: const int VIDEO_VBL_MS   = 1000 / 60; // NTSC display at 60Hz, actually this is 62.5 Hz because (int)1000/(int)60Hz=16ms
                     13: const int BLANK_MS       = 2;         // Give some blank time for both
                     14: 
                     15: NDSDL::NDSDL(int slot, Uint32* vram) : slot(slot), doRepaint(true), repaintThread(NULL), ndWindow(NULL), ndRenderer(NULL), vram(vram) {}
                     16: 
                     17: 
                     18: int NDSDL::repainter(void *_this) {
                     19:     return ((NDSDL*)_this)->repainter();
                     20: }
                     21: 
                     22: int NDSDL::repainter(void) {
                     23:     SDL_SetThreadPriority(SDL_THREAD_PRIORITY_NORMAL);
                     24:     
                     25:     SDL_Texture*  ndTexture  = NULL;
                     26:     
                     27:     SDL_Rect r = {0,0,1120,832};
                     28:     
                     29:     ndRenderer = SDL_CreateRenderer(ndWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
                     30:     
                     31:     if (!ndRenderer) {
                     32:         fprintf(stderr,"[ND] Slot %i: Failed to create renderer!\n", slot);
                     33:         exit(-1);
                     34:     }
                     35:     
                     36:     SDL_RenderSetLogicalSize(ndRenderer, r.w, r.h);
                     37:     ndTexture = SDL_CreateTexture(ndRenderer, SDL_PIXELFORMAT_UNKNOWN, SDL_TEXTUREACCESS_STREAMING, r.w, r.h);
                     38:     
                     39:     SDL_AtomicSet(&blitNDFB, 1);
                     40:     
                     41:     while(doRepaint) {
                     42:         if (SDL_AtomicGet(&blitNDFB)) {
                     43:             blitDimension(vram, ndTexture);
                     44:             SDL_RenderCopy(ndRenderer, ndTexture, NULL, NULL);
                     45:             SDL_RenderPresent(ndRenderer);
                     46:         } else {
                     47:             host_sleep_ms(100);
                     48:         }
                     49:     }
                     50: 
                     51:     SDL_DestroyTexture(ndTexture);
                     52:     SDL_DestroyRenderer(ndRenderer);
                     53:     SDL_DestroyWindow(ndWindow);
                     54: 
                     55:     return 0;
                     56: }
                     57: 
                     58: void NDSDL::init(void) {
                     59:     if(!(repaintThread)) {
                     60:         int x, y, w, h;
                     61:         char title[32];
                     62:         SDL_GetWindowPosition(sdlWindow, &x, &y);
                     63:         SDL_GetWindowSize(sdlWindow, &w, &h);
                     64:         sprintf(title, "NeXTdimension (Slot %i)", slot);
                     65:         ndWindow = SDL_CreateWindow(title, (x-w)+1, y, 1120, 832, SDL_WINDOW_HIDDEN);
                     66:         
                     67:         if (!ndWindow) {
                     68:             fprintf(stderr,"[ND] Slot %i: Failed to create window!\n", slot);
                     69:             exit(-1);
                     70:         }
                     71:     }
                     72:     
                     73:     if(ConfigureParams.Screen.nMonitorType == MONITOR_TYPE_DUAL) {
                     74:         SDL_ShowWindow(ndWindow);
                     75:     } else {
                     76:         SDL_HideWindow(ndWindow);
                     77:     }
                     78: }
                     79: 
                     80: void NDSDL::start_interrupts() {
                     81:     char name[32];
                     82:     
                     83:     if (!(repaintThread) && ConfigureParams.Screen.nMonitorType == MONITOR_TYPE_DUAL) {
                     84:         sprintf(name, "[ND] Slot %i: Repainter", slot);
                     85:         repaintThread = SDL_CreateThread(NDSDL::repainter, name, this);
                     86:     }
                     87:     
                     88:     CycInt_AddRelativeInterruptUs(1000, 0, INTERRUPT_ND_VBL);
                     89:     CycInt_AddRelativeInterruptUs(1000, 0, INTERRUPT_ND_VIDEO_VBL);
                     90: }
                     91: 
                     92: void nd_vbl_handler(void)       {
                     93:     CycInt_AcknowledgeInterrupt();
                     94: 
                     95:     FOR_EACH_SLOT(slot) {
                     96:         IF_NEXT_DIMENSION(slot, nd) {
                     97:             host_blank(nd->slot, ND_DISPLAY, nd->sdl.ndVBLtoggle);
                     98:             nd->sdl.ndVBLtoggle = !nd->sdl.ndVBLtoggle;
                     99:             nd->i860.i860cycles = (1000*1000*33)/136;
                    100:         }
                    101:     }
                    102:     // 136Hz with toggle gives 68Hz, blank time is 1/2 frame time
                    103:     CycInt_AddRelativeInterruptUs((1000*1000)/136, 0, INTERRUPT_ND_VBL);
                    104: }
                    105: void nd_video_vbl_handler(void) {
                    106:     CycInt_AcknowledgeInterrupt();
                    107: 
                    108:     FOR_EACH_SLOT(slot) {
                    109:         IF_NEXT_DIMENSION(slot, nd) {
                    110:             host_blank(slot, ND_VIDEO, nd->sdl.ndVideoVBLtoggle);
                    111:             nd->sdl.ndVideoVBLtoggle = !nd->sdl.ndVideoVBLtoggle;
                    112:         }
                    113:     }
                    114:     
                    115:     // 120Hz with toggle gives 60Hz NTSC, blank time is 1/2 frame time
                    116:     CycInt_AddRelativeInterruptUs((1000*1000)/120, 0, INTERRUPT_ND_VIDEO_VBL);
                    117: }
                    118: 
                    119: void NDSDL::uninit(void) {
                    120:     SDL_HideWindow(ndWindow);
                    121: }
                    122: 
                    123: void NDSDL::pause(bool pause) {
                    124:     SDL_AtomicSet(&blitNDFB, pause ? 0 : 1);
                    125: }
                    126: 
                    127: void nd_sdl_destroy(void) {
                    128:     FOR_EACH_SLOT(slot) {
                    129:         IF_NEXT_DIMENSION(slot, nd) {
                    130:             nd->sdl.destroy();
                    131:         }
                    132:     }
                    133: }
                    134: 
                    135: void NDSDL::destroy(void) {
                    136:     doRepaint = false; // stop repaint thread
                    137:     int s;
                    138:     SDL_WaitThread(repaintThread, &s);
                    139:     uninit();
                    140: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.