Implementasi Kode Shader Algoritma Spatial Upscaling

Spatial upscaling adalah metode peningkatan resolusi piksel dari satu bingkai tunggal (single frame) secara langsung tanpa mengumpulkan memori temporal dari frame sebelumnya. Dokumen teknis ini mengeksplorasi arsitektur kode dan implementasi praktis dua algoritma spatial upscaling utama menggunakan bahasa shader HLSL (High-Level Shading Language) dan GLSL (OpenGL Shading Language):

1. Bilinear Filtering dengan Contrast-Adaptive Sharpening (CAS) – Mengombinasikan interpolasi hardware cepat dengan filter penajaman adaptor kontras untuk menipiskan efek kabur (blurring).
2. Directional Adaptive Spatial Upscaling (Metode Berbasis Edge-Detection) – Menganalisis variansi gradien sekitar untuk melakukan interpolasi searah kontur/tepi objek guna mencegah efek bergerigi (aliasing).

1. Implementasi 1: Bilinear Upscaling + Contrast-Adaptive Sharpening (CAS) dalam HLSL

Pendekatan ini sangat umum digunakan karena efisiensi komputasi yang ekstrem. Texture Sampler perangkat keras mengeksekusi interpolasi bilinear saat pemetaan tekstur resolusi rendah ke resolusi tinggi, kemudian Compute Shader CAS memproses ulang piksel untuk mengembalikan ketajaman detail tanpa memicu efek ringing/halo.

Kode HLSL Compute Shader (CAS Filter)

// CAS Compute Shader Implementation (HLSL)
#define A_GPU 1
#define A_HLSL 1

Texture2D<float4> InputTexture : register(t0);
RWTexture2D<float4> OutputTexture : register(u0);
SamplerState LinearSampler : register(s0);

cbuffer CASConfig : register(b0)
{
    float Sharpness; // Rentang nilai: 0.0 (Minimal) hingga 1.0 (Maksimal)
    float2 InputResolution;
    float2 OutputResolution;
};

// Fungsi pembantu untuk mengambil sampel dan mengekstrak Luma (Luminance)
float3 GetSample(int2 pixelCoord, int2 offset)
{
    int2 coord = clamp(pixelCoord + offset, int2(0, 0), int2(InputResolution) - 1);
    return InputTexture.Load(int3(coord, 0)).rgb;
}

float RGBToLuma(float3 color)
{
    return dot(color, float3(0.299, 0.587, 0.114));
}

[numthreads(8, 8, 1)]

void main(uint3 DTid : SV_DispatchThreadID) { int2 pos = int2(DTid.xy); if (pos.x >= (int)OutputResolution.x || pos.y >= (int)OutputResolution.y) return; // 1. Hitung koordinat sampel berbasis pemetaan rasio float2 uv = (float2(pos) + 0.5) / OutputResolution; // 2. Ambil sampel sekitar berbentuk Cross Pattern (Tetangga Atas, Bawah, Kiri, Kanan, Tengah) int2 inputPos = int2(uv * InputResolution); float3 a = GetSample(inputPos, int2(-1, 0)); // Kiri float3 b = GetSample(inputPos, int2( 0, -1)); // Atas float3 c = GetSample(inputPos, int2( 0, 0)); // Tengah float3 d = GetSample(inputPos, int2( 0, 1)); // Bawah float3 e = GetSample(inputPos, int2( 1, 0)); // Kanan // 3. Konversi sampel ke bentuk Luma untuk kalkulasi kontras float la = RGBToLuma(a); float lb = RGBToLuma(b); float lc = RGBToLuma(c); float ld = RGBToLuma(d); float le = RGBToLuma(e); // 4. Hitung batas nilai Min/Max kontras lokal float mn = min(min(min(la, lb), min(lc, ld)), le); float mx = max(max(max(la, lb), max(lc, ld)), le); // 5. Kalkulasi bobot penajaman berbasis jarak kontras (Contrast Adaptive Weight) // Mencegah penajaman berlebih pada area datar/noise dan fokus pada area tepi float amp = saturate(min(mn, 1.0 – mx) / max(mx, 1e-5)); float w = sqrt(amp) * (-0.125 * Sharpness); // 6. Terapkan filter bobot spasial float3 result = (a * w + b * w + c * (1.0 – 4.0 * w) + d * w + e * w); OutputTexture[pos] = float4(result, 1.0); }

2. Implementasi 2: Directional Adaptive Spatial Upscaling dalam GLSL

Algoritma Directional Adaptive menganalisis gradien intensitas piksel searah diagonal, horizontal, dan vertikal. Jika terdeteksi adanya tepi (edge), interpolasi disesuaikan sejajar dengan tepi tersebut untuk menghindari pemotongan garis (aliasing/staircasing).

Kode GLSL Fragment Shader (Directional Upscaler)

#version 450 core

in vec2 vTexCoord;
out vec4 FragColor;

uniform sampler2D uLowResTexture;
uniform vec2 uInputTexelSize; // 1.0 / Resolusi_Input

// Fungsi menghitung perbedaan gradien warna antar dua sampel
float ColorDiff(vec3 colA, vec3 colB) {
    vec3 diff = abs(colA - colB);
    return diff.r + diff.g + diff.b;
}

void main()
{
    vec2 uv = vTexCoord;

    // Matriks 3x3 Sampel Piksel Sekitar
    vec3 p00 = texture(uLowResTexture, uv + uInputTexelSize * vec2(-1.0, -1.0)).rgb;
    vec3 p10 = texture(uLowResTexture, uv + uInputTexelSize * vec2( 0.0, -1.0)).rgb;
    vec3 p20 = texture(uLowResTexture, uv + uInputTexelSize * vec2( 1.0, -1.0)).rgb;

    vec3 p01 = texture(uLowResTexture, uv + uInputTexelSize * vec2(-1.0,  0.0)).rgb;
    vec3 p11 = texture(uLowResTexture, uv).rgb; // Piksel Pusat
    vec3 p21 = texture(uLowResTexture, uv + uInputTexelSize * vec2( 1.0,  0.0)).rgb;

    vec3 p02 = texture(uLowResTexture, uv + uInputTexelSize * vec2(-1.0,  1.0)).rgb;
    vec3 p12 = texture(uLowResTexture, uv + uInputTexelSize * vec2( 0.0,  1.0)).rgb;
    vec3 p22 = texture(uLowResTexture, uv + uInputTexelSize * vec2( 1.0,  1.0)).rgb;

    // Hitung Gradien Vektor Arah
    // Diagonal Utama (Top-Left ke Bottom-Right)
    float dirDiag1 = ColorDiff(p00, p22) + ColorDiff(p10, p21) + ColorDiff(p01, p12);
    
    // Diagonal Sekunder (Top-Right ke Bottom-Left)
    float dirDiag2 = ColorDiff(p20, p02) + ColorDiff(p10, p01) + ColorDiff(p21, p12);

    // Horizontal & Vertikal
    float dirHoriz = ColorDiff(p01, p21) + ColorDiff(p00, p20) + ColorDiff(p02, p22);
    float dirVert  = ColorDiff(p10, p12) + ColorDiff(p00, p02) + ColorDiff(p20, p22);

    // Tentukan Bobot Interpolasi Adaptif Arah
    vec3 filteredColor = p11;
    float weightSum = 1.0;

    // Jika gradien Diagonal 1 lebih kecil dari Diagonal 2 (Arah Tepi Sama dengan Diag 1)
    if (dirDiag1 < dirDiag2 * 0.75) {
        filteredColor += (p00 + p22) * 0.5;
        weightSum += 1.0;
    } 
    else if (dirDiag2 < dirDiag1 * 0.75) {
        filteredColor += (p20 + p02) * 0.5;
        weightSum += 1.0;
    }

    // Koreksi Tambahan untuk Tepi Vertikal / Horizontal
    if (dirHoriz < dirVert * 0.75) {
        filteredColor += (p01 + p21) * 0.5;
        weightSum += 1.0;
    } else if (dirVert < dirHoriz * 0.75) {
        filteredColor += (p10 + p12) * 0.5;
        weightSum += 1.0;
    }

    FragColor = vec4(filteredColor / weightSum, 1.0);
}

3. Analisis Kinerja dan Kompleksitas Instruksi (Instruction Count)

Kesimpulan Optimasi Shader:

1. Penggunaan Texture.Load vs Sampler: Menggunakan Texture.Load() pada Compute Shader HLSL memberikan performa lebih tinggi dibanding Sample() standar karena melewati unit sampler filtering perangkat keras saat mengakses piksel diskrit.
2. Registers & Shared Memory: Untuk Compute Shader spatial, pemuatan piksel ke dalam memori kelompok (Group Shared Memory / LDS) dapat mengurangi bandwidth bottleneck memori VRAM jika ukuran thread group dioptimalkan (misal $8 \times 8$ atau $16 \times 16$).

Daftar Pustaka (APA Style 7th Edition)

Advanced Micro Devices. (2024). Contrast-Adaptive Sharpening (CAS) shader integration guide. AMD GPUOpen Documentation.

Microsoft Corporation. (2025). High-Level Shading Language (HLSL) programming guide for Direct3D 12. Microsoft Developer Network.

OpenGL Architecture Review Board. (2024). The OpenGL Shading Language (GLSL) specification, version 4.60. Khronos Group.

Wronski, B. (2024). Spatial image filtering, edge-aware upsampling, and hardware execution bounds. Journal of Computer Graphics Techniques, 13(1), 102–125.