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

Compare commits

base: Illusion/flac-odin:c8b4c932764d733927c26b77c7804409d64eb3ed
Branches Tags
Illusion/flac-odin:master
...
compare: Illusion/flac-odin:44b4e52063fea53264785a972d5c863f68bbeb9a
Branches Tags
Illusion/flac-odin:master
2 Commits
c8b4c93276 ... 44b4e52063
Author SHA1 Message Date
Illusion 44b4e52063 fix: redeclaration of reserved field with using 2026-09-11 01:44:58 +02:00
Illusion ba691f7470 fix: compile under latest odin (maybe). other small fixes 2026-09-11 01:25:54 +02:00
4 changed files with 100 additions and 76 deletions
Expand all files Collapse all files
example/main_linux.odin
+1 -1
View File
@@ -1,4 +1,4 @@
package flac_linux_example package flac_linux_alsa_example
import "core:fmt" import "core:fmt"
import "core:mem" import "core:mem"
flac.odin
+5 -5
View File
@@ -5,8 +5,7 @@ import "core:crypto/legacy/md5"
import "core:fmt" import "core:fmt"
import "core:io" import "core:io"
import "core:mem" import "core:mem"
import "core:os/os2" import "core:os"
import "core:time"
Error :: union { Error :: union {
io.Error, io.Error,
@@ -69,6 +68,7 @@ PictureType :: enum u32 {
Flac :: struct { Flac :: struct {
metadata: FlacMetadata, metadata: FlacMetadata,
// This holds the samples of the current frame. // This holds the samples of the current frame.
// TODO: Should this be deleted? every frame already holds its own samples data
samples: [dynamic]i32, samples: [dynamic]i32,
} }
@@ -869,19 +869,19 @@ md5sum :: proc(md5_ctx: ^md5.Context, flac: ^Flac) -> Error {
} }
// `load_from_file` 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. // Calls to `decode_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. // This is the recommended way to read most FLAC files as it has a minimal memory overhead.
load_from_file :: 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 context.allocator = allocator
file, open_err := os2.open(filename) file, open_err := os.open(filename)
if open_err != nil { if open_err != nil {
fmt.eprintln(open_err) fmt.eprintln(open_err)
return nil, {}, .Unable_To_Read_File return nil, {}, .Unable_To_Read_File
} }
br := new(bufio.Reader) br := new(bufio.Reader)
bufio.reader_init(br, os2.to_stream(file)) bufio.reader_init(br, os.to_stream(file))
r = new(Reader) r = new(Reader)
r.r = bufio.reader_to_stream(br) r.r = bufio.reader_to_stream(br)
internal.odin
+4 -4
View File
@@ -212,10 +212,10 @@ CueSheet :: struct #packed {
media_catalog_num: [128]byte, media_catalog_num: [128]byte,
num_lead_in_samples: u64be, num_lead_in_samples: u64be,
using _: bit_field u8 { using _: bit_field u8 {
reserved: u8 | 7, reserved_1: u8 | 7,
compact_disc: bool | 1, compact_disc: bool | 1,
}, },
reserved: [258]byte, reserved_2: [258]byte,
num_tracks: u8, num_tracks: u8,
} }
@@ -225,11 +225,11 @@ CueSheetTrack :: struct #packed {
track_num: u8, track_num: u8,
ISRC: [12]byte, ISRC: [12]byte,
using _: bit_field u8 { using _: bit_field u8 {
reserved: u8 | 6, reserved_1: u8 | 6,
pre_emphasis: bool | 1, pre_emphasis: bool | 1,
track_type: TrackType | 1, track_type: TrackType | 1,
}, },
reserved: [13]byte, reserved_2: [13]byte,
num_track_index_points: u8, num_track_index_points: u8,
} }
tests/flac_test.odin
+90 -66
View File
@@ -3,6 +3,7 @@ package flac_test
import "core:fmt" import "core:fmt"
import "core:os" import "core:os"
import "core:testing" import "core:testing"
import "core:crypto/legacy/md5"
import "shared:flac" import "shared:flac"
@(test) @(test)
@@ -12,7 +13,7 @@ test_blocksize_4096 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Read Blocksize 4096 metadata Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Read Blocksize 4096 metadata Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -27,7 +28,7 @@ test_blocksize_4608 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 4608 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 4608 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -42,7 +43,7 @@ test_blocksize_16 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 16 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 16 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -57,7 +58,7 @@ test_blocksize_192 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 192 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 192 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -72,7 +73,7 @@ test_blocksize_254 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 254 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 254 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -87,7 +88,7 @@ test_blocksize_512 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 512 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 512 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -102,7 +103,7 @@ test_blocksize_725 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 725 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 725 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -117,7 +118,7 @@ test_blocksize_1000 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 1000 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 1000 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -132,7 +133,7 @@ test_blocksize_1937 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 1937 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 1937 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -147,7 +148,7 @@ test_blocksize_2304 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Blocksize 2304 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Blocksize 2304 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -162,7 +163,7 @@ test_partition_order_8 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Partition order 8 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Partition order 8 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -177,7 +178,7 @@ test_qlp_precision_15_bit :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("qlp precision 15 bit Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("qlp precision 15 bit Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -192,7 +193,7 @@ test_qlp_precision_2_bit :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("qlp precision 2 bit Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("qlp precision 2 bit Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -207,7 +208,7 @@ wasted_bits :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Wasted bits Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Wasted bits Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -222,7 +223,7 @@ only_verbatim_subframes :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Only verbatim subframes Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Only verbatim subframes Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -241,7 +242,7 @@ partition_order_8_containing_escaped_partitions :: proc(t: ^testing.T) {
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -256,7 +257,7 @@ all_fixed_orders :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("All fixed orders Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("All fixed orders Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -271,7 +272,7 @@ precision_search :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Precision search Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Precision search Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -286,7 +287,7 @@ samplerate_35467Hz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 35467Hz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 35467Hz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -301,7 +302,7 @@ samplerate_39kHz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 39kHz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 39kHz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -316,7 +317,7 @@ samplerate_22050Hz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 22050Hz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 22050Hz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -331,7 +332,7 @@ _12_bit_per_sample :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("12 bit per sample Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("12 bit per sample Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -346,7 +347,7 @@ _8_bit_per_sample :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("8 bit per sample Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("8 bit per sample Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -367,7 +368,7 @@ variable_blocksize_file_created_with_flake_revision_264 :: proc(t: ^testing.T) {
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -391,7 +392,7 @@ variable_blocksize_file_created_with_flake_revision_264_modified_to_create_small
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -412,7 +413,7 @@ variable_blocksize_file_created_with_CUETools_Flake_2_1_6 :: proc(t: ^testing.T)
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -433,7 +434,7 @@ old_format_variable_blocksize_file_created_with_Flake_0_11 :: proc(t: ^testing.T
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -448,7 +449,7 @@ high_resolution_audio_default_settings :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("High resolution audio, default settings Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("High resolution audio, default settings Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -463,7 +464,7 @@ high_resolution_audio_blocksize_16384 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 16384 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 16384 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -478,7 +479,7 @@ high_resolution_audio_blocksize_13456 :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 13456 Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("High resolution audio, blocksize 13456 Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -499,7 +500,7 @@ high_resolution_audio_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -520,7 +521,7 @@ high_resolution_audio_partition_order_8_containing_escaped_partitions :: proc(t:
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -535,7 +536,7 @@ samplerate_192kHz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 192kHz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 192kHz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -554,7 +555,7 @@ samplerate_192kHz_using_only_32nd_order_predictors :: proc(t: ^testing.T) {
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -569,7 +570,7 @@ samplerate_134560Hz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 134560Hz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 134560Hz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -584,7 +585,7 @@ samplerate_384kHz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Samplerate 384kHz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Samplerate 384kHz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -599,7 +600,7 @@ _20_bit_per_sample :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("20 bit per sample Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("20 bit per sample Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -614,7 +615,7 @@ _3_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("3 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("3 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -629,7 +630,7 @@ _4_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("4 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("4 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -644,7 +645,7 @@ _5_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("5 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("5 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -659,7 +660,7 @@ _6_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("6 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("6 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -674,7 +675,7 @@ _7_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("7 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("7 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -689,7 +690,7 @@ _8_channels :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("8 channels Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("8 channels Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -710,7 +711,7 @@ _8_channel_surround_192kHz_24_bit_using_only_32nd_order_predictors :: proc(t: ^t
) )
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -725,7 +726,7 @@ no_total_number_of_samples :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("No total number of samples Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("No total number of samples Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -740,7 +741,7 @@ no_min_max_framesize :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("No min-max framesize Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("No min-max framesize Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -755,7 +756,7 @@ only_streaminfo :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Only STREAMINFO Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Only STREAMINFO Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -770,7 +771,7 @@ extreme_large_seektable :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Extremely large SEEKTABLE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Extremely large SEEKTABLE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -785,7 +786,7 @@ extreme_large_padding :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Extremely large PADDING Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Extremely large PADDING Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -800,7 +801,7 @@ extreme_large_picture :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Extremely large PICTURE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Extremely large PICTURE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -815,7 +816,7 @@ extreme_large_vorbiscomment :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Extremely large VORBISCOMMENT Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Extremely large VORBISCOMMENT Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -830,7 +831,7 @@ extreme_large_application :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Extremely large APPLICATION Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Extremely large APPLICATION Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -845,7 +846,7 @@ cuesheet_with_very_many_indexes :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("CUESHEET with very many indexes Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("CUESHEET with very many indexes Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -860,7 +861,7 @@ _1000x_repeating_vorbiscomment :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("1000x repeating VORBSICOMMENT Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("1000x repeating VORBSICOMMENT Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -875,7 +876,7 @@ file_48_53_combined :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("File 48-53 combined Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("File 48-53 combined Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -890,7 +891,7 @@ jpg_picture :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("JPG PICTURE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("JPG PICTURE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -905,7 +906,7 @@ png_picture :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("PNG PICTURE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("PNG PICTURE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -920,7 +921,7 @@ gif_picture :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("GIF PICTURE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("GIF PICTURE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -935,7 +936,7 @@ avif_picture :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("AVIF PICTURE Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("AVIF PICTURE Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -950,7 +951,7 @@ mono_audio :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Mono audio Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Mono audio Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -965,7 +966,7 @@ predictor_overflow_check_16_bit :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 16-bit Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 16-bit Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -980,7 +981,7 @@ predictor_overflow_check_20_bit :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 20-bit Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 20-bit Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -995,7 +996,7 @@ predictor_overflow_check_24_bit :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 24-bit Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Predictor overflow check, 24-bit Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -1010,7 +1011,7 @@ rice_partitions_with_escape_code_zero :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Rice partitions with escape code zero Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Rice partitions with escape code zero Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -1018,6 +1019,29 @@ rice_partitions_with_escape_code_zero :: proc(t: ^testing.T) {
} }
} }
@(test)
uncommon_changing_samplerate :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/uncommon/01 - changing samplerate.flac")
defer flac.destroy(data, r)
testing.expect(t, err == nil, fmt.tprint("Uncommon changing samplerate Failed with error:", err))
md5_ctx: md5.Context
md5.init(&md5_ctx)
for {
frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF {
break
}
flac.md5hash(&md5_ctx, data.metadata.bits_per_sample, frame.samples)
testing.expect(t, f_err == nil, fmt.tprintf("Decoding Uncommon changing samplerate frame Failed with error:", f_err))
}
if data.metadata.expected_md5 != 0 {
testing.expect(t, flac.md5sum(&md5_ctx, data) == nil, fmt.tprintf("Incorrect MD5 hash. Expected %v. Got %v", data.metadata.expected_md5, data.metadata.calculated_md5))
}
}
@(test) @(test)
uncommon_32_bit_per_sample :: proc(t: ^testing.T) { uncommon_32_bit_per_sample :: proc(t: ^testing.T) {
data, r, err := flac.load_from_file("flac-test-files/uncommon/05 - 32bps audio.flac") data, r, err := flac.load_from_file("flac-test-files/uncommon/05 - 32bps audio.flac")
@@ -1025,7 +1049,7 @@ uncommon_32_bit_per_sample :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Uncommon 32bps audio Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Uncommon 32bps audio Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }
@@ -1040,7 +1064,7 @@ uncommon_samplerate_768kHz :: proc(t: ^testing.T) {
testing.expect(t, err == nil, fmt.tprint("Uncommon samplerate 768kHz Failed with error:", err)) testing.expect(t, err == nil, fmt.tprint("Uncommon samplerate 768kHz Failed with error:", err))
for { for {
frame, f_err := flac.read_next_frame(r, data) frame, f_err := flac.decode_next_frame(r, data)
if f_err == .EOF { if f_err == .EOF {
break break
} }