audio/flac

import audio
import audio.flac
import audio.synth
import compress

func main:
    src := synth.Tone(440.0, 0.1, 44100, synth.WaveSine)
    mut q := audio.ToBits(src, 16)
    q.bits = 16
    enc := flac.EncodeFLAC(q)
    println flac.IsFLAC(enc.data, enc.len), flac.IsFLAC(enc.data, 4)
    println audio.FormatName(audio.DetectFormat(enc.data, enc.len))

    blocks := flac.Blocks(enc.data, enc.len)
    println blocks.len(), blocks.get(0).kind == flac.BlockStreamInfo, blocks.get(0).last, blocks.get(0).size

    mut si := flac.StreamInfo {}
    println flac.ReadStreamInfo(enc.data, enc.len, si)
    println si.rate, si.channels, si.bits, si.total as int
    println si.md5.len, si.audio_offset
    println si.min_block, si.max_block

    mut fi := flac.FrameInfo {}
    head := flac.ReadFrameHeader(enc.data, enc.len, si.audio_offset, si, fi)
    println head > 0, fi.channels, fi.bits, fi.rate, fi.block_size

    mut ok := false
    back := flac.DecodeFLAC(enc.data, enc.len, ok)
    println ok, back.frames, back.channels, back.bits
    println audio.Sample(back, 100, 0) == audio.Sample(q, 100, 0)

    mut pok := false
    info := flac.ProbeFLAC(enc.data, enc.len, pok)
    println pok, info.rate, info.channels, info.bits, info.frames, info.lossless

    println flac.MaxChannels, flac.MaxBlockSize
    mut junk := compress.NewByteBuf()
    compress.BufPush(junk, 1)
    println flac.CRC8(junk.data, 0, 0), flac.CRC16Buf(junk, 0, 1) == flac.CRC16(junk.data, 0, 1)
    mut bad := false
    flac.DecodeFLAC(junk.data, junk.len, bad)
    println bad

    flac.FreeStreamInfo(si)
    blocks.free()
    compress.BufFree(enc)
    compress.BufFree(junk)
    audio.Free(src)
    audio.Free(q)
    audio.Free(back)
end

import audio
import audio.flac
import audio.synth
import compress
import filepath
import mem
import os

func main:
    src := synth.Tone(440.0, 0.2, 44100, synth.WaveSine)
    mut tone := audio.ToBits(src, 16)
    tone.bits = 16
    raw := tone.frames * tone.channels * 2
    println tone.frames, raw

    enc := flac.EncodeFLAC(tone)
    println compress.BufLen(enc) < raw / 2
    println flac.VerifyFLAC(enc.data, enc.len)
    println flac.DefaultBlock

    mut ok := false
    back := flac.DecodeFLAC(enc.data, enc.len, ok)
    mut worst := 0.0
    mut i := 0
    until i < tone.frames:
        d := audio.Sample(back, i, 0) - audio.Sample(tone, i, 0)
        if d > worst:
            worst = d
        end
        if 0.0 - d > worst:
            worst = 0.0 - d
        end
        i += 1
    end
    println worst

    each lv in [0, 5, 8]:
        one := flac.EncodeFLACLevel(tone, lv)
        println lv, compress.BufLen(one) > 42, flac.VerifyFLAC(one.data, one.len)
        compress.BufFree(one)
    end
    println compress.BufLen(flac.EncodeFLAC(audio.Clip {}))

    path := filepath.Join(os.TempDir(), "salam_flac_example.flac")
    defer mem.Free(path as void*)
    println flac.SaveFLAC(tone, path)
    mut dok := false
    disk := flac.OpenFLAC(path, dok)
    println dok, disk.frames == tone.frames, disk.bits
    println flac.SaveFLACLevel(tone, path, 8)
    mut iok := false
    info := flac.ProbeFileFLAC(path, iok)
    println iok, info.frames
    mut gone := false
    missing := filepath.Join(os.TempDir(), "salam_flac_none.flac")
    defer mem.Free(missing as void*)
    flac.OpenFLAC(missing, gone)
    println gone

    compress.BufFree(enc)
    audio.Free(src)
    audio.Free(tone)
    audio.Free(back)
    audio.Free(disk)
end