blurhash-odin/example/main.odin

package main

import "core:fmt"
import "core:image"
import "core:image/qoi"
import "core:image/png"
import "core:slice"
import "core:mem"
import "core:os/os2"

import blurhash "../"

decode_example :: proc() {
    if len(os2.args) < 3 {
        fmt.eprintln("Please input the blurhash as an arg")
        return
    }

    track: mem.Tracking_Allocator
    mem.tracking_allocator_init(&track, context.allocator)
    alloc := mem.tracking_allocator(&track)

    width := 400
    height := 240
    pixels, err := blurhash.decode(os2.args[2], width, height, 1.2, alloc)
    if err != nil {
        fmt.eprintln(err)
        return
    }

    img, ok := image.pixels_to_image(slice.reinterpret([]image.RGB_Pixel, pixels), width, height)
    if !ok {
        fmt.eprintln("Couldn't create an image")
        return
    }

    save_err := qoi.save_to_file("yup.qoi", &img)
    if save_err != nil {
        fmt.eprintln(save_err)
        return
    }

    delete(pixels, alloc)

    for _, leak in track.allocation_map {
        fmt.printfln("%v leaked %m", leak.location, leak.size)
    }
    for bad_free in track.bad_free_array {
        fmt.printfln("%v allocation %p was freed badly", bad_free.location, bad_free.memory)
    }
    fmt.printfln("Peak Mem: %m", track.peak_memory_allocated)
    fmt.printfln("Total Mem: %m", track.total_memory_allocated)
    fmt.printfln("Current Mem: %m", track.current_memory_allocated)
    fmt.printfln("Total Allocs: %v, Total Frees: %v:", track.total_allocation_count, track.total_free_count)
    fmt.printfln("Total Mem Free'd: %m", track.total_memory_freed)
}

encode_example :: proc() {
    if len(os2.args) < 3 {
        fmt.eprintln("Please provide a path to a png")
        return
    }

    img, err := image.load_from_file(os2.args[2])
    if err != nil {
        fmt.eprintln(err)
        return
    }

    track: mem.Tracking_Allocator
    mem.tracking_allocator_init(&track, context.allocator)
    alloc := mem.tracking_allocator(&track)

    bhash, hash_err := blurhash.encode(img.pixels.buf[:], 5, 4, img.width, img.height, img.width*img.channels, alloc)
    if hash_err != nil {
        fmt.eprintln(hash_err)
        return
    }

    fmt.println(bhash)
    delete(bhash, alloc)

    for _, leak in track.allocation_map {
        fmt.printfln("%v leaked %m", leak.location, leak.size)
    }
    for bad_free in track.bad_free_array {
        fmt.printfln("%v allocation %p was freed badly", bad_free.location, bad_free.memory)
    }
    fmt.printfln("Peak Mem: %m", track.peak_memory_allocated)
    fmt.printfln("Total Mem: %m", track.total_memory_allocated)
    fmt.printfln("Current Mem: %m", track.current_memory_allocated)
    fmt.printfln("Total Allocs: %v, Total Frees: %v:", track.total_allocation_count, track.total_free_count)
    fmt.printfln("Total Mem Free'd: %m", track.total_memory_freed)
}

main :: proc() {
    if len(os2.args) < 2 {
        fmt.eprintln("Usage: program \"decode|encode\" <arg>")
        return
    }

    if os2.args[1] == "decode" {
        decode_example()
    } else if os2.args[1] == "encode" {
        encode_example()
    } else {
        fmt.eprintln("Unknown command")
    }
}