rockbox_ffi 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f77ffe0b56e69c1749a47007c36837cd2b1a17a1c9cf36fd76a3ce42411af8
-  data.tar.gz: 620692c18aada83e7aa9b1d1e282f159fd804a9db0e2303677f825a04367fa81
+  metadata.gz: 65435e6c7a7b4ef8e59f3bc088ce2c9eb978b34d49e134c3e42413e9790bb333
+  data.tar.gz: 0d14838882902eaa6818a9726518f0c782848ad34e09b6afe6ca9ddbbf6cdd1a
 SHA512:
-  metadata.gz: 2217930492eb1d545fa86c0ffad14b90ec9144712320d03c46e595aba2fdc31d28ed1d256040d165a78c967465b3645b146117a40d45ce57ac06269d2e6da079
-  data.tar.gz: c3bed2b5f9238be0d072d46a82b5c6e697ea61dc041915389c8db7a139b3cb2d3805caff51e76571de703f3333653c5dbed0ca27f37ef7af0a4a9d9a2ca8e093
+  metadata.gz: f4275075ebc6d35b7b495dfc3a081b97960f5dc81f8f279372acf5b852fc0723776f536f9f87602811499a23d1653de9a8c5b072144444fe15dd0cd4b4dc1066
+  data.tar.gz: 5b4a35ca244aed1f570cf2d639a131eb8244645fe4ebe86513193345a95716107c72c67f7037f195e8048bff4f885c1d3c8af1fdd218ffabcf200860b841e363

data/README.md

@@ -10,6 +10,10 @@ via [`fiddle`](https://docs.ruby-lang.org/en/master/Fiddle.html) (Ruby stdlib)
 over the prebuilt `librockbox_ffi` shared library. No native extension is
 compiled — the gem `dlopen`s the shared library at load time.
 
+> 📖 **Sound settings reference** — the equalizer, tone, crossfeed, compressor
+> and other DSP controls mirror Rockbox's own. See the official
+> [Rockbox manual — Sound Settings](https://download.rockbox.org/daily/manual/rockbox-ipodvideo/rockbox-buildch6.html).
+
 ## Setup
 
 Build the shared library once (from the repo root):
@@ -95,7 +99,7 @@ ruby -Ilib examples/play.rb [path]    # play a file through the output device
 ## Interactive console
 
 ```sh
-./bin/console        # or: rake console
+bundle exec rake console        # or: ./bin/console
 ```
 
 Drops into IRB with `RockboxFFI` loaded and `FIXTURE` pointing at a sample
@@ -108,6 +112,20 @@ p.set_queue([FIXTURE]); p.play
 p.status[:state]                                  # => "playing"
 ```
 
+The console bundles `irb` + `reline`, so **Tab autocompletion** and **syntax
+highlighting** work out of the box — start typing `RockboxFFI::` and press
+`Tab`. Both are on by default; toggle per-session with `irb --noautocomplete`,
+or persist preferences in `~/.irbrc`:
+
+```ruby
+IRB.conf[:USE_AUTOCOMPLETE] = true
+IRB.conf[:USE_COLORIZE]     = true
+```
+
+> Run the console under a modern Ruby (3.x/4.x, e.g. Homebrew's
+> `/opt/homebrew/opt/ruby`). macOS system Ruby 2.6 can't build `fiddle`'s
+> native extension, so `bundle install` fails there.
+
 ## Test
 
 ```sh

data/examples/play.rb

@@ -13,9 +13,16 @@ FIXTURE = File.join(REPO, "crates", "rocksky", "fixtures", "08 - Internet Money
 file = ARGV[0] || FIXTURE
 
 player = RockboxFFI::Player.new(volume: 0.8)
-player.set_queue([file])
-player.play
+# Mutating setters return self, so the setup reads as one fluent chain.
+# DSP: Bass Boost preset + a +7 dB bass / +4 dB treble lift.
+player
+  .set_queue([file])
+  .set_eq_preset(RockboxFFI::EqPreset::BASS_BOOST)
+  .set_bass(7)
+  .set_treble(4)
+  .play
 puts "▶ playing #{file}"
+puts "eq: BassBoost preset, bass +7 dB, treble +4 dB"
 
 # Reinstall a SIGINT handler AFTER the player boots: the native audio engine
 # installs its own signal handler while starting the output device, which

data/lib/rockbox_ffi/enums.rb

@@ -18,6 +18,13 @@ module RockboxFFI
     ALBUM = 2
   end
 
+  # Values for Player#set_repeat / #repeat.
+  module RepeatMode
+    OFF = 0
+    ONE = 1
+    ALL = 2
+  end
+
   module CrossfadeMode
     OFF = 0
     AUTO_SKIP = 1
@@ -32,6 +39,19 @@ module RockboxFFI
     MIX = 1
   end
 
+  # Where inserted tracks land in the queue (Player#insert / #import_m3u).
+  # INDEX (7) uses the explicit +index+ argument.
+  module InsertPosition
+    PREPEND = 0
+    INSERT = 1
+    INSERT_NEXT = 2
+    INSERT_LAST = 3
+    INSERT_SHUFFLED = 4
+    INSERT_LAST_SHUFFLED = 5
+    REPLACE = 6
+    INDEX = 7
+  end
+
   module ChannelConfig
     STEREO = 0
     MONO = 1
@@ -41,4 +61,47 @@ module RockboxFFI
     KARAOKE = 5
     SWAP = 6
   end
+
+  # Built-in EQ presets for Player#set_eq_preset.
+  module EqPreset
+    FLAT = 0
+    ACOUSTIC = 1
+    BASS_BOOST = 2
+    BASS_REDUCER = 3
+    CLASSICAL = 4
+    DANCE = 5
+    DEEP = 6
+    ELECTRONIC = 7
+    HIP_HOP = 8
+    JAZZ = 9
+    LATIN = 10
+    LOUDNESS = 11
+    LOUNGE = 12
+    PIANO = 13
+    POP = 14
+    RNB = 15
+    ROCK = 16
+    SMALL_SPEAKERS = 17
+    TREBLE_BOOST = 18
+    TREBLE_REDUCER = 19
+    VOCAL_BOOST = 20
+  end
+
+  # Crossfeed mode for Player#set_crossfeed.
+  module CrossfeedMode
+    OFF = 0
+    MEIER = 1
+    CUSTOM = 2
+  end
+
+  # Channel mode for Player#set_channel_mode.
+  module ChannelMode
+    STEREO = 0
+    MONO = 1
+    CUSTOM = 2
+    MONO_LEFT = 3
+    MONO_RIGHT = 4
+    KARAOKE = 5
+    SWAP = 6
+  end
 end

data/lib/rockbox_ffi/ffi.rb

@@ -101,9 +101,12 @@ module RockboxFFI
     # ---- player -------------------------------------------------------
     extern "void* rb_player_new()"
     extern "void* rb_player_new_with_config(uint32_t, float, float, int32_t, float, bool, int32_t, uint32_t, uint32_t, uint32_t, uint32_t, int32_t)"
+    extern "void* rb_player_new_with_config_ex(uint32_t, float, float, int32_t, float, bool, int32_t, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, void*, uint32_t)"
     extern "void rb_player_free(void*)"
     extern "void rb_player_set_queue_json(void*, void*)"
     extern "void rb_player_enqueue(void*, void*)"
+    extern "void rb_player_insert_json(void*, void*, int32_t, size_t)"
+    extern "void* rb_player_queue_json(void*)"
     extern "void rb_player_play(void*)"
     extern "void rb_player_pause(void*)"
     extern "void rb_player_toggle(void*)"
@@ -118,6 +121,46 @@ module RockboxFFI
     extern "float rb_player_volume(void*)"
     extern "uint32_t rb_player_sample_rate(void*)"
     extern "void* rb_player_status_json(void*)"
+    extern "void rb_player_set_shuffle(void*, bool)"
+    extern "bool rb_player_is_shuffle_enabled(void*)"
+    extern "void rb_player_set_repeat(void*, int32_t)"
+    extern "int32_t rb_player_repeat(void*)"
+
+    # ---- player DSP ---------------------------------------------------
+    extern "void rb_player_set_eq_enabled(void*, bool)"
+    extern "bool rb_player_is_eq_enabled(void*)"
+    extern "void rb_player_set_eq_band(void*, size_t, int32_t, float, float)"
+    extern "void rb_player_set_eq_precut(void*, float)"
+    extern "void rb_player_set_eq_preset(void*, int32_t)"
+    extern "void rb_player_set_tone(void*, int32_t, int32_t, int32_t, int32_t)"
+    extern "void rb_player_set_bass(void*, int32_t)"
+    extern "void rb_player_set_treble(void*, int32_t)"
+    extern "void rb_player_set_bass_cutoff(void*, int32_t)"
+    extern "void rb_player_set_treble_cutoff(void*, int32_t)"
+    extern "void rb_player_set_crossfeed(void*, int32_t, int32_t, int32_t, int32_t, int32_t)"
+    extern "void rb_player_set_bass_enhancement(void*, int32_t, int32_t)"
+    extern "void rb_player_set_fatigue_reduction(void*, int32_t)"
+    extern "void rb_player_set_surround(void*, int32_t, int32_t, int32_t, int32_t)"
+    extern "void rb_player_set_channel_mode(void*, int32_t)"
+    extern "void rb_player_set_stereo_width(void*, int32_t)"
+    extern "void rb_player_set_compressor(void*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t)"
+    extern "void rb_player_set_dither(void*, bool)"
+    extern "void rb_player_set_pitch(void*, int32_t)"
+    extern "void* rb_player_dsp_settings_json(void*)"
+
+    # ---- resume -------------------------------------------------------
+    extern "void* rb_player_resume(void*)"
+    extern "void rb_player_save_resume(void*)"
+    extern "void rb_player_clear_resume(void*)"
+    extern "void* rb_load_resume_json(void*)"
+
+    # ---- m3u / m3u8 playlists -----------------------------------------
+    extern "void* rb_player_import_m3u(void*, void*, int32_t, size_t)"
+    extern "void* rb_player_load_m3u(void*, void*)"
+    extern "int32_t rb_player_export_m3u(void*, void*)"
+    extern "void* rb_m3u_read_json(void*)"
+    extern "int32_t rb_m3u_write_json(void*, void*)"
+    extern "bool rb_is_url(void*)"
   end
 
   # true/false → 1/0 for the ABI's `bool` (declared as int above).

data/lib/rockbox_ffi/player.rb

@@ -11,6 +11,11 @@ module RockboxFFI
   #
   # ReplayGain +mode+ here uses the *player* values: 0 off, 1 track, 2 album
   # (see ReplayGainMode) — distinct from the DSP encoding.
+  #
+  # Mutating setters (queue, transport, settings, DSP) return +self+ so calls
+  # can be fluently chained, e.g.
+  #   player.set_queue([file]).set_shuffle(true).play
+  # Getters/queries and lifecycle methods keep their own return values.
   class Player
     DEFAULT_CONFIG = {
       sample_rate: 0, # 0 => device default
@@ -24,7 +29,9 @@ module RockboxFFI
       fade_out_duration_ms: 2000,
       fade_in_delay_ms: 0,
       fade_in_duration_ms: 2000,
-      mix_mode: MixMode::CROSSFADE
+      mix_mode: MixMode::CROSSFADE,
+      resume_file: nil, # an .m3u8 to auto-persist queue + position to
+      resume_save_interval_ms: 0 # 0 => 5 s default
     }.freeze
 
     # Open a Player; if a block is given, close it automatically afterwards.
@@ -47,16 +54,19 @@ module RockboxFFI
     end
 
     # Create a player with configuration overrides (see DEFAULT_CONFIG keys).
-    # sample_rate: 0 means the device default.
+    # sample_rate: 0 means the device default. Passing +resume_file:+ enables
+    # auto-persisting the queue + exact position to that .m3u8 file.
     def initialize(**opts)
       c = DEFAULT_CONFIG.merge(opts)
-      ptr = Lib.rb_player_new_with_config(
+      resume_file = c[:resume_file].nil? ? nil : c[:resume_file].to_s
+      ptr = Lib.rb_player_new_with_config_ex(
         Integer(c[:sample_rate]), Float(c[:buffer_seconds]), Float(c[:volume]),
         Integer(c[:replaygain_mode]), Float(c[:replaygain_preamp_db]),
         RockboxFFI.b(c[:replaygain_prevent_clipping]), Integer(c[:crossfade_mode]),
         Integer(c[:fade_out_delay_ms]), Integer(c[:fade_out_duration_ms]),
         Integer(c[:fade_in_delay_ms]), Integer(c[:fade_in_duration_ms]),
-        Integer(c[:mix_mode])
+        Integer(c[:mix_mode]), resume_file,
+        Integer(c[:resume_save_interval_ms])
       )
       init_ptr(ptr)
     end
@@ -80,50 +90,83 @@ module RockboxFFI
     private_class_method :finalizer
 
     # -- queue ------------------------------------------------------------
+    # Replace the queue. Each entry may be a local file path, an http(s)://
+    # URL to a finite remote file, or a live-radio / streaming URL.
     def set_queue(paths)
       Lib.rb_player_set_queue_json(@ptr, JSON.generate(Array(paths).map(&:to_s)))
+      self
     end
 
+    # Append one track to the queue. +path+ may be a local file path, an
+    # http(s):// URL to a finite remote file, or a live-radio / streaming URL.
     def enqueue(path)
       Lib.rb_player_enqueue(@ptr, path.to_s)
+      self
+    end
+
+    # Insert +paths+ (a path/URL or Array of them) into the queue at
+    # +position+ (see InsertPosition). +index+ is only used when position is
+    # InsertPosition::INDEX (7).
+    def insert(paths, position, index = 0)
+      Lib.rb_player_insert_json(
+        @ptr, JSON.generate(Array(paths).map(&:to_s)), Integer(position), Integer(index)
+      )
+      self
+    end
+
+    # The current queue as an Array of String paths/URLs.
+    def queue
+      s = RockboxFFI.take_string(Lib.rb_player_queue_json(@ptr))
+      return [] if s.nil?
+
+      JSON.parse(s)
     end
 
     # -- transport --------------------------------------------------------
     def play
       Lib.rb_player_play(@ptr)
+      self
     end
 
     def pause
       Lib.rb_player_pause(@ptr)
+      self
     end
 
     def toggle
       Lib.rb_player_toggle(@ptr)
+      self
     end
 
     def stop
       Lib.rb_player_stop(@ptr)
+      self
     end
 
     def next
       Lib.rb_player_next(@ptr)
+      self
     end
 
     def previous
       Lib.rb_player_previous(@ptr)
+      self
     end
 
     def skip_to(index)
       Lib.rb_player_skip_to(@ptr, Integer(index))
+      self
     end
 
     def seek_ms(ms)
       Lib.rb_player_seek_ms(@ptr, Integer(ms))
+      self
     end
 
     # -- settings ---------------------------------------------------------
     def set_volume(vol)
       Lib.rb_player_set_volume(@ptr, Float(vol))
+      self
     end
 
     def volume
@@ -141,11 +184,173 @@ module RockboxFFI
         @ptr, Integer(mode), Integer(fade_out_delay_ms), Integer(fade_out_duration_ms),
         Integer(fade_in_delay_ms), Integer(fade_in_duration_ms), Integer(mix_mode)
       )
+      self
     end
 
     # mode: see ReplayGainMode (OFF=0, TRACK=1, ALBUM=2).
     def set_replaygain(mode, preamp_db, prevent_clipping)
       Lib.rb_player_set_replaygain(@ptr, Integer(mode), Float(preamp_db), RockboxFFI.b(prevent_clipping))
+      self
+    end
+
+    # Enable/disable shuffle.
+    def set_shuffle(enabled)
+      Lib.rb_player_set_shuffle(@ptr, RockboxFFI.b(enabled))
+      self
+    end
+
+    # Whether shuffle is currently enabled.
+    def shuffle_enabled?
+      !Lib.rb_player_is_shuffle_enabled(@ptr).zero?
+    end
+
+    # Set the repeat mode (see RepeatMode: OFF=0, ONE=1, ALL=2).
+    def set_repeat(mode)
+      Lib.rb_player_set_repeat(@ptr, Integer(mode))
+      self
+    end
+
+    # The current repeat mode as an Integer (see RepeatMode).
+    def repeat
+      Lib.rb_player_repeat(@ptr)
+    end
+
+    # -- DSP --------------------------------------------------------------
+    # Enable/disable the parametric equalizer.
+    def set_eq_enabled(enabled)
+      Lib.rb_player_set_eq_enabled(@ptr, RockboxFFI.b(enabled))
+      self
+    end
+
+    # Whether the parametric equalizer is currently enabled.
+    def eq_enabled?
+      !Lib.rb_player_is_eq_enabled(@ptr).zero?
+    end
+
+    # Configure one EQ band: +band+ index, +cutoff_hz+ center frequency,
+    # +q+ factor, +gain_db+ gain in dB.
+    def set_eq_band(band, cutoff_hz, q, gain_db)
+      Lib.rb_player_set_eq_band(@ptr, Integer(band), Integer(cutoff_hz), Float(q), Float(gain_db))
+      self
+    end
+
+    # Global EQ pre-cut in dB.
+    def set_eq_precut(db)
+      Lib.rb_player_set_eq_precut(@ptr, Float(db))
+      self
+    end
+
+    # Apply a built-in EQ preset (see EqPreset).
+    def set_eq_preset(preset)
+      Lib.rb_player_set_eq_preset(@ptr, Integer(preset))
+      self
+    end
+
+    # Bass/treble tone controls with explicit cutoff frequencies.
+    def set_tone(bass_db, treble_db, bass_cutoff_hz, treble_cutoff_hz)
+      Lib.rb_player_set_tone(
+        @ptr, Integer(bass_db), Integer(treble_db),
+        Integer(bass_cutoff_hz), Integer(treble_cutoff_hz)
+      )
+      self
+    end
+
+    # Bass gain in dB.
+    def set_bass(bass_db)
+      Lib.rb_player_set_bass(@ptr, Integer(bass_db))
+      self
+    end
+
+    # Treble gain in dB.
+    def set_treble(treble_db)
+      Lib.rb_player_set_treble(@ptr, Integer(treble_db))
+      self
+    end
+
+    # Bass tone-control cutoff frequency in Hz.
+    def set_bass_cutoff(hz)
+      Lib.rb_player_set_bass_cutoff(@ptr, Integer(hz))
+      self
+    end
+
+    # Treble tone-control cutoff frequency in Hz.
+    def set_treble_cutoff(hz)
+      Lib.rb_player_set_treble_cutoff(@ptr, Integer(hz))
+      self
+    end
+
+    # Crossfeed for headphone listening. +mode+ (see CrossfeedMode: OFF=0,
+    # MEIER=1, CUSTOM=2), plus direct/cross/high-frequency gains and the
+    # high-frequency cutoff (Hz) used in CUSTOM mode.
+    def set_crossfeed(mode, direct_gain, cross_gain, hf_gain, hf_cutoff)
+      Lib.rb_player_set_crossfeed(
+        @ptr, Integer(mode), Integer(direct_gain), Integer(cross_gain),
+        Integer(hf_gain), Integer(hf_cutoff)
+      )
+      self
+    end
+
+    # Bass enhancement: +strength+ and +precut+ (in dB).
+    def set_bass_enhancement(strength, precut)
+      Lib.rb_player_set_bass_enhancement(@ptr, Integer(strength), Integer(precut))
+      self
+    end
+
+    # Listening-fatigue reduction (treble roll-off): +strength+.
+    def set_fatigue_reduction(strength)
+      Lib.rb_player_set_fatigue_reduction(@ptr, Integer(strength))
+      self
+    end
+
+    # Surround effect: delay (ms), balance, low/high cutoff frequencies (Hz).
+    def set_surround(delay_ms, balance, cutoff_low_hz, cutoff_high_hz)
+      Lib.rb_player_set_surround(
+        @ptr, Integer(delay_ms), Integer(balance),
+        Integer(cutoff_low_hz), Integer(cutoff_high_hz)
+      )
+      self
+    end
+
+    # Channel mode (see ChannelMode).
+    def set_channel_mode(mode)
+      Lib.rb_player_set_channel_mode(@ptr, Integer(mode))
+      self
+    end
+
+    # Stereo width as a percentage.
+    def set_stereo_width(percent)
+      Lib.rb_player_set_stereo_width(@ptr, Integer(percent))
+      self
+    end
+
+    # Dynamic-range compressor: threshold (dB), makeup gain, ratio, knee,
+    # attack (ms), release (ms).
+    def set_compressor(threshold_db, makeup_gain, ratio, knee, attack_ms, release_ms)
+      Lib.rb_player_set_compressor(
+        @ptr, Integer(threshold_db), Integer(makeup_gain), Integer(ratio),
+        Integer(knee), Integer(attack_ms), Integer(release_ms)
+      )
+      self
+    end
+
+    # Enable/disable output dithering.
+    def set_dither(enabled)
+      Lib.rb_player_set_dither(@ptr, RockboxFFI.b(enabled))
+      self
+    end
+
+    # Pitch shift ratio.
+    def set_pitch(ratio)
+      Lib.rb_player_set_pitch(@ptr, Integer(ratio))
+      self
+    end
+
+    # A snapshot of the current DSP settings as a Hash with symbol keys.
+    def dsp_settings
+      s = RockboxFFI.take_string(Lib.rb_player_dsp_settings_json(@ptr))
+      raise "rb_player_dsp_settings_json returned NULL" if s.nil?
+
+      JSON.parse(s, symbolize_names: true)
     end
 
     # -- status -----------------------------------------------------------
@@ -157,6 +362,51 @@ module RockboxFFI
       JSON.parse(s, symbolize_names: true)
     end
 
+    # -- resume -----------------------------------------------------------
+    # Restore the queue + exact position from the resume file (does NOT
+    # auto-play). Returns a Hash {tracks:, index:, elapsed_ms:} or nil.
+    def resume
+      s = RockboxFFI.take_string(Lib.rb_player_resume(@ptr))
+      return nil if s.nil?
+
+      JSON.parse(s, symbolize_names: true)
+    end
+
+    # Force-persist the current queue + position to the resume file now.
+    def save_resume
+      Lib.rb_player_save_resume(@ptr)
+    end
+
+    # Delete the resume file.
+    def clear_resume
+      Lib.rb_player_clear_resume(@ptr)
+    end
+
+    # -- m3u / m3u8 playlists ---------------------------------------------
+    # Import a playlist file into the queue at +position+ (see InsertPosition;
+    # +index+ only used for INDEX). Returns the imported paths as an Array.
+    def import_m3u(path, position, index = 0)
+      s = RockboxFFI.take_string(
+        Lib.rb_player_import_m3u(@ptr, path.to_s, Integer(position), Integer(index))
+      )
+      return [] if s.nil?
+
+      JSON.parse(s)
+    end
+
+    # Replace the queue with a playlist file. Returns the loaded paths as an Array.
+    def load_m3u(path)
+      s = RockboxFFI.take_string(Lib.rb_player_load_m3u(@ptr, path.to_s))
+      return [] if s.nil?
+
+      JSON.parse(s)
+    end
+
+    # Export the current queue to an .m3u8 (atomic). Returns true on success.
+    def export_m3u(path)
+      Lib.rb_player_export_m3u(@ptr, path.to_s).zero?
+    end
+
     private
 
     def init_ptr(ptr)

data/lib/rockbox_ffi/version.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module RockboxFFI
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

data/lib/rockbox_ffi.rb

@@ -12,9 +12,41 @@ require "rockbox_ffi/metadata"
 require "rockbox_ffi/dsp"
 require "rockbox_ffi/player"
 
+require "json"
+
 module RockboxFFI
   # ABI major version of the loaded library (bumped on breaking changes).
   def self.abi_version
     Lib.rb_ffi_abi_version
   end
+
+  # Peek at a resume file without a Player. Returns a Hash
+  # {tracks:, index:, elapsed_ms:} or nil if the file is absent/invalid.
+  def self.load_resume(path)
+    s = take_string(Lib.rb_load_resume_json(path.to_s))
+    return nil if s.nil?
+
+    JSON.parse(s, symbolize_names: true)
+  end
+
+  # Parse a playlist (.m3u / .m3u8) into an Array of Hashes
+  # {path:, duration_ms:, title:}. Returns nil on failure.
+  def self.m3u_read(path)
+    s = take_string(Lib.rb_m3u_read_json(path.to_s))
+    return nil if s.nil?
+
+    JSON.parse(s, symbolize_names: true)
+  end
+
+  # Write +paths+ (a path/URL or Array of them) as an .m3u8. Returns true on
+  # success.
+  def self.m3u_write(path, paths)
+    Lib.rb_m3u_write_json(path.to_s, JSON.generate(Array(paths).map(&:to_s))).zero?
+  end
+
+  # Whether +s+ looks like an http(s):// URL.
+  def self.is_url?(s)
+    r = Lib.rb_is_url(s.to_s)
+    r == true || r == 1
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rockbox_ffi
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Tsiry Sandratraina
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-09 00:00:00.000000000 Z
+date: 2026-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fiddle