Illusion/flac-odin
1
0
Fork 0
mirror of https://github.com/IllusionMan1212/flac-odin.git synced 2026-10-24 02:12:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove the in-memory API

Browse Source
This commit is contained in:
Illusion
2024-09-24 06:36:33 +02:00
parent ec70efae83
commit dfaca585fd
6 changed files with 150 additions and 1150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TODO.md
+2
View File
@@ -34,6 +34,8 @@ Things:-
[ ] Speed optimizations
[ ] Seeking
[ ] Fuzzing to test the stability of the code
[ ] Check if the use-after-free bug happens on Windows, and if so, if the address sanitizer will show us the full stacktrace
instead of skipping some procs.
[ ] Encoder (low priority for now)
examples/buffered/main.odin → example/main.odin
+2 -2
View File
@@ -36,7 +36,7 @@ main :: proc() {
allocator := virtual.arena_allocator(&arena)
start := time.now()
flac_data, reader, err := flac.load_from_file_buffered(os.args[1], allocator)
flac_data, reader, err := flac.load_from_file(os.args[1], allocator)
if err != nil {
fmt.println("Error while reading flac file:", err)
os.exit(1)
@@ -57,7 +57,7 @@ main :: proc() {
md5_ctx: md5.Context
md5.init(&md5_ctx)
for {
frame, err := flac.read_next_frame(reader, flac_data, allocator)
frame, err := flac.read_next_frame(reader, flac_data)
if err != nil {
if err == .EOF {
break
examples/in_memory/main.odin
-81
View File
@@ -1,81 +0,0 @@
package main
import "core:os"
import "core:fmt"
import "core:mem"
import "core:mem/virtual"
import "core:time"
import "shared:alsa"
import "shared:flac"
DEVICE :: "default"
main :: proc() {
if len(os.args) < 2 {
fmt.eprintln("Please provide a path to a flac file.")
os.exit(1)
}
defer delete(os.args)
handle: ^alsa.pcm_t
arena: virtual.Arena
arena_err := virtual.arena_init_growing(&arena, mem.Megabyte * 8)
if arena_err != nil {
fmt.eprintln("Failed to alloc memory")
return
}
allocator := virtual.arena_allocator(&arena)
alsa_err := alsa.pcm_open(&handle, DEVICE, .PLAYBACK, .BLOCK)
if alsa_err < 0 {
fmt.eprintln("Failed to initialize audio device: ", alsa.strerror(alsa_err))
os.exit(1)
}
defer alsa.pcm_close(handle)
start := time.now()
flac_data, err := flac.load_from_file(os.args[1], allocator = allocator)
if err != nil {
fmt.eprintln(err)
if err == .MD5_Mismatch {
fmt.printfln("Expected: %v, got: %v", flac_data.metadata.expected_md5, flac_data.metadata.calculated_md5)
}
os.exit(1)
}
defer flac.destroy(flac_data, allocator = allocator)
end := time.now()
fmt.println(flac_data.metadata)
alsa_err = alsa.pcm_set_params(handle, .S16_LE, .RW_INTERLEAVED, u32(flac_data.metadata.channels), flac_data.metadata.sample_rate, 1, 500000)
if alsa_err < 0 {
fmt.eprintln("Playback open error:", alsa.strerror(alsa_err))
os.exit(1)
}
converted_samples := make([]i16, len(flac_data.samples))
defer delete(converted_samples)
for sample, i in flac_data.samples {
new_sample := sample & 0xFF
new_sample |= ((sample >> 8) & 0xFF) << 8
converted_samples[i] = i16(new_sample)
}
frames := alsa.pcm_writei(handle, raw_data(converted_samples), u64(len(flac_data.samples)) / u64(flac_data.metadata.channels))
if frames < 0 {
fmt.eprintln("Error writing to PCM device:", alsa.strerror(auto_cast frames))
return
}
fmt.printfln("Played %d frames", frames)
alsa_err = alsa.pcm_drain(handle)
if alsa_err < 0 {
fmt.eprintln("pcm_drain failed with:", alsa.strerror(alsa_err))
}
elapsed := time.diff(start, end)
fmt.println("Decoding took", elapsed)
}
flac.odin
+6 -338
View File
@@ -33,15 +33,11 @@ FlacError :: enum {
/*
Option:
`.skip_md5_check`
Skips checking the MD5 hash of the decoded sample data.
Offers a slight performance increase but will not error if the data is incorrect.
`.only_return_metadata`
Returns all metadata of a FLAC stream without decoding the audio data.
*/
Option :: enum u8 {
skip_md5_check,
only_return_metadata,
}
@@ -73,8 +69,7 @@ PictureType :: enum u32 {
Flac :: struct {
metadata: FlacMetadata,
// When using the in-memory API this will hold all the decoded samples of the FLAC stream.
// When using the buffered API this will hold the samples up to the currently decoded frame. If all frames have
// This holds the samples up to the currently decoded frame. If all frames have
// been decoded then this will hold all the decoded samples.
samples: [dynamic]i32,
}
@@ -399,255 +394,6 @@ decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32
return subframe_samples, nil
}
@(private)
decode_frame :: proc(
r: ^Reader,
flac: ^Flac,
md5_ctx: ^md5.Context,
options: Options,
) -> (
err: Error,
) #no_bounds_check {
//
// Frame Header
//
tee_r: io.Tee_Reader
crc_buffer: bytes.Buffer
bytes.buffer_init_allocator(&crc_buffer, 0, 128)
defer bytes.buffer_destroy(&crc_buffer)
crc := bytes.buffer_to_stream(&crc_buffer)
r := &Reader{
r = io.tee_reader_init(&tee_r, r, crc),
buf = r.buf,
x = r.x,
n = r.n,
}
data := read_data(r, u16be) or_return
sync_code := data >> 2
blocking_strategy := BlockingStrategy(data & 1)
data = read_data(r, u16be) or_return
block_size := data >> 12
sample_rate := SampleRate((data >> 8) & 0xF)
channel_assignment := ChannelAssignment((data >> 4) & 0xF)
sample_size := SampleSize((data >> 1) & 7)
coded_num := decode_extended_utf8(r) or_return
if blocking_strategy == .VARIABLE {
// Sample number of first sample
// MUST NOT be larger than 36 bits unencoded or 7 bytes encoded.
// MUST be equal to the number of samples preceding the current frame. Otherwise seeking is not possible.
// TODO: also write a check for the number of samples so we'll probably keep track of how many samples we decoded
// maybe the number of decoded samples can be inferred by the number of frames ?? or just use the length of
// the decoded_samples slice.
if coded_num > 0x1000000000 {
// TODO: Sample number can't be bigger than 36 bits
}
} else {
// Frame number
// MUST NOT be larger than 31 bits unencoded or 6 bytes encoded.
// MUST be equal to the number of frames preceding the current frame. Otherwise seeking is not possible.
// TODO: also write a check for the number of frames so we'll probably keep track of how many frames we decoded.
if coded_num > 0x80000000 {
// TODO: Frame number cannot be bigger than 31 bits
}
}
actual_block_size: u16be
switch block_size {
case 1:
actual_block_size = 192
case 2..=5:
actual_block_size = 576 * auto_cast (pow2(block_size - 2))
case 6:
actual_block_size = auto_cast (read_bits(r, 8) or_return) + 1
case 7:
actual_block_size = (read_data(r, u16be) or_return) + 1
case 8..=15:
actual_block_size = 256 * auto_cast (pow2(block_size - 8))
case:
return .Invalid_Block_Size
}
//if actual_block_size < 15 && !last_frame {
// TODO: block sizes less than 16 are only valid for the last frame and MUST NOT be used for any other frame.
//}
actual_sample_rate_in_Hz: u32
switch sample_rate {
case .USE_STREAMINFO:
actual_sample_rate_in_Hz = flac.metadata.sample_rate
case ._88_2kHz:
actual_sample_rate_in_Hz = 88200
case ._176_4kHz:
actual_sample_rate_in_Hz = 176400
case ._192kHz:
actual_sample_rate_in_Hz = 192000
case ._8kHz:
actual_sample_rate_in_Hz = 8000
case ._16kHz:
actual_sample_rate_in_Hz = 16000
case ._22_05kHz:
actual_sample_rate_in_Hz = 22005
case ._24kHz:
actual_sample_rate_in_Hz = 24000
case ._32kHz:
actual_sample_rate_in_Hz = 32000
case ._44_1kHz:
actual_sample_rate_in_Hz = 44100
case ._48kHz:
actual_sample_rate_in_Hz = 48000
case ._96kHz:
actual_sample_rate_in_Hz = 96000
case .USE_8_BITS_IN_kHz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_bits(r, 8) or_return) * 1000
case .USE_16_BITS_IN_Hz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_data(r, u16be) or_return)
case .USE_16_BITS_IN_TENS_OF_Hz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_data(r, u16be) or_return) * 10
case .INVALID: fallthrough
case:
return .Invalid_Sample_Rate
}
// TODO: sample rate MUST NOT be 0 if the subframe contains audio.
// a sample rate of 0 MAY be used when non-audio is represented.
crc8_bytes := bytes.buffer_to_bytes(&crc_buffer)
frame_header_crc := u8(read_bits(r, 8) or_return)
calculated_header_crc := calculate_crc8(crc8_bytes)
if frame_header_crc != calculated_header_crc {
fmt.printfln("Expected frame header CRC: 0x%X, got: 0x%X", frame_header_crc, calculated_header_crc)
return .CRC_Mismatch
}
//
// Subframes
//
bps: u8
switch sample_size {
case .USE_STREAMINFO:
bps = flac.metadata.bits_per_sample
case ._8BPS:
bps = 8
case ._12BPS:
bps = 12
case ._16BPS:
bps = 16
case ._20BPS:
bps = 20
case ._24BPS:
bps = 24
case ._32BPS:
bps = 32
}
if bps != flac.metadata.bits_per_sample {
return .Bits_Per_Second_Mismatch
}
frame_channels := flac.metadata.channels
switch channel_assignment {
case .MONO:
frame_channels = 1
case ._3CHANNELS:
frame_channels = 3
case ._4CHANNELS:
frame_channels = 4
case ._5CHANNELS:
frame_channels = 5
case ._6CHANNELS:
frame_channels = 6
case ._7CHANNELS:
frame_channels = 7
case ._8CHANNELS:
frame_channels = 8
case ._2CHANNELS: fallthrough
case .STEREO_LEFT_SIDE: fallthrough
case .STEREO_SIDE_RIGHT: fallthrough
case .STEREO_MID_SIDE:
frame_channels = 2
}
if frame_channels != flac.metadata.channels {
// TODO: warning or error?
// we have a faulty file that says it has 5 channels but subframes all say they got 1
// we also have an two uncommon files with increasing and decreasing number of channels
// uncommon are supposed to be unusual but still valid FLAC files. why is that first one faulty then???
// so many questions...
}
subframes := make([][]i32, frame_channels)
defer delete(subframes)
for i in 0..<frame_channels {
frame_bps := bps
// For side channels we increase the bps by 1
// Left, mid and right channels don't need an extra bit.
// ref: https://github.com/ietf-wg-cellar/flac-specification/blob/master/rfc_backmatter.md#first-audio-frame
if (channel_assignment == .STEREO_SIDE_RIGHT && i == 0) ||
((channel_assignment == .STEREO_LEFT_SIDE || channel_assignment == .STEREO_MID_SIDE) && i == 1) {
frame_bps += 1
}
subframes[i] = decode_subframe(r, frame_bps, auto_cast actual_block_size) or_return
}
align_to_byte(r)
correlate(subframes, channel_assignment)
// Write the samples interleaved.
for i in 0..<len(subframes[0]) {
for subframe, sf in subframes {
sample := subframe[i]
append(&flac.samples, sample)
if .skip_md5_check not_in options {
switch bps {
case 1..=8:
md5.update(md5_ctx, {u8(sample)})
case 9..=16:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte})
case 17..=24:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
third_byte := u8((sample >> 16) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte, third_byte})
case 25..=32:
data := transmute([4]u8)sample
md5.update(md5_ctx, data[:])
case:
fmt.println("INVALID BPS")
os.exit(1)
}
}
}
}
for subframe in subframes {
delete(subframe)
}
//
// Frame Footer
//
crc16_bytes := bytes.buffer_to_bytes(&crc_buffer)
frame_crc := u16(read_data(r, u16be) or_return)
calculated_frame_crc := calculate_crc16(crc16_bytes)
if frame_crc != calculated_frame_crc {
fmt.eprintfln("Expected frame CRC 0x%X, got 0x%X", frame_crc, calculated_frame_crc)
return .CRC_Mismatch
}
return nil
}
@(private)
correlate :: proc(subframes: [][]i32, channel_assignment: ChannelAssignment) {
// Undo Stereo Decorrelation
@@ -684,7 +430,7 @@ correlate :: proc(subframes: [][]i32, channel_assignment: ChannelAssignment) {
}
@(private)
read_metadata :: proc(r: ^Reader, buffered := false, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
read_metadata :: proc(r: ^Reader, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
header := read_data(r, FlacHeader) or_return
if header.magic != FLAC_MAGIC {
return nil, .Invalid_Signature
@@ -731,25 +477,15 @@ read_metadata :: proc(r: ^Reader, buffered := false, allocator := context.alloca
case .STREAMINFO:
// Do nothing, we already parse the mandatory streaminfo metadata
case .PADDING:
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case .APPLICATION:
//app_id := read_slice(&r, 4) or_return
//fmt.println("Found application with ID:", string(app_id))
//fmt.printfln("Skipping %d bytes of application metadata block", metadata_block_header.length)
// TODO: handle the application data
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case .SEEKTABLE:
seekpoints := metadata_block_header.length / 18
//fmt.printfln("we have %d seekpoints", seekpoints)
@@ -833,22 +569,12 @@ read_metadata :: proc(r: ^Reader, buffered := false, allocator := context.alloca
append(&pictures, picture)
case .INVALID:
fmt.eprintln("Invalid block type")
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case:
fmt.printfln("Skipping %d bytes of Unknown metadata block", metadata_block_header.length)
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
}
}
@@ -1140,67 +866,10 @@ md5sum :: proc(md5_ctx: ^md5.Context, flac: ^Flac) -> Error {
return nil
}
// `load_from_bytes` takes a byte slice and initializes a bitreader for it.
// The data is expected to be a full flac stream.
load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
context.allocator = allocator
byte_r: bytes.Reader
bytes.reader_init(&byte_r, data)
r := Reader{bytes.reader_to_stream(&byte_r), 0, 0, 0}
flac = read_metadata(&r) or_return
if .only_return_metadata in options {
return flac, nil
}
md5_ctx: md5.Context
md5.init(&md5_ctx)
defer md5.reset(&md5_ctx)
for {
err = decode_frame(&r, flac, &md5_ctx, options)
if err != nil {
if err == .EOF {
break
} else {
return flac, err
}
}
}
if err != .EOF {
return flac, err
}
if .skip_md5_check not_in options {
md5sum(&md5_ctx, flac) or_return
}
return flac, nil
}
// `load_from_file` reads the entire file to memory and operates on the returned byte slice.
// Only use this with small files.
load_from_file :: proc(filename: string, options := Options{}, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
context.allocator = allocator
data, ok := os.read_entire_file(filename)
defer delete(data)
if ok {
return load_from_bytes(data, options)
} else {
return nil, .Unable_To_Read_File
}
}
// `load_from_file_buffered` initializes a buffered reader for the file and reads all the metadata blocks.
// `load_from_file` initializes a buffered reader for the file and reads all the metadata blocks.
// Calls to `read_next_frame()` MUST be made to decode the audio data.
// This is the recommended way to read most FLAC files as it has a minimal memory overhead.
load_from_file_buffered :: proc(filename: string, allocator := context.allocator) -> (flac: ^Flac, r: ^Reader, err: Error) {
load_from_file :: proc(filename: string, allocator := context.allocator) -> (flac: ^Flac, r: ^Reader, err: Error) {
context.allocator = allocator
file, open_err := os.open(filename)
@@ -1218,14 +887,13 @@ load_from_file_buffered :: proc(filename: string, allocator := context.allocator
r.x = 0
r.n = 0
flac = read_metadata(r, true) or_return
flac = read_metadata(r) or_return
return flac, r, nil
}
/* `destroy` cleans up and frees the memory allocated by all 3 loading functions.
The returned reader from `load_from_file_buffered` MUST be passed to `destroy` in order to close the file handle.
`load_from_file` and `load_from_bytes` may pass nil as the reader.
The returned reader from `load_from_file` MUST be passed to `destroy` in order to close the file handle.
---
The allocator that was used when loading the flac file MUST be passed to `destroy` in order to properly free
the memory, otherwise a bad free may occur and crash the program.
tests/flac_in_memory_test.odin
-589
View File
@@ -1,589 +0,0 @@
package flac_test
import "core:fmt"
import "core:os"
import "core:testing"
import "shared:flac"
@(test)
test_blocksize_4096 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/01 - blocksize 4096.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 4096 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_4608 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/02 - blocksize 4608.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 4608 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_16 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/03 - blocksize 16.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 16 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_192 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/04 - blocksize 192.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 192 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_254 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/05 - blocksize 254.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 254 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_512 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/06 - blocksize 512.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 512 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_725 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/07 - blocksize 725.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 725 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_1000 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/08 - blocksize 1000.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 1000 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_1937 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/09 - blocksize 1937.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 1937 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_blocksize_2304 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/10 - blocksize 2304.flac")
testing.expect(t, err == nil, fmt.tprint("Blocksize 2304 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_partition_order_8 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/11 - partition order 8.flac")
testing.expect(t, err == nil, fmt.tprint("Partition order 8 Failed with error:", err))
flac.destroy(data)
}
@(test)
test_qlp_precision_15_bit :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/12 - qlp precision 15 bit.flac")
testing.expect(t, err == nil, fmt.tprint("qlp precision 15 bit Failed with error:", err))
flac.destroy(data)
}
@(test)
test_qlp_precision_2_bit :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/13 - qlp precision 2 bit.flac")
testing.expect(t, err == nil, fmt.tprint("qlp precision 2 bit Failed with error:", err))
flac.destroy(data)
}
@(test)
wasted_bits :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/14 - wasted bits.flac")
testing.expect(t, err == nil, fmt.tprint("Wasted bits Failed with error:", err))
flac.destroy(data)
}
@(test)
only_verbatim_subframes :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/15 - only verbatim subframes.flac")
testing.expect(t, err == nil, fmt.tprint("Only verbatim subframes Failed with error:", err))
flac.destroy(data)
}
@(test)
partition_order_8_containing_escaped_partitions :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/16 - partition order 8 containing escaped partitions.flac")
testing.expect(
t,
err == nil,
fmt.tprint("Partition order 8 containing escaped partitions Failed with error:", err),
)
flac.destroy(data)
}
@(test)
all_fixed_orders :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/17 - all fixed orders.flac")
testing.expect(t, err == nil, fmt.tprint("All fixed orders Failed with error:", err))
flac.destroy(data)
}
@(test)
precision_search :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/18 - precision search.flac")
testing.expect(t, err == nil, fmt.tprint("Precision search Failed with error:", err))
flac.destroy(data)
}
@(test)
samplerate_35467Hz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/19 - samplerate 35467Hz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 35467Hz Failed with error:", err))
flac.destroy(data)
}
@(test)
samplerate_39kHz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/20 - samplerate 39kHz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 39kHz Failed with error:", err))
flac.destroy(data)
}
@(test)
samplerate_22050Hz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/21 - samplerate 22050Hz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 22050Hz Failed with error:", err))
flac.destroy(data)
}
@(test)
_12_bit_per_sample :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/22 - 12 bit per sample.flac")
testing.expect(t, err == nil, fmt.tprint("12 bit per sample Failed with error:", err))
flac.destroy(data)
}
@(test)
_8_bit_per_sample :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/23 - 8 bit per sample.flac")
testing.expect(t, err == nil, fmt.tprint("8 bit per sample Failed with error:", err))
flac.destroy(data)
}
@(test)
variable_blocksize_file_created_with_flake_revision_264 :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/24 - variable blocksize file created with flake revision 264.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("Variable blocksize file created with flake revision 264 Failed with error:", err),
)
flac.destroy(data)
}
@(test)
variable_blocksize_file_created_with_flake_revision_264_modified_to_create_smaller_blocks :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/25 - variable blocksize file created with flake revision 264, modified to create smaller blocks.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint(
"Variable blocksize file created with flake revision 264 modified to create smaller blocks Failed with error:",
err,
),
)
flac.destroy(data)
}
@(test)
variable_blocksize_file_created_with_CUETools_Flake_2_1_6 :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/26 - variable blocksize file created with CUETools.Flake 2.1.6.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("Variable blocksize file created with CUETools.Flake 2.1.6 Failed with error:", err),
)
flac.destroy(data)
}
@(test)
old_format_variable_blocksize_file_created_with_Flake_0_11 :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/27 - old format variable blocksize file created with Flake 0.11.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("Old format variable blocksize file created with Flake 0.11 Failed with error:", err),
)
flac.destroy(data)
}
@(test)
high_resolution_audio_default_settings :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/28 - high resolution audio, default settings.flac")
testing.expect(t, err == nil, fmt.tprint("High resolution audio, default settings Failed with error:", err))
flac.destroy(data)
}
@(test)
high_resolution_audio_blocksize_16384 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/29 - high resolution audio, blocksize 16384.flac")
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 16384 Failed with error:", err))
flac.destroy(data)
}
@(test)
high_resolution_audio_blocksize_13456 :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/30 - high resolution audio, blocksize 13456.flac")
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 13456 Failed with error:", err))
flac.destroy(data)
}
@(test)
high_resolution_audio_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/31 - high resolution audio, using only 32nd order predictors.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("High resolution audio, using only 32nd order predictors Failed with error:", err),
)
flac.destroy(data)
}
@(test)
high_resolution_audio_partition_order_8_containing_escaped_partitions :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/32 - high resolution audio, partition order 8 containing escaped partitions.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("High resolution audio, partition order 8 containing escaped partitions Failed with error:", err),
)
flac.destroy(data)
}
@(test)
samplerate_192kHz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/33 - samplerate 192kHz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 192kHz Failed with error:", err))
flac.destroy(data)
}
@(test)
samplerate_192kHz_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/34 - samplerate 192kHz, using only 32nd order predictors.flac")
testing.expect(
t,
err == nil,
fmt.tprint("Samplerate 192kHz, using only 32nd order predictors Failed with error:", err),
)
flac.destroy(data)
}
@(test)
samplerate_134560Hz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/35 - samplerate 134560Hz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 134560Hz Failed with error:", err))
flac.destroy(data)
}
@(test)
samplerate_384kHz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/36 - samplerate 384kHz.flac")
testing.expect(t, err == nil, fmt.tprint("Samplerate 384kHz Failed with error:", err))
flac.destroy(data)
}
@(test)
_20_bit_per_sample :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/37 - 20 bit per sample.flac")
testing.expect(t, err == nil, fmt.tprint("20 bit per sample Failed with error:", err))
flac.destroy(data)
}
@(test)
_3_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/38 - 3 channels (3.0).flac")
testing.expect(t, err == nil, fmt.tprint("3 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_4_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/39 - 4 channels (4.0).flac")
testing.expect(t, err == nil, fmt.tprint("4 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_5_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/40 - 5 channels (5.0).flac")
testing.expect(t, err == nil, fmt.tprint("5 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_6_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/41 - 6 channels (5.1).flac")
testing.expect(t, err == nil, fmt.tprint("6 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_7_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/42 - 7 channels (6.1).flac")
testing.expect(t, err == nil, fmt.tprint("7 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_8_channels :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/43 - 8 channels (7.1).flac")
testing.expect(t, err == nil, fmt.tprint("8 channels Failed with error:", err))
flac.destroy(data)
}
@(test)
_8_channel_surround_192kHz_24_bit_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, err := flac.load_from_file(
"flac-test-files/subset/44 - 8-channel surround, 192kHz, 24 bit, using only 32nd order predictors.flac",
)
testing.expect(
t,
err == nil,
fmt.tprint("8-channel surround 192kHz 24 bit using only 32nd order predictors Failed with error:", err),
)
flac.destroy(data)
}
@(test)
no_total_number_of_samples :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/45 - no total number of samples set.flac")
testing.expect(t, err == nil, fmt.tprint("No total number of samples Failed with error:", err))
flac.destroy(data)
}
@(test)
no_min_max_framesize :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/46 - no min-max framesize set.flac")
testing.expect(t, err == nil, fmt.tprint("No min-max framesize Failed with error:", err))
flac.destroy(data)
}
@(test)
only_streaminfo :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/47 - only STREAMINFO.flac")
testing.expect(t, err == nil, fmt.tprint("Only STREAMINFO Failed with error:", err))
flac.destroy(data)
}
@(test)
extreme_large_seektable :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/48 - Extremely large SEEKTABLE.flac")
testing.expect(t, err == nil, fmt.tprint("Extremely large SEEKTABLE Failed with error:", err))
flac.destroy(data)
}
@(test)
extreme_large_padding :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/49 - Extremely large PADDING.flac")
testing.expect(t, err == nil, fmt.tprint("Extremely large PADDING Failed with error:", err))
flac.destroy(data)
}
@(test)
extreme_large_picture :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/50 - Extremely large PICTURE.flac")
testing.expect(t, err == nil, fmt.tprint("Extremely large PICTURE Failed with error:", err))
flac.destroy(data)
}
@(test)
extreme_large_vorbiscomment :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/51 - Extremely large VORBISCOMMENT.flac")
testing.expect(t, err == nil, fmt.tprint("Extremely large VORBISCOMMENT Failed with error:", err))
flac.destroy(data)
}
@(test)
extreme_large_application :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/52 - Extremely large APPLICATION.flac")
testing.expect(t, err == nil, fmt.tprint("Extremely large APPLICATION Failed with error:", err))
flac.destroy(data)
}
@(test)
cuesheet_with_very_many_indexes :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/53 - CUESHEET with very many indexes.flac")
testing.expect(t, err == nil, fmt.tprint("CUESHEET with very many indexes Failed with error:", err))
flac.destroy(data)
}
@(test)
_1000x_repeating_vorbiscomment :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/54 - 1000x repeating VORBISCOMMENT.flac")
testing.expect(t, err == nil, fmt.tprint("1000x repeating VORBSICOMMENT Failed with error:", err))
flac.destroy(data)
}
@(test)
file_48_53_combined :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/55 - file 48-53 combined.flac")
testing.expect(t, err == nil, fmt.tprint("File 48-53 combined Failed with error:", err))
flac.destroy(data)
}
@(test)
jpg_picture :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/56 - JPG PICTURE.flac")
testing.expect(t, err == nil, fmt.tprint("JPG PICTURE Failed with error:", err))
flac.destroy(data)
}
@(test)
png_picture :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/57 - PNG PICTURE.flac")
testing.expect(t, err == nil, fmt.tprint("PNG PICTURE Failed with error:", err))
flac.destroy(data)
}
@(test)
gif_picture :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/58 - GIF PICTURE.flac")
testing.expect(t, err == nil, fmt.tprint("GIF PICTURE Failed with error:", err))
flac.destroy(data)
}
@(test)
avif_picture :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/59 - AVIF PICTURE.flac")
testing.expect(t, err == nil, fmt.tprint("AVIF PICTURE Failed with error:", err))
flac.destroy(data)
}
@(test)
mono_audio :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/60 - mono audio.flac")
testing.expect(t, err == nil, fmt.tprint("Mono audio Failed with error:", err))
flac.destroy(data)
}
@(test)
predictor_overflow_check_16_bit :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/61 - predictor overflow check, 16-bit.flac")
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 16-bit Failed with error:", err))
flac.destroy(data)
}
@(test)
predictor_overflow_check_20_bit :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/62 - predictor overflow check, 20-bit.flac")
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 20-bit Failed with error:", err))
flac.destroy(data)
}
@(test)
predictor_overflow_check_24_bit :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/63 - predictor overflow check, 24-bit.flac")
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 24-bit Failed with error:", err))
flac.destroy(data)
}
@(test)
rice_partitions_with_escape_code_zero :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/subset/64 - rice partitions with escape code zero.flac")
testing.expect(t, err == nil, fmt.tprint("Rice partitions with escape code zero Failed with error:", err))
flac.destroy(data)
}
@(test)
uncommon_32_bit_per_sample :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/uncommon/05 - 32bps audio.flac")
testing.expect(t, err == nil, fmt.tprint("Uncommon 32bps audio Failed with error:", err))
flac.destroy(data)
}
@(test)
uncommon_samplerate_768kHz :: proc(t: ^testing.T) {
data, err := flac.load_from_file("flac-test-files/uncommon/06 - samplerate 768kHz.flac")
testing.expect(t, err == nil, fmt.tprint("Uncommon samplerate 768kHz Failed with error:", err))
flac.destroy(data)
}
// TODO:
tests/flac_buffered_test.odin → tests/flac_test.odin
+132 -132
View File
@@ -6,8 +6,8 @@ import "core:testing"
import "shared:flac"
@(test)
test_blocksize_4096_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/01 - blocksize 4096.flac")
test_blocksize_4096 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/01 - blocksize 4096.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Read Blocksize 4096 metadata Failed with error:", err))
@@ -21,8 +21,8 @@ test_blocksize_4096_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_4608_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/02 - blocksize 4608.flac")
test_blocksize_4608 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/02 - blocksize 4608.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 4608 Failed with error:", err))
@@ -36,8 +36,8 @@ test_blocksize_4608_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_16_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/03 - blocksize 16.flac")
test_blocksize_16 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/03 - blocksize 16.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 16 Failed with error:", err))
@@ -51,8 +51,8 @@ test_blocksize_16_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_192_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/04 - blocksize 192.flac")
test_blocksize_192 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/04 - blocksize 192.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 192 Failed with error:", err))
@@ -66,8 +66,8 @@ test_blocksize_192_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_254_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/05 - blocksize 254.flac")
test_blocksize_254 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/05 - blocksize 254.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 254 Failed with error:", err))
@@ -81,8 +81,8 @@ test_blocksize_254_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_512_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/06 - blocksize 512.flac")
test_blocksize_512 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/06 - blocksize 512.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 512 Failed with error:", err))
@@ -96,8 +96,8 @@ test_blocksize_512_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_725_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/07 - blocksize 725.flac")
test_blocksize_725 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/07 - blocksize 725.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 725 Failed with error:", err))
@@ -111,8 +111,8 @@ test_blocksize_725_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_1000_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/08 - blocksize 1000.flac")
test_blocksize_1000 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/08 - blocksize 1000.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 1000 Failed with error:", err))
@@ -126,8 +126,8 @@ test_blocksize_1000_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_1937_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/09 - blocksize 1937.flac")
test_blocksize_1937 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/09 - blocksize 1937.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 1937 Failed with error:", err))
@@ -141,8 +141,8 @@ test_blocksize_1937_buffered :: proc(t: ^testing.T) {
}
@(test)
test_blocksize_2304_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/10 - blocksize 2304.flac")
test_blocksize_2304 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/10 - blocksize 2304.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Blocksize 2304 Failed with error:", err))
@@ -156,8 +156,8 @@ test_blocksize_2304_buffered :: proc(t: ^testing.T) {
}
@(test)
test_partition_order_8_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/11 - partition order 8.flac")
test_partition_order_8 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/11 - partition order 8.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Partition order 8 Failed with error:", err))
@@ -171,8 +171,8 @@ test_partition_order_8_buffered :: proc(t: ^testing.T) {
}
@(test)
test_qlp_precision_15_bit_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/12 - qlp precision 15 bit.flac")
test_qlp_precision_15_bit :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/12 - qlp precision 15 bit.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("qlp precision 15 bit Failed with error:", err))
@@ -186,8 +186,8 @@ test_qlp_precision_15_bit_buffered :: proc(t: ^testing.T) {
}
@(test)
test_qlp_precision_2_bit_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/13 - qlp precision 2 bit.flac")
test_qlp_precision_2_bit :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/13 - qlp precision 2 bit.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("qlp precision 2 bit Failed with error:", err))
@@ -201,8 +201,8 @@ test_qlp_precision_2_bit_buffered :: proc(t: ^testing.T) {
}
@(test)
wasted_bits_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/14 - wasted bits.flac")
wasted_bits :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/14 - wasted bits.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Wasted bits Failed with error:", err))
@@ -216,8 +216,8 @@ wasted_bits_buffered :: proc(t: ^testing.T) {
}
@(test)
only_verbatim_subframes_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/15 - only verbatim subframes.flac")
only_verbatim_subframes :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/15 - only verbatim subframes.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Only verbatim subframes Failed with error:", err))
@@ -231,8 +231,8 @@ only_verbatim_subframes_buffered :: proc(t: ^testing.T) {
}
@(test)
partition_order_8_containing_escaped_partitions_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/16 - partition order 8 containing escaped partitions.flac")
partition_order_8_containing_escaped_partitions :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/16 - partition order 8 containing escaped partitions.flac")
defer flac.destroy(data, r)
testing.expect(
t,
@@ -250,8 +250,8 @@ partition_order_8_containing_escaped_partitions_buffered :: proc(t: ^testing.T)
}
@(test)
all_fixed_orders_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/17 - all fixed orders.flac")
all_fixed_orders :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/17 - all fixed orders.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("All fixed orders Failed with error:", err))
@@ -265,8 +265,8 @@ all_fixed_orders_buffered :: proc(t: ^testing.T) {
}
@(test)
precision_search_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/18 - precision search.flac")
precision_search :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/18 - precision search.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Precision search Failed with error:", err))
@@ -280,8 +280,8 @@ precision_search_buffered :: proc(t: ^testing.T) {
}
@(test)
samplerate_35467Hz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/19 - samplerate 35467Hz.flac")
samplerate_35467Hz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/19 - samplerate 35467Hz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 35467Hz Failed with error:", err))
@@ -295,8 +295,8 @@ samplerate_35467Hz_buffered :: proc(t: ^testing.T) {
}
@(test)
samplerate_39kHz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/20 - samplerate 39kHz.flac")
samplerate_39kHz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/20 - samplerate 39kHz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 39kHz Failed with error:", err))
@@ -310,8 +310,8 @@ samplerate_39kHz_buffered :: proc(t: ^testing.T) {
}
@(test)
samplerate_22050Hz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/21 - samplerate 22050Hz.flac")
samplerate_22050Hz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/21 - samplerate 22050Hz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 22050Hz Failed with error:", err))
@@ -325,8 +325,8 @@ samplerate_22050Hz_buffered :: proc(t: ^testing.T) {
}
@(test)
_12_bit_per_sample_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/22 - 12 bit per sample.flac")
_12_bit_per_sample :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/22 - 12 bit per sample.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("12 bit per sample Failed with error:", err))
@@ -340,8 +340,8 @@ _12_bit_per_sample_buffered :: proc(t: ^testing.T) {
}
@(test)
_8_bit_per_sample_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/23 - 8 bit per sample.flac")
_8_bit_per_sample :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/23 - 8 bit per sample.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("8 bit per sample Failed with error:", err))
@@ -355,8 +355,8 @@ _8_bit_per_sample_buffered :: proc(t: ^testing.T) {
}
@(test)
variable_blocksize_file_created_with_flake_revision_264_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
variable_blocksize_file_created_with_flake_revision_264 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/24 - variable blocksize file created with flake revision 264.flac",
)
defer flac.destroy(data, r)
@@ -376,8 +376,8 @@ variable_blocksize_file_created_with_flake_revision_264_buffered :: proc(t: ^tes
}
@(test)
variable_blocksize_file_created_with_flake_revision_264_modified_to_create_smaller_blocks_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
variable_blocksize_file_created_with_flake_revision_264_modified_to_create_smaller_blocks :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/25 - variable blocksize file created with flake revision 264, modified to create smaller blocks.flac",
)
defer flac.destroy(data, r)
@@ -400,8 +400,8 @@ variable_blocksize_file_created_with_flake_revision_264_modified_to_create_small
}
@(test)
variable_blocksize_file_created_with_CUETools_Flake_2_1_6_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
variable_blocksize_file_created_with_CUETools_Flake_2_1_6 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/26 - variable blocksize file created with CUETools.Flake 2.1.6.flac",
)
defer flac.destroy(data, r)
@@ -421,8 +421,8 @@ variable_blocksize_file_created_with_CUETools_Flake_2_1_6_buffered :: proc(t: ^t
}
@(test)
old_format_variable_blocksize_file_created_with_Flake_0_11_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
old_format_variable_blocksize_file_created_with_Flake_0_11 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/27 - old format variable blocksize file created with Flake 0.11.flac",
)
defer flac.destroy(data, r)
@@ -442,8 +442,8 @@ old_format_variable_blocksize_file_created_with_Flake_0_11_buffered :: proc(t: ^
}
@(test)
high_resolution_audio_default_settings_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered ("flac-test-files/subset/28 - high resolution audio, default settings.flac")
high_resolution_audio_default_settings :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file ("flac-test-files/subset/28 - high resolution audio, default settings.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("High resolution audio, default settings Failed with error:", err))
@@ -457,8 +457,8 @@ high_resolution_audio_default_settings_buffered :: proc(t: ^testing.T) {
}
@(test)
high_resolution_audio_blocksize_16384_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/29 - high resolution audio, blocksize 16384.flac")
high_resolution_audio_blocksize_16384 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/29 - high resolution audio, blocksize 16384.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 16384 Failed with error:", err))
@@ -472,8 +472,8 @@ high_resolution_audio_blocksize_16384_buffered :: proc(t: ^testing.T) {
}
@(test)
high_resolution_audio_blocksize_13456_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/30 - high resolution audio, blocksize 13456.flac")
high_resolution_audio_blocksize_13456 :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/30 - high resolution audio, blocksize 13456.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 13456 Failed with error:", err))
@@ -487,8 +487,8 @@ high_resolution_audio_blocksize_13456_buffered :: proc(t: ^testing.T) {
}
@(test)
high_resolution_audio_using_only_32nd_order_predictors_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
high_resolution_audio_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/31 - high resolution audio, using only 32nd order predictors.flac",
)
defer flac.destroy(data, r)
@@ -508,8 +508,8 @@ high_resolution_audio_using_only_32nd_order_predictors_buffered :: proc(t: ^test
}
@(test)
high_resolution_audio_partition_order_8_containing_escaped_partitions_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
high_resolution_audio_partition_order_8_containing_escaped_partitions :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/32 - high resolution audio, partition order 8 containing escaped partitions.flac",
)
defer flac.destroy(data, r)
@@ -529,8 +529,8 @@ high_resolution_audio_partition_order_8_containing_escaped_partitions_buffered :
}
@(test)
samplerate_192kHz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/33 - samplerate 192kHz.flac")
samplerate_192kHz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/33 - samplerate 192kHz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 192kHz Failed with error:", err))
@@ -544,8 +544,8 @@ samplerate_192kHz_buffered :: proc(t: ^testing.T) {
}
@(test)
samplerate_192kHz_using_only_32nd_order_predictors_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/34 - samplerate 192kHz, using only 32nd order predictors.flac")
samplerate_192kHz_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/34 - samplerate 192kHz, using only 32nd order predictors.flac")
defer flac.destroy(data, r)
testing.expect(
t,
@@ -563,8 +563,8 @@ samplerate_192kHz_using_only_32nd_order_predictors_buffered :: proc(t: ^testing.
}
@(test)
samplerate_134560Hz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/35 - samplerate 134560Hz.flac")
samplerate_134560Hz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/35 - samplerate 134560Hz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 134560Hz Failed with error:", err))
@@ -578,8 +578,8 @@ samplerate_134560Hz_buffered :: proc(t: ^testing.T) {
}
@(test)
samplerate_384kHz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/36 - samplerate 384kHz.flac")
samplerate_384kHz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/36 - samplerate 384kHz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Samplerate 384kHz Failed with error:", err))
@@ -593,8 +593,8 @@ samplerate_384kHz_buffered :: proc(t: ^testing.T) {
}
@(test)
_20_bit_per_sample_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/37 - 20 bit per sample.flac")
_20_bit_per_sample :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/37 - 20 bit per sample.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("20 bit per sample Failed with error:", err))
@@ -608,8 +608,8 @@ _20_bit_per_sample_buffered :: proc(t: ^testing.T) {
}
@(test)
_3_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/38 - 3 channels (3.0).flac")
_3_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/38 - 3 channels (3.0).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("3 channels Failed with error:", err))
@@ -623,8 +623,8 @@ _3_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_4_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/39 - 4 channels (4.0).flac")
_4_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/39 - 4 channels (4.0).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("4 channels Failed with error:", err))
@@ -638,8 +638,8 @@ _4_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_5_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/40 - 5 channels (5.0).flac")
_5_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/40 - 5 channels (5.0).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("5 channels Failed with error:", err))
@@ -653,8 +653,8 @@ _5_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_6_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/41 - 6 channels (5.1).flac")
_6_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/41 - 6 channels (5.1).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("6 channels Failed with error:", err))
@@ -668,8 +668,8 @@ _6_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_7_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/42 - 7 channels (6.1).flac")
_7_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/42 - 7 channels (6.1).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("7 channels Failed with error:", err))
@@ -683,8 +683,8 @@ _7_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_8_channels_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/43 - 8 channels (7.1).flac")
_8_channels :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/43 - 8 channels (7.1).flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("8 channels Failed with error:", err))
@@ -698,8 +698,8 @@ _8_channels_buffered :: proc(t: ^testing.T) {
}
@(test)
_8_channel_surround_192kHz_24_bit_using_only_32nd_order_predictors_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered(
_8_channel_surround_192kHz_24_bit_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file(
"flac-test-files/subset/44 - 8-channel surround, 192kHz, 24 bit, using only 32nd order predictors.flac",
)
defer flac.destroy(data, r)
@@ -719,8 +719,8 @@ _8_channel_surround_192kHz_24_bit_using_only_32nd_order_predictors_buffered :: p
}
@(test)
no_total_number_of_samples_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/45 - no total number of samples set.flac")
no_total_number_of_samples :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/45 - no total number of samples set.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("No total number of samples Failed with error:", err))
@@ -734,8 +734,8 @@ no_total_number_of_samples_buffered :: proc(t: ^testing.T) {
}
@(test)
no_min_max_framesize_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/46 - no min-max framesize set.flac")
no_min_max_framesize :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/46 - no min-max framesize set.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("No min-max framesize Failed with error:", err))
@@ -749,8 +749,8 @@ no_min_max_framesize_buffered :: proc(t: ^testing.T) {
}
@(test)
only_streaminfo_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/47 - only STREAMINFO.flac")
only_streaminfo :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/47 - only STREAMINFO.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Only STREAMINFO Failed with error:", err))
@@ -764,8 +764,8 @@ only_streaminfo_buffered :: proc(t: ^testing.T) {
}
@(test)
extreme_large_seektable_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/48 - Extremely large SEEKTABLE.flac")
extreme_large_seektable :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/48 - Extremely large SEEKTABLE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Extremely large SEEKTABLE Failed with error:", err))
@@ -779,8 +779,8 @@ extreme_large_seektable_buffered :: proc(t: ^testing.T) {
}
@(test)
extreme_large_padding_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/49 - Extremely large PADDING.flac")
extreme_large_padding :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/49 - Extremely large PADDING.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Extremely large PADDING Failed with error:", err))
@@ -794,8 +794,8 @@ extreme_large_padding_buffered :: proc(t: ^testing.T) {
}
@(test)
extreme_large_picture_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/50 - Extremely large PICTURE.flac")
extreme_large_picture :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/50 - Extremely large PICTURE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Extremely large PICTURE Failed with error:", err))
@@ -809,8 +809,8 @@ extreme_large_picture_buffered :: proc(t: ^testing.T) {
}
@(test)
extreme_large_vorbiscomment_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/51 - Extremely large VORBISCOMMENT.flac")
extreme_large_vorbiscomment :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/51 - Extremely large VORBISCOMMENT.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Extremely large VORBISCOMMENT Failed with error:", err))
@@ -824,8 +824,8 @@ extreme_large_vorbiscomment_buffered :: proc(t: ^testing.T) {
}
@(test)
extreme_large_application_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/52 - Extremely large APPLICATION.flac")
extreme_large_application :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/52 - Extremely large APPLICATION.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Extremely large APPLICATION Failed with error:", err))
@@ -839,8 +839,8 @@ extreme_large_application_buffered :: proc(t: ^testing.T) {
}
@(test)
cuesheet_with_very_many_indexes_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/53 - CUESHEET with very many indexes.flac")
cuesheet_with_very_many_indexes :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/53 - CUESHEET with very many indexes.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("CUESHEET with very many indexes Failed with error:", err))
@@ -854,8 +854,8 @@ cuesheet_with_very_many_indexes_buffered :: proc(t: ^testing.T) {
}
@(test)
_1000x_repeating_vorbiscomment_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/54 - 1000x repeating VORBISCOMMENT.flac")
_1000x_repeating_vorbiscomment :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/54 - 1000x repeating VORBISCOMMENT.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("1000x repeating VORBSICOMMENT Failed with error:", err))
@@ -869,8 +869,8 @@ _1000x_repeating_vorbiscomment_buffered :: proc(t: ^testing.T) {
}
@(test)
file_48_53_combined_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/55 - file 48-53 combined.flac")
file_48_53_combined :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/55 - file 48-53 combined.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("File 48-53 combined Failed with error:", err))
@@ -884,8 +884,8 @@ file_48_53_combined_buffered :: proc(t: ^testing.T) {
}
@(test)
jpg_picture_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/56 - JPG PICTURE.flac")
jpg_picture :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/56 - JPG PICTURE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("JPG PICTURE Failed with error:", err))
@@ -899,8 +899,8 @@ jpg_picture_buffered :: proc(t: ^testing.T) {
}
@(test)
png_picture_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/57 - PNG PICTURE.flac")
png_picture :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/57 - PNG PICTURE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("PNG PICTURE Failed with error:", err))
@@ -914,8 +914,8 @@ png_picture_buffered :: proc(t: ^testing.T) {
}
@(test)
gif_picture_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/58 - GIF PICTURE.flac")
gif_picture :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/58 - GIF PICTURE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("GIF PICTURE Failed with error:", err))
@@ -929,8 +929,8 @@ gif_picture_buffered :: proc(t: ^testing.T) {
}
@(test)
avif_picture_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/59 - AVIF PICTURE.flac")
avif_picture :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/59 - AVIF PICTURE.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("AVIF PICTURE Failed with error:", err))
@@ -944,8 +944,8 @@ avif_picture_buffered :: proc(t: ^testing.T) {
}
@(test)
mono_audio_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/60 - mono audio.flac")
mono_audio :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/60 - mono audio.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Mono audio Failed with error:", err))
@@ -959,8 +959,8 @@ mono_audio_buffered :: proc(t: ^testing.T) {
}
@(test)
predictor_overflow_check_16_bit_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/61 - predictor overflow check, 16-bit.flac")
predictor_overflow_check_16_bit :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/61 - predictor overflow check, 16-bit.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 16-bit Failed with error:", err))
@@ -974,8 +974,8 @@ predictor_overflow_check_16_bit_buffered :: proc(t: ^testing.T) {
}
@(test)
predictor_overflow_check_20_bit_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/62 - predictor overflow check, 20-bit.flac")
predictor_overflow_check_20_bit :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/62 - predictor overflow check, 20-bit.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 20-bit Failed with error:", err))
@@ -989,8 +989,8 @@ predictor_overflow_check_20_bit_buffered :: proc(t: ^testing.T) {
}
@(test)
predictor_overflow_check_24_bit_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/63 - predictor overflow check, 24-bit.flac")
predictor_overflow_check_24_bit :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/63 - predictor overflow check, 24-bit.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 24-bit Failed with error:", err))
@@ -1004,8 +1004,8 @@ predictor_overflow_check_24_bit_buffered :: proc(t: ^testing.T) {
}
@(test)
rice_partitions_with_escape_code_zero_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/subset/64 - rice partitions with escape code zero.flac")
rice_partitions_with_escape_code_zero :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/subset/64 - rice partitions with escape code zero.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Rice partitions with escape code zero Failed with error:", err))
@@ -1019,8 +1019,8 @@ rice_partitions_with_escape_code_zero_buffered :: proc(t: ^testing.T) {
}
@(test)
uncommon_32_bit_per_sample_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/uncommon/05 - 32bps audio.flac")
uncommon_32_bit_per_sample :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/uncommon/05 - 32bps audio.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Uncommon 32bps audio Failed with error:", err))
@@ -1034,8 +1034,8 @@ uncommon_32_bit_per_sample_buffered :: proc(t: ^testing.T) {
}
@(test)
uncommon_samplerate_768kHz_buffered :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file_buffered("flac-test-files/uncommon/06 - samplerate 768kHz.flac")
uncommon_samplerate_768kHz :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/uncommon/06 - samplerate 768kHz.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Uncommon samplerate 768kHz Failed with error:", err))