From dfaca585fde3623bbc8e776f19254c06bea60f85 Mon Sep 17 00:00:00 2001 From: IllusionMan1212 Date: Tue, 24 Sep 2024 06:36:33 +0200 Subject: [PATCH] remove the in-memory API --- TODO.md | 2 + {examples/buffered => example}/main.odin | 4 +- examples/in_memory/main.odin | 81 --- flac.odin | 360 +---------- tests/flac_in_memory_test.odin | 589 ------------------ ...flac_buffered_test.odin => flac_test.odin} | 264 ++++---- 6 files changed, 150 insertions(+), 1150 deletions(-) rename {examples/buffered => example}/main.odin (95%) delete mode 100644 examples/in_memory/main.odin delete mode 100644 tests/flac_in_memory_test.odin rename tests/{flac_buffered_test.odin => flac_test.odin} (70%) diff --git a/TODO.md b/TODO.md index d598aec..4ebae00 100644 --- a/TODO.md +++ b/TODO.md @@ -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) diff --git a/examples/buffered/main.odin b/example/main.odin similarity index 95% rename from examples/buffered/main.odin rename to example/main.odin index e4c016e..7e04a92 100644 --- a/examples/buffered/main.odin +++ b/example/main.odin @@ -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 diff --git a/examples/in_memory/main.odin b/examples/in_memory/main.odin deleted file mode 100644 index 6f76618..0000000 --- a/examples/in_memory/main.odin +++ /dev/null @@ -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) -} diff --git a/flac.odin b/flac.odin index 1987bd3..de5b6f2 100644 --- a/flac.odin +++ b/flac.odin @@ -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..> 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 - } + reader := cast(^bufio.Reader)r.data + skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) 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 - } + reader := cast(^bufio.Reader)r.data + skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) 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 - } + reader := cast(^bufio.Reader)r.data + skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) 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 - } + reader := cast(^bufio.Reader)r.data + skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) 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. diff --git a/tests/flac_in_memory_test.odin b/tests/flac_in_memory_test.odin deleted file mode 100644 index 7b5f6af..0000000 --- a/tests/flac_in_memory_test.odin +++ /dev/null @@ -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: diff --git a/tests/flac_buffered_test.odin b/tests/flac_test.odin similarity index 70% rename from tests/flac_buffered_test.odin rename to tests/flac_test.odin index ed6e152..9a7afd3 100644 --- a/tests/flac_buffered_test.odin +++ b/tests/flac_test.odin @@ -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))