srctree

* implement queue item sort keys

* when scanning the file system, detect files that are in the database but have

been deleted from the file system

* apply loudness information to playback

* example that transcodes a list of input files

* Serving both https and http on the same port

* Automatic SSL Certificate obtaining and renewal

 

 

});

const libsoundio = soundio_dep.artifact("soundio");

 

const player = b.addModule("player", .{

.root_source_file = b.path("player/root.zig"),

.target = target,

.optimize = optimize,

});

 

const shared_server = b.addModule("shared", .{

.root_source_file = b.path("shared/root.zig"),

.target = target,

.optimize = optimize,

});

 

const shared_wasm = b.addModule("shared", .{

.root_source_file = b.path("shared/root.zig"),

.target = wasm_target,

.optimize = wasm_optimize,

});

 

player.addImport("av", ffmpeg_dep.module("av"));

 

pub const SoundIo = @import("SoundIo");

pub const acoustid = @import("acoustid.zig");

pub const musicbrainz = @import("musicbrainz.zig");

 

// Used by MusicBrainz for rate-limiting and contacting us if

// there is misbehaving code in the wild.

 

const WebSocket = @import("WebSocket.zig");

const StaticHttpFileServer = @import("StaticHttpFileServer");

const Directory = std.Build.Cache.Directory;

 

const usage =

\\Usage: groovebasin [options]

const basename_z = try arena.dupeZ(u8, entry.name);

scan.new_count += 1;

 

scan.mutex.unlock();

defer scan.mutex.lock();

 

const file_index: Db.File.Index = @enumFromInt(gop.index);

scan.thread_pool.spawnWg(&scan.wait_group, analyzeFile, .{

scan, rcd_parent, basename_z, file_index,

});

};

defer file.close();

 

std.log.err("unable to analyze '{s}': {s}", .{ basename_z, @errorName(err) });

return;

};

scan.mutex.lock();

defer scan.mutex.unlock();

 

const metadata = fileMetaData(gpa, db, file) catch |err| {

std.log.err("unable to extract metadata from '{s}': {s}", .{ basename_z, @errorName(err) });

return;

const directories = std.mem.sliceAsBytes(db.directories.keys());

const albums = std.mem.sliceAsBytes(db.albums.keys());

const string_bytes = db.string_bytes.items;

const header: DbFileHeader = .{

.magic = .v1,

.files_len = @intCast(db.files.entries.len),

.{ .base = directories.ptr, .len = directories.len },

.{ .base = albums.ptr, .len = albums.len },

.{ .base = string_bytes.ptr, .len = string_bytes.len },

};

 

var atomic_file = try install_directory.handle.atomicFile(db_path, .{});

try db.directories.entries.resize(gpa, header.directories_len);

try db.albums.entries.resize(gpa, header.albums_len);

try db.string_bytes.resize(gpa, header.string_bytes_len);

 

const files = std.mem.sliceAsBytes(db.files.keys());

const directories = std.mem.sliceAsBytes(db.directories.keys());

const albums = std.mem.sliceAsBytes(db.albums.keys());

const string_bytes = db.string_bytes.items;

 

var iovecs = [_]std.posix.iovec{

.{ .base = files.ptr, .len = files.len },

.{ .base = directories.ptr, .len = directories.len },

.{ .base = albums.ptr, .len = albums.len },

.{ .base = string_bytes.ptr, .len = string_bytes.len },

};

const amt_read = try file.readvAll(&iovecs);

if (amt_read != amt_expected) return error.UnexpectedFileSize;

 

try db.files.reIndexContext(gpa, .{});

 

const Db = @This();

const Allocator = std.mem.Allocator;

const Hash = std.hash.Wyhash;

 

files: std.ArrayHashMapUnmanaged(File, void, File.Hasher, false),

directories: std.AutoArrayHashMapUnmanaged(Path, void),

albums: std.AutoArrayHashMapUnmanaged(Album, void),

string_bytes: std.ArrayListUnmanaged(u8),

queue_items: std.ArrayHashMapUnmanaged(QueueItem, void, QueueItem.Hasher, false),

state: State,

 

/// Used for finding the index inside `string_bytes`.

std.hash_map.default_max_load_percentage,

) = .{},

 

pub const empty: Db = .{

.files = .{},

.directories = .{},

.string_table = .{},

.albums = .{},

.queue_items = .{},

.state = .{

.flags = .{

.playing = false,

buf[i] = 0;

return buf[0..i :0];

}

 

const std = @import("std");

const json = std.json;

 

pub fn main() !void {

var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);