aboutsummaryrefslogtreecommitdiff
path: root/src/main.zig
blob: ec79ce6ff18c96e842739272f747576e441478ca (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
const sdl3 = @import("sdl3");
const std = @import("std");
const posix = std.posix;
const io = std.Io;

/// How long to sleep between event-loop iterations, in milliseconds.
const poll_interval_ms = 50;

const autumn_trees = "assets/chico.wav";

// isso pra sistemas linux
const STDIN_FD: posix.fd_t = 0;

pub fn main(
    init: std.process.Init,
) !void {
    defer sdl3.shutdown();

    const log_app = sdl3.log.Category.application;

    try sdl3.init(.{ .audio = true });
    defer sdl3.quit(.{ .audio = true });

    try sdl3.mixer.init();
    defer sdl3.mixer.quit();

    const compiled_version = sdl3.mixer.Version.compiled_against;
    const linked_version = sdl3.mixer.Version.get();
    try log_app.logInfo("Using SDL_mixer {d}.{d}.{d}", .{ compiled_version.getMajor(), compiled_version.getMinor(), compiled_version.getMicro() });
    try log_app.logInfo("Linked against SDL_mixer {d}.{d}.{d}", .{ linked_version.getMajor(), linked_version.getMinor(), linked_version.getMicro() });

    // Open a mixer on the default playback device, letting SDL mixer pick the format.
    const mixer = try sdl3.mixer.Mixer.initDevice(sdl3.audio.Device.default_playback, null);
    defer mixer.deinit();

    const wav = try sdl3.mixer.Audio.init(mixer, autumn_trees, true);
    defer wav.deinit();

    const metadata = try wav.getProperties();
    const titulo = metadata.title orelse "";
    const artista = metadata.artist orelse "";
    const album = metadata.album orelse "";

    const track = try sdl3.mixer.Track.init(mixer);
    defer track.deinit();
    try track.setAudio(wav);

    try track.play(.{});

    // estado original do terminal
    const termios_ro = try posix.tcgetattr(STDIN_FD);

    // ativa modo `raw` do terminal
    var termios_rw = termios_ro;

    termios_rw.oflag.OPOST = false;

    termios_rw.iflag.IXON = false;
    termios_rw.iflag.ICRNL = false;

    termios_rw.lflag.ECHO = false;
    termios_rw.lflag.ICANON = false;
    termios_rw.lflag.ISIG = false;
    termios_rw.lflag.IEXTEN = false;

    try posix.tcsetattr(STDIN_FD, .FLUSH, termios_rw);

    // var stdout = io.File.stdout();
    var stdin = io.File.stdin();

    var quit_app = false;
    while (!quit_app) {
        // renderiza interface
        // var w_buffer: [256]u8 = undefined;
        // var stdout_writer = stdout.writer(init.io, &w_buffer);
        // const writer_interface = &stdout_writer.interface;
        // limpa o que estava no buffer anteriormente
        // try writer_interface.flush();
        // try writer_interface.print("<BARRA>\n<MÚSICA> | <ARTISTA> | <ÁLBUM>\n", .{});
        try log_app.logInfo("<BARRA>\n{s} | {s} | {s}\n", .{titulo, artista, album});

        // lê comandos
        var r_buffer: [64]u8 = undefined;
        var stdin_reader = stdin.reader(init.io, &r_buffer);
        const reader_interface = &stdin_reader.interface;
        // lê apenas um caractere da stdin
        const char = try reader_interface.peek(1);
        if (std.mem.eql(u8, char, " ")) {
            if (track.isPaused()) {
                try track.resumeTrack();
            } else {
                try track.pause();
            }
        } else if (std.mem.eql(u8, char, "q")) {
            quit_app = true;
        }

        sdl3.timer.delayMilliseconds(poll_interval_ms);
    }

    // restaura terminal pro estado original ao final
    try posix.tcsetattr(0, .FLUSH, termios_ro);

    try track.stop(0);
    try log_app.logInfo("Quit.", .{});
}