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

feat: buffered decoding API

Browse Source
This commit is contained in:
Illusion
2024-06-19 04:08:54 +02:00
parent ae6ad428ab
commit c7a634eeb3
10 changed files with 1985 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files
flac.odin
+518 -155
View File
@@ -1,6 +1,7 @@
package flac
import "core:bytes"
import "core:bufio"
import "core:crypto/legacy/md5"
import "core:fmt"
import "core:io"
@@ -20,7 +21,6 @@ FlacError :: enum {
Missing_StreamInfo,
Missing_Lead_Out_Track,
Invalid_Coefficient_Precision,
Metadata_Block_Length_Mismatch,
CRC_Mismatch,
MD5_Mismatch,
Unsupported_BPS, // Remove when implemented
@@ -36,17 +36,12 @@ 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_picture_data`
Returns the embedded picture metadata and encoded pixel data (if available)
`.only_return_metadata` includes this.
`.only_return_metadata`
`.only_return_metadata`
Returns all metadata of a FLAC stream without decoding the audio data.
*/
// TODO: Implement these
Option :: enum {
skip_md5_check,
only_return_picture_data,
only_return_metadata,
}
@@ -77,9 +72,8 @@ PictureType :: enum u32 {
}
Flac :: struct {
// TODO: Other stuff
metadata: FlacMetadata,
samples: []i32,
samples: [dynamic]i32,
}
FlacMetadata :: struct {
@@ -90,6 +84,8 @@ FlacMetadata :: struct {
expected_md5: [16]byte,
calculated_md5: [16]byte,
pictures: []Picture,
vendor_name: string,
vorbis_comments: []string,
}
Picture :: struct {
@@ -103,14 +99,17 @@ Picture :: struct {
data: []byte,
}
Frame :: struct {
channels: u8,
sample_rate: u32,
samples: []i32,
}
@(private)
decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32, err: Error) #no_bounds_check {
// TODO: temp allocator?? so we copy the slice of data into the _actual_ sample buffer
// Maybe even a static arena with a size of 32MB by default (and configurable using #config) or something
// that we then use to allocate from (better perf is the reason because allocating on the heap for every subframe
// is probably noticibly slower)
subframe_samples := make([]i32, block_size)
data := read_byte(r) or_return
data := read_bits(r, 8) or_return
subframe_type := (data & 0x7E) >> 1
low_3_bits := subframe_type & 7
@@ -118,7 +117,7 @@ decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32
wasted_bits := 0
if has_wasted_bits {
for (read_bit(r) or_return) != 1 {
for (read_bits(r, 1) or_return) != 1 {
wasted_bits += 1
}
wasted_bits += 1
@@ -251,7 +250,7 @@ decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32
for s in 0..<num_samples {
quotient := 0
// Read bits until we encounter a 1 (also called unary encoding). That's our quotient.
for (read_bit(r) or_return) != 1 {
for (read_bits(r, 1) or_return) != 1 {
quotient += 1
}
remainder := int(read_bits(r, uint(rice_parameter)) or_return)
@@ -352,7 +351,7 @@ decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32
for s in 0..<num_samples {
quotient := 0
// Read bits until we encounter a 1 (also called unary encoding). That's our quotient.
for (read_bit(r) or_return) != 1 {
for (read_bits(r, 1) or_return) != 1 {
quotient += 1
}
remainder := int(read_bits(r, uint(rice_parameter)) or_return)
@@ -395,22 +394,29 @@ decode_subframe :: proc(r: ^Reader, bps: u8, block_size: u16) -> (samples: []i32
return subframe_samples, nil
}
// TODO: remove
frame_num := 0
@(private)
decode_frame :: proc(
r: ^Reader,
flac: ^Flac,
md5_ctx: ^md5.Context,
options: Options,
) -> (
err: Error,
) #no_bounds_check {
//
// Frame Header
//
frame_beginning := r.i
//fmt.println("STARTING FRAME", frame_num)
//fmt.println("FRAME START AT OFFSET:", r.i)
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
@@ -451,7 +457,7 @@ decode_frame :: proc(
case 2..=5:
actual_block_size = 576 * auto_cast (pow2(block_size - 2))
case 6:
actual_block_size = auto_cast (read_byte(r) or_return) + 1
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:
@@ -491,7 +497,7 @@ decode_frame :: proc(
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_byte(r) or_return) * 1000
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:
@@ -504,16 +510,9 @@ decode_frame :: proc(
// 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.
frame_header_end := r.i
frame_header_crc := read_byte(r) or_return
calculated_header_crc := calculate_crc8(r.s[frame_beginning:frame_header_end])
//fmt.printfln("block size bits: 0b%b", block_size)
//fmt.printfln("actual block size: %d sample(s)", actual_block_size)
//fmt.println("sample rate bits:", sample_rate)
//fmt.printfln("actual sample rate: %dHz", actual_sample_rate_in_Hz)
//fmt.println("channel assignment:", channel_assignment)
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)
@@ -576,7 +575,6 @@ decode_frame :: proc(
// so many questions...
}
// TODO: remember to clean this up
subframes := make([][]i32, frame_channels)
defer delete(subframes)
for i in 0..<frame_channels {
@@ -594,6 +592,59 @@ decode_frame :: proc(
align_to_byte(r)
correlate(subframes, channel_assignment)
// Write the samples interleaved.
for i in 0..<len(subframes[0]) {
for subframe, sf in subframes {
sample := subframe[i]
append(&flac.samples, sample)
if .skip_md5_check not_in options {
switch bps {
case 1..=8:
md5.update(md5_ctx, {u8(sample)})
case 9..=16:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte})
case 17..=24:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
third_byte := u8((sample >> 16) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte, third_byte})
case 25..=32:
data := transmute([4]u8)sample
md5.update(md5_ctx, data[:])
case:
fmt.println("INVALID BPS")
os.exit(1)
}
}
}
}
for subframe in subframes {
delete(subframe)
}
//
// Frame Footer
//
crc16_bytes := bytes.buffer_to_bytes(&crc_buffer)
frame_crc := u16(read_data(r, u16be) or_return)
calculated_frame_crc := calculate_crc16(crc16_bytes)
if frame_crc != calculated_frame_crc {
fmt.eprintfln("Expected frame CRC 0x%X, got 0x%X", frame_crc, calculated_frame_crc)
return .CRC_Mismatch
}
return nil
}
@(private)
correlate :: proc(subframes: [][]i32, channel_assignment: ChannelAssignment) {
// Undo Stereo Decorrelation
#partial switch channel_assignment {
case .STEREO_MID_SIDE:
@@ -625,67 +676,11 @@ decode_frame :: proc(
subframes[1][i] = left - side
}
}
// TODO: Maybe this is slow if we have a lot of samples??
// The cases are ranges because streaminfo can define unusual bits per sample
for i in 0..<len(subframes[0]) {
for subframe in subframes {
sample := subframe[i]
switch bps {
case 1..=8:
md5.update(&md5_ctx, {u8(sample)})
case 9..=16:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
md5.update(&md5_ctx, {first_byte, second_byte})
case 17..=24:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
third_byte := u8((sample >> 16) & 0xFF)
md5.update(&md5_ctx, {first_byte, second_byte, third_byte})
case 25..=32:
data := transmute([4]u8)sample
md5.update(&md5_ctx, data[:])
case:
fmt.println("INVALID BPS")
os.exit(1)
}
}
}
// TODO: We need a way to copy (or better yet just point to) the decoded sample data
// We'll probably either copy each subframe's samples somehow, or have a dynamic array and append to that.
// Both are slow-ish but I can't think of a faster way that just works.
// This doesn't work btw, just for my future self to not think this is fine.
for subframe in subframes {
copy(flac.samples, subframe)
}
//
// Frame Footer
//
frame_end := r.i
frame_crc := read_data(r, u16be) or_return
calculated_frame_crc := calculate_crc16(r.s[frame_beginning:frame_end])
if auto_cast frame_crc != calculated_frame_crc {
fmt.eprintfln("Expected frame CRC 0x%X, got 0x%X", frame_crc, calculated_frame_crc)
return .CRC_Mismatch
}
frame_num += 1
return nil
}
load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
r: Reader
bytes.reader_init(&r, data)
md5.init(&md5_ctx)
defer md5.reset(&md5_ctx)
header := read_data(&r, FlacHeader) or_return
@(private)
read_metadata :: proc(r: ^Reader, buffered := false, allocator := context.allocator) -> (flac: ^Flac, err: Error) {
header := read_data(r, FlacHeader) or_return
if header.magic != FLAC_MAGIC {
return nil, .Invalid_Signature
}
@@ -718,7 +713,7 @@ load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context
pictures := make([dynamic]Picture, 0, 2, allocator)
last_block := streaminfo_header.last_block
for !last_block {
md_block_hdr := read_data(&r, u32be) or_return
md_block_hdr := read_data(r, u32be) or_return
metadata_block_header := MetadataBlockHeader {
last_block = bool(md_block_hdr >> 31),
type = BlockType((md_block_hdr >> 24) & 0x7F),
@@ -731,70 +726,95 @@ load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context
case .STREAMINFO:
// Do nothing, we already parse the mandatory streaminfo metadata
case .PADDING:
//fmt.printfln("Skipping %d bytes of padding data", metadata_block_header.length)
bytes.reader_seek(&r, auto_cast metadata_block_header.length, .Current)
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case .APPLICATION:
//app_id := read_slice(&r, 4) or_return
//fmt.println("Found application with ID:", string(app_id))
//fmt.printfln("Skipping %d bytes of application metadata block", metadata_block_header.length)
bytes.reader_seek(&r, auto_cast metadata_block_header.length, .Current)
// TODO: handle the application data
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case .SEEKTABLE:
// TODO: check for size mismatch?
seekpoints := metadata_block_header.length / 18
//fmt.printfln("we have %d seekpoints", seekpoints)
actual_size := 0
for i in 0..<seekpoints {
_ = read_data(&r, Seekpoint) or_return
_ = read_data(r, Seekpoint) or_return
actual_size += size_of(Seekpoint)
//fmt.println(seekpoint)
}
if metadata_block_header.length != u32(actual_size) {
fmt.eprintln("Seektable metadata header length mismatch!")
fmt.eprintfln("Expected size: %d, Got %d", metadata_block_header.length, actual_size)
}
case .VORBIS_COMMENT:
// TODO: save this info to a struct
vendor_name_len := read_data(&r, u32le) or_return
vendor_name := string(read_slice(&r, auto_cast vendor_name_len) or_return)
user_comment_list_len := read_data(&r, u32le) or_return
vendor_name_len := read_data(r, u32le) or_return
vendor_name_slice := make([]byte, vendor_name_len)
read_slice(r, vendor_name_slice) or_return
vendor_name := string(vendor_name_slice)
user_comment_list_len := read_data(r, u32le) or_return
actual_size := 4 + vendor_name_len + 4
comments := make([]string, user_comment_list_len)
for i in 0..<user_comment_list_len {
comment_len := read_data(&r, u32le) or_return
comment := string(read_slice(&r, auto_cast comment_len) or_return)
//fmt.println(comment)
comment_len := read_data(r, u32le) or_return
comment_slice := make([]byte, comment_len)
read_slice(r, comment_slice) or_return
comment := string(comment_slice)
actual_size += 4 + comment_len
comments[i] = comment
}
flac.metadata.vorbis_comments = comments
flac.metadata.vendor_name = vendor_name
if metadata_block_header.length != u32(actual_size) {
// TODO: should this be a warning instead of an error that halts the decoding?
// I think so, the comment isn't crucial to the decoding process.
//fmt.println("Metadata header length mismatch!")
//fmt.printfln("Expected size: %d, Got %d", metadata_block_header.length, actual_size)
return flac, .Metadata_Block_Length_Mismatch
fmt.eprintln("Vorbis metadata header length mismatch!")
fmt.eprintfln("Expected size: %d, Got %d", metadata_block_header.length, actual_size)
}
// TODO: framing bit??
//fmt.println(vendor_name)
case .CUESHEET:
// TODO: save this to a struct
// + there's some CD-DA stuff that we need to consider I think
cuesheet := read_data(&r, CueSheet) or_return
cuesheet := read_data(r, CueSheet) or_return
if cuesheet.num_tracks < 1 {
// TODO: should this be a warning instead of an error that halts the decoding?
return flac, .Missing_Lead_Out_Track
}
//fmt.println(cuesheet)
for i in 0..<cuesheet.num_tracks {
track := read_data(&r, CueSheetTrack) or_return
track := read_data(r, CueSheetTrack) or_return
for i in 0..<track.num_track_index_points {
_ = read_data(&r, CueSheetTrackIndex) or_return
_ = read_data(r, CueSheetTrackIndex) or_return
//fmt.println(track_index)
}
//fmt.println(track)
}
case .PICTURE:
pic_type := PictureType(read_data(&r, u32be) or_return)
mime_len := read_data(&r, u32be) or_return
mimetype := string(read_slice(&r, auto_cast mime_len) or_return)
desc_len := read_data(&r, u32be) or_return
desc := string(read_slice(&r, auto_cast desc_len) or_return)
metadata := read_data(&r, PictureMetadata) or_return
data := read_slice(&r, auto_cast metadata.data_len) or_return
pic_type := PictureType(read_data(r, u32be) or_return)
mime_len := read_data(r, u32be) or_return
mimetype_slice := make([]byte, mime_len)
read_slice(r, mimetype_slice) or_return
mimetype := string(mimetype_slice)
desc_len := read_data(r, u32be) or_return
desc_slice := make([]byte, desc_len)
read_slice(r, desc_slice) or_return
desc := string(desc_slice)
metadata := read_data(r, PictureMetadata) or_return
data := make([]byte, metadata.data_len)
read_slice(r, data) or_return
picture := Picture{
type = pic_type,
mimetype = mimetype,
@@ -808,40 +828,334 @@ load_from_bytes :: proc(data: []byte, options := Options{}, allocator := context
append(&pictures, picture)
case .INVALID:
fmt.eprintln("Invalid block type")
bytes.reader_seek(&r, auto_cast metadata_block_header.length, .Current)
if buffered {
reader := cast(^bufio.Reader)r.data
skipped := bufio.reader_discard(reader, int(metadata_block_header.length)) or_return
} else {
reader := cast(^bytes.Reader)r.data
skipped := bytes.reader_seek(reader, i64(metadata_block_header.length), .Current) or_return
}
case:
fmt.printfln("Skipping %d bytes of Unknown metadata block", metadata_block_header.length)
bytes.reader_seek(&r, auto_cast metadata_block_header.length, .Current)
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
}
}
}
// Yucky
err = decode_frame(&r, flac)
for err == nil {
err = decode_frame(&r, flac)
flac.metadata.pictures = pictures[:]
return flac, nil
}
read_next_frame :: proc(r: ^Reader, flac: ^Flac) -> (frame: Frame, err: Error) {
//
// 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,
}
flac.metadata.pictures = pictures[:]
data := read_data(r, u16be) or_return
sync_code := data >> 2
blocking_strategy := BlockingStrategy(data & 1)
data = read_data(r, u16be) or_return
block_size := data >> 12
sample_rate := SampleRate((data >> 8) & 0xF)
channel_assignment := ChannelAssignment((data >> 4) & 0xF)
sample_size := SampleSize((data >> 1) & 7)
coded_num := decode_extended_utf8(r) or_return
if blocking_strategy == .VARIABLE {
// Sample number of first sample
// MUST NOT be larger than 36 bits unencoded or 7 bytes encoded.
// MUST be equal to the number of samples preceding the current frame. Otherwise seeking is not possible.
// TODO: also write a check for the number of samples so we'll probably keep track of how many samples we decoded
// maybe the number of decoded samples can be inferred by the number of frames ?? or just use the length of
// the decoded_samples slice.
if coded_num > 0x1000000000 {
// TODO: Sample number can't be bigger than 36 bits
}
} else {
// Frame number
// MUST NOT be larger than 31 bits unencoded or 6 bytes encoded.
// MUST be equal to the number of frames preceding the current frame. Otherwise seeking is not possible.
// TODO: also write a check for the number of frames so we'll probably keep track of how many frames we decoded.
if coded_num > 0x80000000 {
// TODO: Frame number cannot be bigger than 31 bits
}
}
actual_block_size: u16be
switch block_size {
case 1:
actual_block_size = 192
case 2..=5:
actual_block_size = 576 * auto_cast (pow2(block_size - 2))
case 6:
actual_block_size = auto_cast (read_bits(r, 8) or_return) + 1
case 7:
actual_block_size = (read_data(r, u16be) or_return) + 1
case 8..=15:
actual_block_size = 256 * auto_cast (pow2(block_size - 8))
case:
return {}, .Invalid_Block_Size
}
//if actual_block_size < 15 && !last_frame {
// TODO: block sizes less than 16 are only valid for the last frame and MUST NOT be used for any other frame.
//}
actual_sample_rate_in_Hz: u32
switch sample_rate {
case .USE_STREAMINFO:
actual_sample_rate_in_Hz = flac.metadata.sample_rate
case ._88_2kHz:
actual_sample_rate_in_Hz = 88200
case ._176_4kHz:
actual_sample_rate_in_Hz = 176400
case ._192kHz:
actual_sample_rate_in_Hz = 192000
case ._8kHz:
actual_sample_rate_in_Hz = 8000
case ._16kHz:
actual_sample_rate_in_Hz = 16000
case ._22_05kHz:
actual_sample_rate_in_Hz = 22005
case ._24kHz:
actual_sample_rate_in_Hz = 24000
case ._32kHz:
actual_sample_rate_in_Hz = 32000
case ._44_1kHz:
actual_sample_rate_in_Hz = 44100
case ._48kHz:
actual_sample_rate_in_Hz = 48000
case ._96kHz:
actual_sample_rate_in_Hz = 96000
case .USE_8_BITS_IN_kHz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_bits(r, 8) or_return) * 1000
case .USE_16_BITS_IN_Hz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_data(r, u16be) or_return)
case .USE_16_BITS_IN_TENS_OF_Hz_FROM_HEADER_END:
actual_sample_rate_in_Hz = auto_cast (read_data(r, u16be) or_return) * 10
case .INVALID: fallthrough
case:
return {}, .Invalid_Sample_Rate
}
// TODO: sample rate MUST NOT be 0 if the subframe contains audio.
// a sample rate of 0 MAY be used when non-audio is represented.
crc8_bytes := bytes.buffer_to_bytes(&crc_buffer)
frame_header_crc := u8(read_bits(r, 8) or_return)
calculated_header_crc := calculate_crc8(crc8_bytes)
if frame_header_crc != calculated_header_crc {
fmt.printfln("Expected frame header CRC: 0x%X, got: 0x%X", frame_header_crc, calculated_header_crc)
return {}, .CRC_Mismatch
}
//
// Subframes
//
bps: u8
switch sample_size {
case .USE_STREAMINFO:
bps = flac.metadata.bits_per_sample
case ._8BPS:
bps = 8
case ._12BPS:
bps = 12
case ._16BPS:
bps = 16
case ._20BPS:
bps = 20
case ._24BPS:
bps = 24
case ._32BPS:
bps = 32
}
if bps != flac.metadata.bits_per_sample {
return {}, .Bits_Per_Second_Mismatch
}
frame_channels := flac.metadata.channels
switch channel_assignment {
case .MONO:
frame_channels = 1
case ._3CHANNELS:
frame_channels = 3
case ._4CHANNELS:
frame_channels = 4
case ._5CHANNELS:
frame_channels = 5
case ._6CHANNELS:
frame_channels = 6
case ._7CHANNELS:
frame_channels = 7
case ._8CHANNELS:
frame_channels = 8
case ._2CHANNELS: fallthrough
case .STEREO_LEFT_SIDE: fallthrough
case .STEREO_SIDE_RIGHT: fallthrough
case .STEREO_MID_SIDE:
frame_channels = 2
}
if frame_channels != flac.metadata.channels {
// TODO: warning or error?
// we have a faulty file that says it has 5 channels but subframes all say they got 1
// we also have an two uncommon files with increasing and decreasing number of channels
// uncommon are supposed to be unusual but still valid FLAC files. why is that first one faulty then???
// so many questions...
}
subframes := make([][]i32, frame_channels)
defer delete(subframes)
for i in 0..<frame_channels {
frame_bps := bps
// For side channels we increase the bps by 1
// Left, mid and right channels don't need an extra bit.
// ref: https://github.com/ietf-wg-cellar/flac-specification/blob/master/rfc_backmatter.md#first-audio-frame
if (channel_assignment == .STEREO_SIDE_RIGHT && i == 0) ||
((channel_assignment == .STEREO_LEFT_SIDE || channel_assignment == .STEREO_MID_SIDE) && i == 1) {
frame_bps += 1
}
subframes[i] = decode_subframe(r, frame_bps, auto_cast actual_block_size) or_return
}
align_to_byte(r)
correlate(subframes, channel_assignment)
samples_arr := make([dynamic]i32, 0, block_size * 2)
// Write the samples interleaved.
for i in 0..<len(subframes[0]) {
for subframe, sf in subframes {
sample := subframe[i]
append(&samples_arr, sample)
}
}
for subframe in subframes {
delete(subframe)
}
frame.samples = samples_arr[:]
frame.channels = frame_channels
frame.sample_rate = actual_sample_rate_in_Hz
//
// 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 frame, nil
}
md5hash :: proc(md5_ctx: ^md5.Context, bps: u8, samples: []i32) {
for sample in samples {
switch bps {
case 1..=8:
md5.update(md5_ctx, {u8(sample)})
case 9..=16:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte})
case 17..=24:
first_byte := u8(sample & 0xFF)
second_byte := u8((sample >> 8) & 0xFF)
third_byte := u8((sample >> 16) & 0xFF)
md5.update(md5_ctx, {first_byte, second_byte, third_byte})
case 25..=32:
data := transmute([4]u8)sample
md5.update(md5_ctx, data[:])
case:
fmt.println("INVALID BPS")
os.exit(1)
}
}
}
md5sum :: proc(md5_ctx: ^md5.Context, flac: ^Flac) -> Error {
calculated_md5: [16]byte
md5.final(md5_ctx, calculated_md5[:])
flac.metadata.calculated_md5 = calculated_md5
if mem.compare(calculated_md5[:], flac.metadata.expected_md5[:]) != 0 {
return .MD5_Mismatch
}
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
}
//
// Validate the decoded audio data's md5
//
calculated_md5: [16]byte
md5.final(&md5_ctx, calculated_md5[:])
flac.metadata.calculated_md5 = calculated_md5
if mem.compare(calculated_md5[:], header.streaminfo.md5[:]) != 0 {
return flac, .MD5_Mismatch
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
@@ -849,22 +1163,71 @@ load_from_file :: proc(filename: string, options := Options{}, allocator := cont
defer delete(data)
if ok {
return load_from_bytes(data)
return load_from_bytes(data, options)
} else {
return nil, .Unable_To_Read_File
}
}
destroy :: proc(flac: ^Flac) {
// TODO: clean up the allocations
delete(flac.samples)
// TODO: I think this data gets deleted when the data from os.read_entire_file is deleted.
// Double check that and if it's true then make sure to copy this data.
// Copying small strings is fine but copying the image pixel data might be slow.
//for picture in flac.metadata.pictures {
// picture.mimetype
// picture.data
// picture.description
//}
delete(flac.metadata.pictures)
// `load_from_file_buffered` 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) {
context.allocator = allocator
file, open_err := os.open(filename)
if open_err != os.ERROR_NONE {
fmt.eprintln(open_err)
return nil, {}, .Unable_To_Read_File
}
br := new(bufio.Reader)
bufio.reader_init(br, os.stream_from_handle(file))
r = new(Reader)
r.r = bufio.reader_to_stream(br)
r.buf = 0
r.x = 0
r.n = 0
flac = read_metadata(r, true) 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 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.
*/
destroy :: proc(flac: ^Flac, r: ^Reader = nil, allocator := context.allocator) {
context.allocator = allocator
delete(flac.samples)
for picture in flac.metadata.pictures {
delete(picture.mimetype)
delete(picture.data)
delete(picture.description)
}
delete(flac.metadata.pictures)
for comment in flac.metadata.vorbis_comments {
delete(comment)
}
delete(flac.metadata.vorbis_comments)
delete(flac.metadata.vendor_name)
free(flac)
if r != nil {
br := cast(^bufio.Reader)r.data
closer, ok := io.to_closer(br.rd)
io.close(closer)
bufio.reader_destroy(br)
free(br)
free(r)
}
}