rockbox_ffi

-module(rockbox@player).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/rockbox/player.gleam").
-export([default_config/0, new/0, with_config/1, set_queue/2, enqueue/2, play/1, pause/1, toggle/1, stop/1, next/1, previous/1, skip_to/2, seek_ms/2, set_volume/2, volume/1, sample_rate/1, set_crossfade/7, set_replaygain/4, status/1]).
-export_type([player/0, config/0, status/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Queue-based player with native ReplayGain and Rockbox crossfade.\n"
    "\n"
    " A `Player` owns a live audio output device and a background engine\n"
    " thread, so it only works where an output device exists. The handle is a\n"
    " NIF resource, freed by the BEAM garbage collector (which stops playback).\n"
    "\n"
    " ReplayGain `mode` here uses the player values: 0 off, 1 track, 2 album.\n"
    " Crossfade `mode`: 0 off, 1 auto-skip, 2 manual-skip, 3 shuffle,\n"
    " 4 shuffle-or-manual, 5 always. Mix mode: 0 crossfade, 1 mix.\n"
).

-type player() :: any().

-type config() :: {config,
        integer(),
        float(),
        float(),
        integer(),
        float(),
        boolean(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer()}.

-type status() :: {status,
        binary(),
        gleam@option:option(integer()),
        integer(),
        integer(),
        integer()}.

-file("src/rockbox/player.gleam", 38).
?DOC(
    " Rockbox-default configuration (device sample rate, no crossfade,\n"
    " ReplayGain off, full volume).\n"
).
-spec default_config() -> config().
default_config() ->
    {config, 0, 4.0, 1.0, 0, +0.0, true, 0, 0, 2000, 0, 2000, 0}.

-file("src/rockbox/player.gleam", 68).
?DOC(" Create a player on the default device with default settings.\n").
-spec new() -> player().
new() ->
    rockbox_ffi_nif:player_new().

-file("src/rockbox/player.gleam", 71).
?DOC(" Create a player with explicit configuration.\n").
-spec with_config(config()) -> player().
with_config(C) ->
    rockbox_ffi_nif:player_new_with_config(
        erlang:element(2, C),
        erlang:element(3, C),
        erlang:element(4, C),
        erlang:element(5, C),
        erlang:element(6, C),
        erlang:element(7, C),
        erlang:element(8, C),
        erlang:element(9, C),
        erlang:element(10, C),
        erlang:element(11, C),
        erlang:element(12, C),
        erlang:element(13, C)
    ).

-file("src/rockbox/player.gleam", 89).
?DOC(" Replace the queue with a list of file paths.\n").
-spec set_queue(player(), list(binary())) -> nil.
set_queue(Player, Paths) ->
    rockbox_ffi_nif:player_set_queue_json(
        Player,
        erlang:iolist_to_binary(json:encode(Paths))
    ).

-file("src/rockbox/player.gleam", 94).
-spec enqueue(player(), binary()) -> nil.
enqueue(Player, Path) ->
    rockbox_ffi_nif:player_enqueue(Player, Path).

-file("src/rockbox/player.gleam", 97).
-spec play(player()) -> nil.
play(Player) ->
    rockbox_ffi_nif:player_play(Player).

-file("src/rockbox/player.gleam", 100).
-spec pause(player()) -> nil.
pause(Player) ->
    rockbox_ffi_nif:player_pause(Player).

-file("src/rockbox/player.gleam", 103).
-spec toggle(player()) -> nil.
toggle(Player) ->
    rockbox_ffi_nif:player_toggle(Player).

-file("src/rockbox/player.gleam", 106).
-spec stop(player()) -> nil.
stop(Player) ->
    rockbox_ffi_nif:player_stop(Player).

-file("src/rockbox/player.gleam", 109).
-spec next(player()) -> nil.
next(Player) ->
    rockbox_ffi_nif:player_next(Player).

-file("src/rockbox/player.gleam", 112).
-spec previous(player()) -> nil.
previous(Player) ->
    rockbox_ffi_nif:player_previous(Player).

-file("src/rockbox/player.gleam", 115).
-spec skip_to(player(), integer()) -> nil.
skip_to(Player, Index) ->
    rockbox_ffi_nif:player_skip_to(Player, Index).

-file("src/rockbox/player.gleam", 118).
-spec seek_ms(player(), integer()) -> nil.
seek_ms(Player, Ms) ->
    rockbox_ffi_nif:player_seek_ms(Player, Ms).

-file("src/rockbox/player.gleam", 121).
-spec set_volume(player(), float()) -> nil.
set_volume(Player, Volume) ->
    rockbox_ffi_nif:player_set_volume(Player, Volume).

-file("src/rockbox/player.gleam", 124).
-spec volume(player()) -> float().
volume(Player) ->
    rockbox_ffi_nif:player_volume(Player).

-file("src/rockbox/player.gleam", 127).
-spec sample_rate(player()) -> integer().
sample_rate(Player) ->
    rockbox_ffi_nif:player_sample_rate(Player).

-file("src/rockbox/player.gleam", 130).
-spec set_crossfade(
    player(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> nil.
set_crossfade(
    Player,
    Mode,
    Fade_out_delay_ms,
    Fade_out_duration_ms,
    Fade_in_delay_ms,
    Fade_in_duration_ms,
    Mix_mode
) ->
    rockbox_ffi_nif:player_set_crossfade(
        Player,
        Mode,
        Fade_out_delay_ms,
        Fade_out_duration_ms,
        Fade_in_delay_ms,
        Fade_in_duration_ms,
        Mix_mode
    ).

-file("src/rockbox/player.gleam", 141).
-spec set_replaygain(player(), integer(), float(), boolean()) -> nil.
set_replaygain(Player, Mode, Preamp_db, Prevent_clipping) ->
    rockbox_ffi_nif:player_set_replaygain(
        Player,
        Mode,
        Preamp_db,
        Prevent_clipping
    ).

-file("src/rockbox/player.gleam", 157).
-spec status_decoder() -> gleam@dynamic@decode:decoder(status()).
status_decoder() ->
    gleam@dynamic@decode:field(
        <<"state"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(State) ->
            gleam@dynamic@decode:field(
                <<"index"/utf8>>,
                gleam@dynamic@decode:one_of(
                    gleam@dynamic@decode:map(
                        {decoder, fun gleam@dynamic@decode:decode_int/1},
                        fun(Field@0) -> {some, Field@0} end
                    ),
                    [gleam@dynamic@decode:success(none)]
                ),
                fun(Index) ->
                    gleam@dynamic@decode:field(
                        <<"position_ms"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_int/1},
                        fun(Position_ms) ->
                            gleam@dynamic@decode:field(
                                <<"duration_ms"/utf8>>,
                                {decoder, fun gleam@dynamic@decode:decode_int/1},
                                fun(Duration_ms) ->
                                    gleam@dynamic@decode:field(
                                        <<"queue_len"/utf8>>,
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_int/1},
                                        fun(Queue_len) ->
                                            gleam@dynamic@decode:success(
                                                {status,
                                                    State,
                                                    Index,
                                                    Position_ms,
                                                    Duration_ms,
                                                    Queue_len}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/rockbox/player.gleam", 149).
?DOC(" A snapshot of the player's status.\n").
-spec status(player()) -> status().
status(Player) ->
    Status@1 = case gleam@dynamic@decode:run(
        json:decode(rockbox_ffi_nif:player_status_json(Player)),
        status_decoder()
    ) of
        {ok, Status} -> Status;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"rockbox/player"/utf8>>,
                        function => <<"status"/utf8>>,
                        line => 150,
                        value => _assert_fail,
                        start => 4198,
                        'end' => 4292,
                        pattern_start => 4209,
                        pattern_end => 4219})
    end,
    Status@1.