Everything before initial synced list

Signed-off-by: Andrew Opalach <andrew@akon.city>

8 files changed, 180 insertions, 131 deletions

diff --git a/src/render/meson.build b/src/render/meson.build
index 20f68c3..b62a5a5 100644
--- a/src/render/meson.build
+++ b/src/render/meson.build
@@ -1,58 +1,62 @@
 render_src = []
 render_deps = [common_deps]
+render_args = []
 
-#linmath = subproject('linmath.h').get_variable('linmath')
-#libm = compiler.find_library('m', required: false)
-#if libm.found()
-#  render_deps += [libm]
-#endif
-#render_src += ['renderer_tiger.c', 'queue_tiger.c']
-#render_deps += [linmath]
-
-libplacebo_opts = [
-  'warning_level=2',
-  'demos=false',
-  'tests=false',
-  'bench=false',
-  'fuzz=false',
-  'glslang=disabled',
-  'gl-proc-addr=disabled',
-  'vk-proc-addr=disabled',
-  'd3d11=disabled',
-  'lcms=disabled',
-  'dovi=disabled',
-  'libdovi=disabled'
-]
-
-if sink_use_vulkan
-  shaderc_opts = cmake.subproject_options()
-  shaderc_opts.add_cmake_defines({ 'CMAKE_BUILD_TYPE': is_debug ? 'Debug' : 'Release' })
-  shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_INSTALL': false })
-  shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_TESTS': true })
-  shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_EXAMPLES': true })
-  shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_COPYRIGHT_CHECK': true })
-  shaderc_proj = cmake.subproject('shaderc', options: shaderc_opts)
-  shaderc = shaderc_proj.dependency('shaderc')
-  meson.override_dependency('shaderc', shaderc)
-  render_deps += [
-    shaderc_proj.dependency('shaderc_util'),
-    shaderc_proj.dependency('glslang'),
-    shaderc_proj.dependency('MachineIndependent'),
-    shaderc_proj.dependency('OSDependent'),
-    shaderc_proj.dependency('GenericCodeGen'),
-    shaderc_proj.dependency('SPIRV'),
-    shaderc_proj.dependency('SPIRV-Tools-opt'),
-    shaderc_proj.dependency('SPIRV-Tools-static')
+if get_option('renderer') == 'tiger'
+  render_src += ['renderer_tiger.c', 'queue_tiger.c']
+  linmath_h = subproject('linmath.h').get_variable('linmath_h')
+  render_deps += [linmath_h]
+  libm = compiler.find_library('m', required: false)
+  if libm.found()
+    render_deps += [libm]
+  endif
+  render_args += ['-DCAMU_RENDERER_TIGER']
+elif get_option('renderer') == 'libplacebo'
+  libplacebo_opts = ['warning_level=2', 'demos=false', 'tests=false', 'bench=false', 'fuzz=false',
+    'glslang=disabled',
+    'gl-proc-addr=disabled',
+    'vk-proc-addr=disabled',
+    'd3d11=disabled',
+    'lcms=disabled',
+    'dovi=disabled',
+    'libdovi=disabled'
   ]
-  libplacebo_opts += ['shaderc=enabled', 'vulkan=enabled', 'opengl=disabled']
-else
-  libplacebo_opts += ['shaderc=disabled', 'opengl=enabled', 'vulkan=disabled']
-endif
 
-libplacebo = dependency('libplacebo', default_options: libplacebo_opts)
-if libplacebo.found()
+  if sink_use_vulkan
+    shaderc = dependency('shaderc', required: false, allow_fallback: false)
+    if shaderc.found()
+      render_deps += [shaderc]
+    else
+      shaderc_opts = cmake.subproject_options()
+      reltype = is_minsize ? 'MinSizeRel' : 'Release'
+      shaderc_opts.add_cmake_defines({ 'CMAKE_BUILD_TYPE': is_debug ? 'Debug' : reltype })
+      shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_INSTALL': true })
+      shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_TESTS': true })
+      shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_EXAMPLES': true })
+      shaderc_opts.add_cmake_defines({ 'SHADERC_SKIP_COPYRIGHT_CHECK': true })
+      shaderc_proj = cmake.subproject('shaderc', options: shaderc_opts)
+      shaderc = shaderc_proj.dependency('shaderc')
+      meson.override_dependency('shaderc', shaderc)
+      render_deps += [
+        shaderc_proj.dependency('shaderc_util'),
+        shaderc_proj.dependency('glslang'),
+        shaderc_proj.dependency('MachineIndependent'),
+        shaderc_proj.dependency('OSDependent'),
+        shaderc_proj.dependency('GenericCodeGen'),
+        shaderc_proj.dependency('SPIRV'),
+        shaderc_proj.dependency('SPIRV-Tools-opt'),
+        shaderc_proj.dependency('SPIRV-Tools-static')
+      ]
+    endif
+    libplacebo_opts += ['shaderc=enabled', 'vulkan=enabled', 'opengl=disabled']
+  else
+    libplacebo_opts += ['shaderc=disabled', 'opengl=enabled', 'vulkan=disabled']
+  endif
+
+  libplacebo = dependency('libplacebo', default_options: libplacebo_opts)
   render_src += ['renderer_libplacebo.c', 'queue_libplacebo.c']
   render_deps += [libplacebo]
+  render_args += ['-DCAMU_RENDERER_LIBPLACEBO']
 endif
 
-render = declare_dependency(sources: render_src, dependencies: render_deps)
+render = declare_dependency(sources: render_src, dependencies: render_deps, compile_args: render_args)
diff --git a/src/render/queue_libplacebo.c b/src/render/queue_libplacebo.c
index 6316fe2..bd5ed7b 100644
--- a/src/render/queue_libplacebo.c
+++ b/src/render/queue_libplacebo.c
@@ -12,49 +12,65 @@
 static bool map_frame(pl_gpu gpu, pl_tex *tex, const struct pl_source_frame *src,
     struct pl_frame *out_frame)
 {
-    struct camu_frame *frame = src->frame_data;
+    struct camu_codec_frame *frame = src->frame_data;
 
-    u64 masks[4] = { 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
-    s32 pixel_stride = 4;
-
-    /*
-    switch (frame->fmt) {
-    case CAMU_PIXEL_FMT_RGBA:
+    u64 masks[4] = { 0 };
+    s32 pixel_stride;
+    switch (frame->format) {
+    case CAMU_PIXEL_FORMAT_RGBA:
+        masks[0] = 0x000000ff;
+        masks[1] = 0x0000ff00;
+        masks[2] = 0x00ff0000;
+        masks[3] = 0xff000000;
+        pixel_stride = 4;
+        break;
+    case CAMU_PIXEL_FORMAT_RGB:
+        masks[0] = 0x000000ff;
+        masks[1] = 0x0000ff00;
+        masks[2] = 0x00ff0000;
+        pixel_stride = 3;
+        break;
+    case CAMU_PIXEL_FORMAT_GREYA:
+        masks[0] = 0x000000ff;
+        masks[1] = 0x0000ff00;
+        pixel_stride = 2;
+        break;
+    case CAMU_PIXEL_FORMAT_GREY:
+        masks[0] = 0x000000ff;
+        pixel_stride = 1;
         break;
     default:
         al_log_error("frame_queue_libplacebo", "Unsuppored pixel format.");
-        return false;
+        al_assert_and_return(false);
     }
-    */
 
     struct pl_plane_data data = {
         .type = PL_FMT_UNORM,
-        .width = frame->width,
-        .height = frame->height,
+        .width = frame->video.width,
+        .height = frame->video.height,
         .pixel_stride = pixel_stride,
-        .row_stride = frame->width * pixel_stride,
+        .row_stride = frame->video.width * pixel_stride,
         .pixels = frame->data
     };
-
     pl_plane_data_from_mask(&data, masks);
 
     struct pl_plane plane = { 0 };
     bool ok = pl_upload_plane(gpu, &plane, tex, &data);
 
-    al_free(frame);
+    out_frame->num_planes = 1;
+    out_frame->planes[0] = plane;
+    out_frame->repr = pl_color_repr_unknown;
+    out_frame->color = pl_color_space_monitor;
+    out_frame->crop = (pl_rect2df){ 0, 0, frame->video.width, frame->video.height };
+    //out_frame->profile =
+
+    camu_codec_frame_discard(frame);
 
     if (!ok) {
         al_log_error("frame_queue_libplacebo", "Failed to upload texture.");
         return false;
     }
 
-    out_frame->num_planes = 1;
-    out_frame->planes[0] = plane;
-    out_frame->repr = pl_color_repr_unknown;
-    out_frame->color = pl_color_space_unknown;
-    out_frame->crop = (pl_rect2df){ 0, 0, frame->width, frame->height };
-    //out_frame->profile =
-
     return true;
 }
 
@@ -67,11 +83,11 @@ static void unmap_frame(pl_gpu gpu, struct pl_frame *frame, const struct pl_sour
 
 static void discard_frame(const struct pl_source_frame *src)
 {
-    struct camu_frame *frame = src->frame_data;
-    al_free(frame);
+    struct camu_codec_frame *frame = src->frame_data;
+    camu_codec_frame_discard(frame);
 }
 
-static void queue_lp_push(struct camu_frame_queue *queue, struct camu_frame *frame, f64 pts)
+static void queue_lp_push(struct camu_frame_queue *queue, struct camu_codec_frame *frame, f64 pts)
 {
     struct camu_frame_queue_lp *lq = (struct camu_frame_queue_lp *)queue;
     pl_queue_push(lq->queue, &(struct pl_source_frame){
@@ -80,7 +96,7 @@ static void queue_lp_push(struct camu_frame_queue *queue, struct camu_frame *fra
         .map = map_frame,
         .unmap = unmap_frame,
         .discard = discard_frame,
-        .frame_data = frame,
+        .frame_data = frame
     });
 }
 
diff --git a/src/render/queue_tiger.c b/src/render/queue_tiger.c
index 0e76502..b1c34ca 100644
--- a/src/render/queue_tiger.c
+++ b/src/render/queue_tiger.c
@@ -1,10 +1,9 @@
 #include <al/lib.h>
+#include <stl/gl.h>
 
-#include "renderer_tiger.h"
 #include "queue_tiger.h"
 
-static void upload_texture(struct camu_frame_queue_tiger *tq, s32 width, s32 height,
-    u8 *data, s32 linesize)
+static void upload_texture(struct camu_frame_queue_tiger *tq, struct camu_codec_frame *frame)
 {
     glGenTextures(1, &tq->texture_id);
     glActiveTexture(GL_TEXTURE0);
@@ -19,18 +18,28 @@ static void upload_texture(struct camu_frame_queue_tiger *tq, s32 width, s32 hei
     //if (linesize) {
     //    glPixelStorei(GL_UNPACK_ROW_LENGTH, linesize);
     //}
-    (void)linesize;
     //glPixelStorei(GL_UNPACK_ROW_LENGTH, linesize);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-    //glGenerateMipmap(GL_TEXTURE_2D);
+    switch (frame->format) {
+    case CAMU_PIXEL_FORMAT_RGBA:
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, frame->width, frame->height, 0,
+            GL_RGBA, GL_UNSIGNED_BYTE, frame->data);
+        break;
+    case CAMU_PIXEL_FORMAT_RGB:
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, frame->width, frame->height, 0,
+            GL_RGB, GL_UNSIGNED_BYTE, frame->data);
+        break;
+    default:
+        al_assert(false);
+    }
+    glGenerateMipmap(GL_TEXTURE_2D);
 }
 
-static void queue_tiger_push(struct camu_frame_queue *queue, struct camu_frame *frame, f64 pts)
+static void queue_tiger_push(struct camu_frame_queue *queue, struct camu_codec_frame *frame, f64 pts)
 {
     struct camu_frame_queue_tiger *tq = (struct camu_frame_queue_tiger *)queue;
     (void)pts;
-    upload_texture(tq, frame->width, frame->height, frame->data, 0);
+    tq->queued_frame = frame;
 }
 
 #ifdef CAMU_HAVE_FFMPEG
@@ -38,7 +47,6 @@ static void queue_tiger_push_av_frame(struct camu_frame_queue *queue, AVFrame *f
 {
     struct camu_frame_queue_tiger *tq = (struct camu_frame_queue_tiger *)queue;
     (void)pts;
-    upload_texture(tq, frame->width, frame->height, frame->data[0], frame->linesize[0]);
 }
 #endif
 
@@ -58,6 +66,13 @@ static u8 queue_tiger_read(struct camu_frame_queue *queue, f64 pts, void *out)
 {
     struct camu_frame_queue_tiger *tq = (struct camu_frame_queue_tiger *)queue;
     (void)pts;
+    if (tq->queued_frame) {
+        struct camu_codec_frame *frame = tq->queued_frame;
+        upload_texture(tq, frame);
+        tq->queued_frame = NULL;
+        tq->uploaded = true;
+    }
+    if (!tq->uploaded) return CAMU_QUEUE_MORE;
     *((GLuint *)out) = tq->texture_id;
     return CAMU_QUEUE_OK;
 }
@@ -79,6 +94,8 @@ static void queue_tiger_free(struct camu_frame_queue **queue)
 struct camu_frame_queue *camu_frame_queue_tiger_create(void)
 {
     struct camu_frame_queue_tiger *tq = al_alloc_object(struct camu_frame_queue_tiger);
+    tq->queued_frame = NULL;
+    tq->uploaded = false;
     tq->q.push = queue_tiger_push;
 #ifdef CAMU_HAVE_FFMPEG
     tq->q.push_av_frame = queue_tiger_push_av_frame;
diff --git a/src/render/queue_tiger.h b/src/render/queue_tiger.h
index db675df..a90d8c7 100644
--- a/src/render/queue_tiger.h
+++ b/src/render/queue_tiger.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <skh/gl.h>
+#include <stl/gl.h>
 
 #include "../buffer/frame_queue.h"
 
@@ -8,6 +8,8 @@ struct camu_frame_queue_tiger {
     struct camu_frame_queue q;
     GLuint texture_id;
     struct camu_renderer_tiger *tr;
+    struct camu_codec_frame *queued_frame;
+    bool uploaded;
 };
 
 struct camu_frame_queue *camu_frame_queue_tiger_create(void);
diff --git a/src/render/renderer.h b/src/render/renderer.h
index e60c3a5..5b1d342 100644
--- a/src/render/renderer.h
+++ b/src/render/renderer.h
@@ -1,20 +1,19 @@
 #pragma once
 
 #include <al/types.h>
-#include <skh/window.h>
+#include <stl/window.h>
 #ifdef CAMU_HAVE_FFMPEG
 #include <libavcodec/avcodec.h>
 #endif
 
-#include "../buffer/frame_queue.h"
-
-#if defined SEKIHI_API_OPENGL
+#if defined STELA_API_OPENGL
 #define CAMU_RENDERER_OPENGL
-#elif defined SEKIHI_API_VULKAN
+#elif defined STELA_API_VULKAN
 #define CAMU_RENDERER_VULKAN
 #endif
 
 struct camu_screen;
+struct camu_frame_queue;
 struct camu_renderer {
     bool (*create_renderer)(
         struct camu_renderer *, s32 *, s32 *,
diff --git a/src/render/renderer_libplacebo.c b/src/render/renderer_libplacebo.c
index 9cc0917..eeef565 100644
--- a/src/render/renderer_libplacebo.c
+++ b/src/render/renderer_libplacebo.c
@@ -130,18 +130,20 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, s32 *wid
 
     lr->renderer = pl_renderer_create(lr->logger, lr->gpu);
 
-    lr->r.resize(&lr->r, width, height);
+    pl_swapchain_resize(lr->swapchain, width, height);
 
     al_memset(&lr->params, 0, sizeof(struct pl_render_params));
-    //lr->params = pl_render_default_params;
-    lr->params = pl_render_fast_params;
-    lr->params.upscaler = &pl_filter_box;
+    //lr->params = pl_render_fast_params;
+    //lr->params.upscaler = &pl_filter_nearest;
+    lr->params = pl_render_default_params;
+    //lr->params = pl_render_high_quality_params;
+    lr->params.deband_params = NULL;
 
-    // Clear manually so we can draw multiple images per frame.
-    lr->params.skip_target_clearing = true;
-    // Breaks zoom/pan.
+    // Don't let the cache treat different images of the same size as the same frame.
     lr->params.skip_caching_single_frame = true;
-    // Prioritize a more consistant image (should be configurable).
+    // Clear manually so we can draw multiple images per frame.
+    lr->params.border = PL_CLEAR_SKIP;
+    // Prioritize a more consistant image.
     lr->params.correct_subpixel_offsets = true;
 
 #if 0
@@ -159,8 +161,8 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, s32 *wid
 #endif
 
 #ifdef CAMU_HAVE_FFMPEG
-    //lr->r.get_buffer2 = pl_get_buffer2;
-    //lr->r.opaque = &lr->gpu;
+    lr->r.get_buffer2 = pl_get_buffer2;
+    lr->r.opaque = &lr->gpu;
 #endif
 
     return true;
@@ -187,32 +189,23 @@ static void renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
     struct camu_renderer_lp *lr = (struct camu_renderer_lp *)renderer;
 
 #ifdef CAMU_SCREEN_THREADED
-    if (al_atomic_bool_load(&scr->queued, AL_ATOMIC_RELAXED)) {
+    if (al_atomic_load(u8)(&scr->queued, AL_ATOMIC_RELAXED)) {
         camu_screen_run_queue(scr);
     }
 #endif
 
-    bool have_frame = false;
     struct pl_swapchain_frame frame;
     struct pl_frame target;
     struct pl_frame_mix mix;
 
-#if 1
     pl_swapchain_start_frame(lr->swapchain, &frame);
     pl_frame_from_swapchain(&target, &frame);
     pl_frame_clear_rgba(lr->gpu, &target, clear_color);
-    have_frame = true;
-#endif
 
-    if (scr->videos.size > 0) {
-        struct camu_screen_video *video = &al_array_last(scr->videos);
+    struct camu_screen_video *video;
+    while (scr->videos.size > 0) {
+        video = &al_array_last(scr->videos);
         if (camu_video_buffer_read(video->buf, &mix) && mix.frames) {
-            if (!have_frame) {
-                pl_swapchain_start_frame(lr->swapchain, &frame);
-                pl_frame_from_swapchain(&target, &frame);
-                pl_frame_clear_rgba(lr->gpu, &target, clear_color);
-                have_frame = true;
-            }
             target.crop = mix.frames[0]->crop;
             target.crop.x1 *= video->view.zoom / video->view.stretch;
             target.crop.y1 *= video->view.zoom * video->view.stretch;
@@ -221,14 +214,22 @@ static void renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
             target.crop.x1 += video->view.x_offset;
             target.crop.y1 += video->view.y_offset;
             target.rotation = video->view.rotation;
+            //lr->params.color_adjustment = pl_color_adjustment(
+            //    .saturation = 0.0
+            //);
             pl_render_image_mix(lr->renderer, &mix, &target, &lr->params);
+            break;
+#ifdef CAMU_SCREEN_THREADED
+        } else {
+            if (al_atomic_load(u8)(&scr->queued, AL_ATOMIC_RELAXED)) {
+                camu_screen_run_queue(scr);
+            }
+#endif
         }
     }
 
-    if (have_frame) {
-        pl_swapchain_submit_frame(lr->swapchain);
-        pl_swapchain_swap_buffers(lr->swapchain);
-    }
+    pl_swapchain_submit_frame(lr->swapchain);
+    pl_swapchain_swap_buffers(lr->swapchain);
 }
 
 void renderer_lp_free(struct camu_renderer **renderer)
diff --git a/src/render/renderer_tiger.c b/src/render/renderer_tiger.c
index 049a3b6..7127891 100644
--- a/src/render/renderer_tiger.c
+++ b/src/render/renderer_tiger.c
@@ -90,9 +90,8 @@ static void renderer_tiger_resize(struct camu_renderer *renderer, s32 *width, s3
 {
     struct camu_renderer_tiger *tr = (struct camu_renderer_tiger *)renderer;
     (void)tr;
-#ifdef CAMU_RENDERER_OPENGL
-    glViewport(0, 0, *width, *height);
-#endif
+    (void)width;
+    (void)height;
 }
 
 static bool renderer_tiger_create_renderer(struct camu_renderer *renderer, s32 *width, s32 *height,
@@ -123,7 +122,7 @@ static bool renderer_tiger_create_renderer(struct camu_renderer *renderer, s32 *
 
     if (!tr->load_loader(tr->priv)) return false;
 
-    renderer_tiger_resize(renderer, width, height);
+    tr->r.resize(&tr->r, width, height);
 
     clear_color[0] = ((global_color_palette.colors[0] >> 16) & 0xff) / 255.f;
     clear_color[1] = ((global_color_palette.colors[0] >> 8) & 0xff) / 255.f;
@@ -144,6 +143,10 @@ static bool renderer_tiger_create_renderer(struct camu_renderer *renderer, s32 *
 
     GLint pos = glGetAttribLocation(tr->program, "a_Position");
     glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void *)0);
+    if (stl_gl_check_error()) {
+        al_log_error("render_tiger", "glVertexAttribPointer returned error, use GLES context.");
+        al_assert(false);
+    }
     glEnableVertexAttribArray(pos);
     GLint texcoord = glGetAttribLocation(tr->program, "a_TexCoord");
     glVertexAttribPointer(texcoord, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void *)12);
@@ -208,7 +211,7 @@ static void set_uniform(struct camu_renderer_tiger *tr, const GLchar *name,
 }
 
 #ifdef CAMU_RENDERER_OPENGL
-static mat4x4 model;
+static mat4x4 model = { 0 };
 static GLuint texture0 = 0;
 #endif
 
@@ -217,6 +220,8 @@ static void renderer_tiger_render(struct camu_renderer *renderer, struct camu_sc
 #ifdef CAMU_RENDERER_OPENGL
     struct camu_renderer_tiger *tr = (struct camu_renderer_tiger *)renderer;
 
+    tr->make_current(tr->priv);
+
     glClear(GL_COLOR_BUFFER_BIT);
 
     glUseProgram(tr->program);
@@ -233,21 +238,26 @@ static void renderer_tiger_render(struct camu_renderer *renderer, struct camu_sc
         struct camu_screen_video *video = &al_array_last(scr->videos);
 
         GLuint texture_id;
-        camu_video_buffer_read(video->buf, &texture_id);
-        glBindTexture(GL_TEXTURE_2D, texture_id);
+        if (camu_video_buffer_read(video->buf, &texture_id)) {
+            glBindTexture(GL_TEXTURE_2D, texture_id);
 
-        mat4x4_ortho(model, 0.f, (f32)scr->width, (f32)scr->height, 0.f, -1.f, 1.f);
-        mat4x4_translate_in_place(model, (f32)video->view.x_offset, (f32)video->view.y_offset, 0.f);
-        mat4x4_scale_aniso(model, model, (f32)video->view.zoom, (f32)video->view.zoom, 1.f);
-        mat4x4_scale_aniso(model, model, (f32)video->view.width, (f32)video->view.height, 1.f);
-        set_uniform(tr, "g_ModelViewProjectionMatrix", TYPE_MAT4, model);
-        set_uniform(tr, "g_Texture0", TYPE_SAMPLER2D, &texture0);
+            mat4x4_identity(model);
+            mat4x4_ortho(model, 0.f, (f32)scr->width, (f32)scr->height, 0.f, -1.f, 1.f);
+            mat4x4_translate_in_place(model, (f32)video->view.x_offset, (f32)video->view.y_offset, 0.f);
+            mat4x4_scale_aniso(model, model, (f32)video->view.zoom, (f32)video->view.zoom, 1.f);
+            mat4x4_scale_aniso(model, model, (f32)video->view.width, (f32)video->view.height, 1.f);
+            set_uniform(tr, "g_ModelViewProjectionMatrix", TYPE_MAT4, model);
+            set_uniform(tr, "g_Texture0", TYPE_SAMPLER2D, &texture0);
 
-        glDrawArrays(GL_TRIANGLES, 0, 6);
+            glViewport(0, 0, scr->width, scr->height);
+            glDrawArrays(GL_TRIANGLES, 0, 6);
+        }
     }
 
     tr->swap_buffers(tr->priv);
 #endif
+
+    tr->release_current(tr->priv);
 }
 
 static void *renderer_tiger_get_device_ptr(struct camu_renderer *renderer, size_t length)
diff --git a/src/render/renderer_tiger.h b/src/render/renderer_tiger.h
index 2979d91..5891c20 100644
--- a/src/render/renderer_tiger.h
+++ b/src/render/renderer_tiger.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <skh/gl.h>
+#include <stl/gl.h>
 
 #include "renderer.h"