Return to nd_sdl.c CVS log

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

Annotation of previous/src/dimension/nd_sdl.c, revision 1.1

1.1     ! root        1: #include "main.h"
        !             2: #include "nd_sdl.h"
        !             3: #include "configuration.h"
        !             4: #include "dimension.h"
        !             5: #include "screen.h"
        !             6: 
        !             7: /* Because of SDL time (in)accuracy, timing is very approximative */
        !             8: const int DISPLAY_VBL_MS = 1000 / 68; // main display at 68Hz, actually this is 71.42 Hz because (int)1000/(int)68Hz=14ms
        !             9: const int VIDEO_VBL_MS   = 1000 / 60; // NTSC display at 60Hz, actually this is 62.5 Hz because (int)1000/(int)60Hz=16ms
        !            10: const int BLANK_MS       = 2;         // Give some blank time for both
        !            11: 
        !            12: extern Uint32      nd_display_blank_start();
        !            13: extern Uint32      nd_display_blank_end();
        !            14: extern Uint32      nd_video_vbl(Uint32 interval, void* param);
        !            15: 
        !            16: static SDL_TimerID   videoVBL      = NULL;
        !            17: static volatile bool doRepaint     = true;
        !            18: static SDL_Thread*   repaintThread = NULL;
        !            19: static SDL_Window*   ndWindow      = NULL;
        !            20: 
        !            21: extern void blitDimension(SDL_Texture* tex);
        !            22: 
        !            23: static int repainter(void* unused) {
        !            24:     SDL_Texture*  ndTexture  = NULL;
        !            25:     SDL_Renderer* ndRenderer = NULL;
        !            26:     
        !            27:     ndRenderer = SDL_CreateRenderer(ndWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
        !            28:     if (!ndWindow || !ndRenderer) {
        !            29:         fprintf(stderr,"[ND] Failed to create renderer!\n");
        !            30:         exit(-1);
        !            31:     }
        !            32:     SDL_Rect r = {0,0,1120,832};
        !            33:     SDL_RenderSetLogicalSize(ndRenderer, r.w, r.h);
        !            34:     ndTexture = SDL_CreateTexture(ndRenderer, SDL_PIXELFORMAT_UNKNOWN, SDL_TEXTUREACCESS_STREAMING, r.w, r.h);
        !            35:     
        !            36:     while(doRepaint) {
        !            37:         if(ConfigureParams.Screen.nMonitorType == MONITOR_TYPE_DUAL) {
        !            38:             blitDimension(ndTexture);
        !            39:             SDL_RenderCopy(ndRenderer, ndTexture, NULL, NULL);
        !            40:             SDL_RenderPresent(ndRenderer);
        !            41:         } else {
        !            42:             SDL_Delay(VIDEO_VBL_MS - BLANK_MS);
        !            43:         }
        !            44:         // if this is a cube, then do ND blank emulation.
        !            45:         if(ConfigureParams.System.nMachineType == NEXT_CUBE030 || ConfigureParams.System.nMachineType == NEXT_CUBE040) {
        !            46:             nd_display_blank_start();
        !            47:             SDL_Delay(BLANK_MS);
        !            48:             nd_display_blank_end();
        !            49:         }
        !            50:     }
        !            51: 
        !            52:     SDL_DestroyTexture(ndTexture);
        !            53:     SDL_DestroyRenderer(ndRenderer);
        !            54:     SDL_DestroyWindow(ndWindow);
        !            55: 
        !            56:     return 0;
        !            57: }
        !            58: 
        !            59: void nd_sdl_init() {
        !            60:     if(!(repaintThread)) {
        !            61:         int x, y, w, h;
        !            62:         SDL_GetWindowPosition(sdlWindow, &x, &y);
        !            63:         SDL_GetWindowSize(sdlWindow, &w, &h);
        !            64:         ndWindow      = SDL_CreateWindow("NeXT Dimension",(x-w)+1, y, 1120, 832, SDL_WINDOW_HIDDEN);
        !            65:         repaintThread = SDL_CreateThread(repainter, "[ND] repainter", NULL);
        !            66:     }
        !            67:     if(videoVBL) SDL_RemoveTimer(videoVBL);
        !            68:     // NTSC video at 60Hz
        !            69:     videoVBL   = SDL_AddTimer(VIDEO_VBL_MS, nd_video_vbl, NULL);
        !            70:     
        !            71:     if(ConfigureParams.Screen.nMonitorType == MONITOR_TYPE_DUAL) {
        !            72:         SDL_ShowWindow(ndWindow);
        !            73:     } else {
        !            74:         SDL_HideWindow(ndWindow);
        !            75:     }
        !            76: }
        !            77: 
        !            78: void nd_sdl_uninit() {
        !            79:     if(videoVBL) {
        !            80:         SDL_RemoveTimer(videoVBL);
        !            81:         videoVBL = NULL;
        !            82:     }
        !            83:     SDL_HideWindow(ndWindow);
        !            84: }
        !            85: 
        !            86: void nd_sdl_destroy() {
        !            87:     doRepaint = false; // stop repaint thread
        !            88:     int s;
        !            89:     SDL_WaitThread(repaintThread, &s);
        !            90:     nd_sdl_uninit();
        !            91: }
        !            92: 
        !            93: //----- SDL abstractions for ND implementation
        !            94: 
        !            95: void lock(lock_t* lock) {
        !            96:     SDL_AtomicLock(lock);
        !            97: }
        !            98: 
        !            99: int trylock(lock_t* lock) {
        !           100:     return SDL_AtomicTryLock(lock);
        !           101: }
        !           102: 
        !           103: void unlock(lock_t* lock) {
        !           104:     SDL_AtomicUnlock(lock);
        !           105: }
        !           106: 
        !           107: void checklock(lock_t* lock) {
        !           108:     SDL_AtomicLock(lock);
        !           109:     SDL_AtomicUnlock(lock);
        !           110: }
        !           111: 
        !           112: Uint32 time_ms() {
        !           113:     return SDL_GetTicks();
        !           114: }
        !           115: 
        !           116: void sleep_ms(Uint32 ms) {
        !           117:     SDL_Delay(ms);
        !           118: }
        !           119: 
        !           120: thread_t* thread_create(thread_func_t func, void* data) {
        !           121:     return SDL_CreateThread(func, "[ND] Thread", data);
        !           122: }
        !           123: 
        !           124: int thread_wait(thread_t* thread) {
        !           125:     int status;
        !           126:     SDL_WaitThread(thread, &status);
        !           127:     return status;
        !           128: }

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