SDL_libretro_video.h

Go to the documentation of this file.

 
#if defined(SDL_LIBRETRO_IMPLEMENTATION) && !defined(SDL_LIBRETRO_VIDEO_IMPL_ONCE)
#define SDL_LIBRETRO_VIDEO_IMPL_ONCE
 
static SDL_PixelFormat SDL_Libretro_GetTextureFormat(enum retro_pixel_format fmt) {
    switch (fmt) {
        case RETRO_PIXEL_FORMAT_XRGB8888: return SDL_PIXELFORMAT_XRGB8888;
        case RETRO_PIXEL_FORMAT_RGB565: return SDL_PIXELFORMAT_RGB565;
        case RETRO_PIXEL_FORMAT_0RGB1555: return SDL_PIXELFORMAT_XRGB1555;
        default: return SDL_PIXELFORMAT_RGB565;
    }
}
 
static void SDL_Libretro_ReleaseSoftwareFramebuffer(SDL_Libretro* lr) {
    if (!lr->core.softwareFramebufferPixels) {
        return;
    }
    if (lr->core.texture) {
        SDL_UnlockTexture(lr->core.texture);
    }
    lr->core.softwareFramebufferPixels = NULL;
}
 
static bool SDL_Libretro_InitVideo(SDL_Libretro* lr) {
    if (!lr || !lr->renderer) return false;
 
    // Make sure we're starting a clean video context.
    SDL_Libretro_CloseVideo(lr);
 
    // If there is no desired width/height, select an arbitrary one.
    if (lr->core.width == 0 || lr->core.height == 0) {
        lr->core.width = 320;
        lr->core.height = 240;
    }
 
    // Build the Texture.
    lr->core.texture = SDL_CreateTexture(lr->renderer, SDL_Libretro_GetTextureFormat(lr->core.pixelFormat), SDL_TEXTUREACCESS_STREAMING, lr->core.width, lr->core.height);
 
    if (!lr->core.texture) {
        SDL_SetError("[SDL_Libretro] Failed to create texture: %s", SDL_GetError());
        return false;
    }
    lr->core.videoReinitPending = false;
 
    SDL_SetTextureScaleMode(lr->core.texture, lr->scaleMode);
    return true;
}
 
static void SDL_Libretro_CloseVideo(SDL_Libretro* lr) {
    if (!lr) return;
 
    SDL_Libretro_ReleaseSoftwareFramebuffer(lr);
    if (lr->core.texture) {
        SDL_DestroyTexture(lr->core.texture);
        lr->core.texture = NULL;
    }
}
 
static void SDL_Libretro_VideoRefresh(const void* data, unsigned width, unsigned height, size_t pitch) {
    SDL_Libretro* lr = SDL_Libretro_active;
    if (!lr) return;
 
    // Software framebuffer (RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER)
    if (lr->core.softwareFramebufferPixels) {
        void* swfb = lr->core.softwareFramebufferPixels;
        SDL_Libretro_ReleaseSoftwareFramebuffer(lr);
        if (data == swfb) return;
    }
 
    if (!data) return;
 
    // A hardware-rendered core signals its frame via this sentinel rather than a real pointer; we're software-only, so there's nothing to copy.
    if (data == RETRO_HW_FRAME_BUFFER_VALID) return;
 
    // Rebuild the texture when the core's frame dimensions change.
    if (width != lr->core.width || height != lr->core.height) {
        lr->core.width = width;
        lr->core.height = height;
        if (!SDL_Libretro_InitVideo(lr)) return;
    }
 
    // Make sure the texture is workable.
    if (!lr->core.texture) return;
 
    // Copy straight into the texture's backing memory to avoid the extra staging copy SDL_UpdateTexture() makes.
    void* pixels = NULL;
    int lockPitch = 0;
    if (!SDL_LockTexture(lr->core.texture, NULL, &pixels, &lockPitch)) {
        return;
    }
 
    // The core's `pitch` and the texture's locked pitch can differ, so copy row by row.
    const Uint8* src = (const Uint8*)data;
    Uint8* dst = (Uint8*)pixels;
    size_t rowBytes = pitch < (size_t)lockPitch ? pitch : (size_t)lockPitch;
    if (pitch == (size_t)lockPitch) {
        // The strides match, so we can do a straight copy.
        SDL_memcpy(dst, src, rowBytes * height);
    }
    else {
        for (size_t y = 0; y < height; y++) {
            SDL_memcpy(dst + y * lockPitch, src + y * pitch, rowBytes);
        }
    }
 
    SDL_UnlockTexture(lr->core.texture);
}
 
bool SDL_Libretro_SetRenderer(SDL_Libretro* lr, SDL_Renderer* renderer) {
    if (!lr || !renderer) {
        SDL_SetError("[SDL_Libretro] Invalid context");
        return false;
    }
 
    bool changed = (lr->renderer != renderer);
    lr->renderer = renderer;
    lr->window = SDL_GetRenderWindow(renderer);
 
    // Build the texture if a game is loaded but has none yet (deferred init after
    // a renderer-less LoadGame), or rebuild it against the new renderer on a swap
    // (a texture is bound to the renderer that created it). With no game loaded,
    // LoadGame's InitVideo handles it once the geometry is known.
    if (lr->core.gameLoaded && (!lr->core.texture || changed)) {
        return SDL_Libretro_InitVideo(lr);
    }
 
    return true;
}
 
SDL_Renderer* SDL_Libretro_GetRenderer(const SDL_Libretro* lr) {
    return lr ? lr->renderer : NULL;
}
 
SDL_Texture* SDL_Libretro_GetTexture(const SDL_Libretro* lr) {
    return (lr && lr->core.texture) ? lr->core.texture : NULL;
}
 
SDL_Surface* SDL_Libretro_CreateSurface(const SDL_Libretro* lr) {
    if (!lr || !lr->core.texture || !lr->renderer) return NULL;
 
    // Blit the current frame 1:1 into an offscreen target texture
    // and read it back.
    SDL_Renderer* renderer = lr->renderer;
    int w = (int)lr->core.width;
    int h = (int)lr->core.height;
 
    SDL_Texture* target = SDL_CreateTexture(renderer, SDL_Libretro_GetTextureFormat(lr->core.pixelFormat), SDL_TEXTUREACCESS_TARGET, w, h);
    if (!target) return NULL;
 
    SDL_Texture* prevTarget = SDL_GetRenderTarget(renderer);
    SDL_Surface* out = NULL;
    if (SDL_SetRenderTarget(renderer, target)) {
        // Draw the frame unscaled and unrotated into the target, then read it.
        if (SDL_RenderTexture(renderer, lr->core.texture, NULL, NULL)) {
            out = SDL_RenderReadPixels(renderer, NULL);
        }
        SDL_SetRenderTarget(renderer, prevTarget);
    }
 
    SDL_DestroyTexture(target);
    return out;
}
 
bool SDL_Libretro_SaveScreenshot(const SDL_Libretro* lr, const char* path) {
    SDL_Surface* screenshot = SDL_Libretro_CreateSurface(lr);
    if (screenshot == NULL) {
        return false;
    }
    bool saved = SDL_SavePNG(screenshot, path != NULL ? path : "screenshot.png");
    SDL_DestroySurface(screenshot);
    return saved;
}
 
static void SDL_Libretro_FitRect(const SDL_Libretro* lr, SDL_FRect* rect, bool rotated) {
    SDL_FRect avail = *rect;
 
    // Nothing to fit into a zero-size area, or when we're stretching it.
    if (avail.w <= 0.0f || avail.h <= 0.0f || lr->fitMode == SDL_LIBRETRO_FIT_STRETCH) return;
 
    // Fix the aspect ratio.
    float srcAspect = lr->core.aspectRatio;
    if (srcAspect <= 0.0f && lr->core.width > 0 && lr->core.height > 0) {
        srcAspect = (float)lr->core.width / (float)lr->core.height;
    }
 
    // Letterbox to the effective aspect ratio within the available area.
    float aspect = (rotated && srcAspect > 0.0f) ? 1.0f / srcAspect : srcAspect;
    if (aspect > 0.0f) {
        if (aspect > avail.w / avail.h) {
            rect->h = avail.w / aspect;
            rect->y = avail.y + (avail.h - rect->h) * 0.5f;
        }
        else {
            rect->w = avail.h * aspect;
            rect->x = avail.x + (avail.w - rect->w) * 0.5f;
        }
    }
 
    // Integer scaling: a quarter turn maps the core's width to the vertical
    // extent and its height to the horizontal.
    if (lr->fitMode == SDL_LIBRETRO_FIT_INTEGER && lr->core.width > 0 && lr->core.height > 0) {
        float coreW = rotated ? (float)lr->core.height : (float)lr->core.width;
        float coreH = rotated ? (float)lr->core.width : (float)lr->core.height;
        int scale = SDL_max(1, SDL_min((int)(rect->w / coreW), (int)(rect->h / coreH)));
        float w = coreW * (float)scale;
        float h = coreH * (float)scale;
        rect->x += (rect->w - w) * 0.5f;
        rect->y += (rect->h - h) * 0.5f;
        rect->w = w;
        rect->h = h;
    }
}
 
bool SDL_Libretro_Render(SDL_Libretro* lr, SDL_Renderer* renderer, const SDL_FRect* dstRect) {
    if (!lr || !renderer) return false;
 
    // Adopt the renderer if it changed or isn't initialized.
    if (renderer != lr->renderer && !SDL_Libretro_SetRenderer(lr, renderer)) return false;
 
    // Requires a texture to render.
    if (!lr->core.texture) return false;
 
    // Determine the destination area: the given rect, or the full render output.
    if (dstRect) {
        lr->core.renderDstRect = *dstRect;
    }
    else {
        // With logical presentation, draw in logical units; otherwise fill
        // the current output (the render target if one is set).
        int w, h;
        SDL_RendererLogicalPresentation mode = SDL_LOGICAL_PRESENTATION_DISABLED;
        if (!SDL_GetRenderLogicalPresentation(renderer, &w, &h, &mode) ||
            mode == SDL_LOGICAL_PRESENTATION_DISABLED) {
            if (!SDL_GetCurrentRenderOutputSize(renderer, &w, &h)) return false;
        }
        lr->core.renderDstRect = (SDL_FRect){0.0f, 0.0f, (float)w, (float)h};
    }
 
    // A 90/270 turn swaps the image's on-screen extents.
    bool rotated = (lr->core.rotation & 1) != 0;
 
    // Fit the destination to optimally fit within the renderer.
    SDL_Libretro_FitRect(lr, &lr->core.renderDstRect, rotated);
 
    // libretro SET_ROTATION is counter-clockwise, but SDL_RenderTextureRotated's
    // angle is clockwise, so negate it.
    double angle = -(lr->core.rotation * 90.0);
 
    if (rotated) {
        SDL_FRect dst = lr->core.renderDstRect;
        dst.w = lr->core.renderDstRect.h;
        dst.h = lr->core.renderDstRect.w;
        dst.x = lr->core.renderDstRect.x + (lr->core.renderDstRect.w - dst.w) * 0.5f;
        dst.y = lr->core.renderDstRect.y + (lr->core.renderDstRect.h - dst.h) * 0.5f;
        return SDL_RenderTextureRotated(renderer, lr->core.texture, NULL, &dst, angle, NULL, SDL_FLIP_NONE);
    }
 
    return SDL_RenderTextureRotated(renderer, lr->core.texture, NULL, &lr->core.renderDstRect, angle, NULL, SDL_FLIP_NONE);
}
 
void SDL_Libretro_GetSize(const SDL_Libretro* lr, int* w, int* h) {
    if (w) *w = lr ? (int)lr->core.width : 0;
    if (h) *h = lr ? (int)lr->core.height : 0;
}
 
float SDL_Libretro_GetAspectRatio(const SDL_Libretro* lr) {
    return lr ? lr->core.aspectRatio : 0.0f;
}
 
double SDL_Libretro_GetFPS(const SDL_Libretro* lr) {
    return lr ? lr->core.fps : 0.0;
}
 
int SDL_Libretro_GetRotation(const SDL_Libretro* lr) {
    return lr ? lr->core.rotation * 90 : 0;
}
 
bool SDL_Libretro_SetFitMode(SDL_Libretro* lr, SDL_LibretroFitMode mode) {
    if (!lr) return false;
    if ((int)mode < (int)SDL_LIBRETRO_FIT_FIRST || (int)mode >= (int)SDL_LIBRETRO_FIT_COUNT) {
        return SDL_InvalidParamError("mode");
    }
    lr->fitMode = mode;
    return true;
}
 
SDL_LibretroFitMode SDL_Libretro_GetFitMode(const SDL_Libretro* lr) {
    return lr ? lr->fitMode : SDL_LIBRETRO_FIT_ASPECT;
}
 
bool SDL_Libretro_SetScaleMode(SDL_Libretro* lr, SDL_ScaleMode mode) {
    if (!lr) return false;
    bool valid = (mode == SDL_SCALEMODE_NEAREST || mode == SDL_SCALEMODE_LINEAR);
#if SDL_VERSION_ATLEAST(3, 4, 0)
    if (mode == SDL_SCALEMODE_PIXELART) valid = true;
#endif
    if (!valid) {
        return SDL_InvalidParamError("mode");
    }
    lr->scaleMode = mode;
    if (lr->core.texture) {
        SDL_SetTextureScaleMode(lr->core.texture, mode);
    }
    return true;
}
 
SDL_ScaleMode SDL_Libretro_GetScaleMode(const SDL_Libretro* lr) {
    return lr ? lr->scaleMode : SDL_SCALEMODE_NEAREST;
}
 
#endif /* SDL_LIBRETRO_VIDEO_IMPL_ONCE */