mpv-ipc 5.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e7d0c0d23fc7f57e54fa0c0425686e20c6fd08c0002ca1c3569ab9d7aabab68
+  data.tar.gz: d63982804801f0831ab131ce860e601c2ae7908f30d79c2f3781d256da50c9b9
+SHA512:
+  metadata.gz: c00ca5d89ffc2343b378ccee7a3013847d931b17b8cbbf0743c517b3825b20c2c4df13660d6eb4db99d9e63ef0005287f963df62d85eb577e9241d51c341359f
+  data.tar.gz: 28388a0ae21f8d550d1d42d5974db247bce0f28ce6efdeed94f09cd9f8e1813ac175adf0b8d438aef8af0ee8ddb8cfb3425886cdd72165fb586d795640c16f03

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 William Woodruff <william @ tuffbizz.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+mpv-ipc
+=======
+
+Start or connect to the mpv media player and control it via IPC.
+
+A Ruby library that provides a simple interface for interacting with
+[mpv](https://mpv.io) via its JSON IPC protocol.
+
+This gem supports multiple usage patterns:
+- starting and managing an mpv instance (IPC server + connected client),
+- connecting to an already running mpv process as a plain IPC client,
+- writing Ruby-based mpv scripts that are automatically launched at startup.
+
+### Installation
+
+```bash
+$ gem install mpv-ipc
+```
+
+This gem requires [mpv](https://mpv.io) to be installed separately.
+
+### Usage
+
+For full documentation, please see the [RubyDocs](https://www.rubydoc.info/gems/mpv-ipc).
+
+Check out mpv's property [documentation](https://mpv.io/manual/stable/#properties)
+for more details on supported properties and their usage.
+
+#### Standalone session
+
+This gem can be used to create a standalone mpv session, which starts
+and manages its own mpv instance and communicates with it via JSON IPC.
+
+```ruby
+require "mpv_ipc"
+
+# Initialize a new mpv session with both a Server and a Client
+mpv = MPV::Session.new
+
+# Observe changes in properties
+mpv.observe_property("volume") do |prop_event|
+  puts "Volume changed to: #{prop_event.data}"
+end
+
+# Interact with mpv
+mpv.get_property "pause"
+mpv.set_property "volume", 50.0
+mpv.command "loadfile", "video.mkv"
+
+sleep 10
+
+# Exit mpv gracefully
+mpv.quit!
+```
+
+Internally, `MPV::Session` instantiates and wires together an `MPV::Server`
+and an `MPV::Client`.
+
+#### IPC client
+
+Alternatively, the library can be used as a plain JSON IPC client to connect
+to an already running mpv process. This makes it suitable for both:
+- external control tools that attach to an existing mpv instance, and
+- scripts started and managed by mpv, communicating with it over IPC.
+
+To use the gem as an mpv script, place the Ruby file in mpv's script configuration
+directory (e.g. `$HOME/.config/mpv/scripts`) with a `.run` suffix.
+It will automatically start the script at launch and provide the script
+with an IPC connection via `--mpv-ipc-fd`.
+
+```ruby
+#!/usr/bin/ruby
+
+require "mpv_ipc/client"
+
+# Connect to an existing mpv process via its IPC socket
+mpv = MPV::Client.new("/var/run/mpv.socket")
+
+# Or initialize a Client using the IPC connection provided by mpv
+# when running as an mpv-managed script (via --mpv-ipc-fd)
+# mpv = MPV::Client.script
+
+# Add a listener for the "seek" event
+mpv.register_event_listener("seek") do |event|
+  pos = mpv.get_property!("percent-pos")
+  mpv.command("show-text", "Pos: %.2f%%" % pos)
+end
+
+# Register keybindings for zooming
+mpv.register_keybindings("+", "-") do |key_event|
+  if key_event.hold?
+    zoom = mpv.get_property!("video-zoom")
+    mpv.set_property!("video-zoom", zoom.send(key_event.key, 0.1).clamp(-4, 4))
+  end
+end
+
+# Observe changes in the "video-zoom" property
+mpv.observe_property("video-zoom") do |prop_event|
+  mpv.command("show-text", "Zoom: %.0f%%" % (2 ** prop_event.data * 100))
+end
+
+# Wait until the connection closes
+mpv.wait
+```
+
+All event-related callbacks are executed sequentially on the same dedicated
+internal thread to preserve event order. Handlers that may take longer
+can delegate their work to another thread or a new one.
+
+#### OSD messages
+
+For more advanced overlays, you can also create and edit styled OSD messages
+using the bundled Ass text helpers, with custom fonts, colors, text styles,
+alignment, and other formatting.
+
+```ruby
+title = Ass::Span.new("Now playing")
+title.bold.size(28).color(:gold).outline(2, :black)
+
+body = Ass::Span.new("Interstellar")
+body.italic.size(24).color(:white).outline(2, :black)
+
+text = Ass::Text.new(title, "\n", body).align(:top_right)
+id = mpv.create_osd_message(text)
+
+body.content = "Inception"
+mpv.edit_osd_message(id, text)
+```
+
+### Compatibility
+
+This library currently targets Unix-like systems and has been tested on Linux.
+Some features depend on Unix-specific IPC and process behavior, so Windows
+compatibility has not been implemented or tested yet.
+
+This gem is based on the original [ruby-mpv](https://github.com/woodruffw/ruby-mpv)
+project and the extended [fork](https://github.com/pigoz/ruby-mpv).
+
+Although this implementation differs from the original,
+it remains partially compatible with its API.

data/lib/mpv_ass/color.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ass
+  # Represents an ASS color.
+  class Color
+    PRESETS = {
+      # grayscale
+      black:     [  0,   0,   0],
+      carbon:    [ 64,  64,  64],
+      gray:      [128, 128, 128],
+      silver:    [192, 192, 192],
+      white:     [255, 255, 255],
+
+      # primary
+      red:       [255,   0,   0],
+      green:     [  0, 255,   0],
+      blue:      [  0,   0, 255],
+
+      # secondary
+      yellow:    [255, 255,   0],
+      magenta:   [255,   0, 255],
+      cyan:      [  0, 255, 255],
+
+      # vivid
+      orange:    [255, 128,   0],
+      gold:      [255, 192,   0],
+      purple:    [128,   0, 255],
+      turquoise: [  0, 255, 128],
+
+      # pastel
+      pink:      [255, 128, 255],
+      sky:       [128, 255, 255],
+      mint:      [128, 255, 128],
+      vanilla:   [255, 255, 128],
+      coral:     [255, 128, 128],
+
+      # shade
+      maroon:    [128,   0,   0],
+      forest:    [  0, 128,   0],
+      navy:      [  0,   0, 128],
+      teal:      [  0, 128, 128],
+      plum:      [128,   0, 128],
+      olive:     [128, 128,   0],
+      brown:     [128,  64,   0],
+    }.freeze
+
+    # Gets the RGBA component values.
+    # @return [Array<Integer>] red, green, blue and alpha codes
+    attr_reader :codes
+    alias_method :to_a, :codes
+
+    # Creates an ASS::Color.
+    # @param color [Array<Integer>, Symbol] preset symbol or custom color codes
+    #   Color codes are given as [red, green, blue, alpha] in the range 0..255.
+    #   Alpha defaults to 0, meaning fully opaque, while 255 means fully transparent.
+    def initialize(color)
+      set(color)
+    end
+
+    # Changes the color value.
+    # @param color [Array<Integer>, Symbol] preset symbol or custom color codes
+    #   Color codes are given as [red, green, blue, alpha] in the range 0..255.
+    #   Alpha defaults to 0, meaning fully opaque, while 255 means fully transparent.
+    # @return [self]
+    def set(color)
+      color = PRESETS.fetch(color) if color.is_a?(Symbol)
+      @codes = color.to_a.values_at(0..3).map{ |code| code.to_i.clamp(0, 255) }
+      self
+    end
+
+    # Changes the red value.
+    # @param code [Integer] red channel value in the range 0..255
+    # @return [self]
+    def red(code)
+      @codes[0] = code.to_i.clamp(0, 255)
+      self
+    end
+
+    # Changes the green value.
+    # @param code [Integer] green channel value in the range 0..255
+    # @return [self]
+    def green(code)
+      @codes[1] = code.to_i.clamp(0, 255)
+      self
+    end
+
+    # Changes the blue value.
+    # @param code [Integer] blue channel value in the range 0..255
+    # @return [self]
+    def blue(code)
+      @codes[2] = code.to_i.clamp(0, 255)
+      self
+    end
+
+    # Changes the alpha value.
+    # @param code [Integer] alpha channel value in the range 0..255
+    #   0 means fully opaque, while 255 means fully transparent
+    # @return [self]
+    def alpha(code)
+      @codes[3] = code.to_i.clamp(0, 255)
+      self
+    end
+
+    # Converts the color to ASS syntax.
+    # @return [String] ASS color representation
+    def to_script
+      codes = @codes.last.zero? ? @codes[0..-2] : @codes
+      "&H#{codes.reverse.map{ |code| "%02X" % code }.join}&"
+    end
+  end
+end

data/lib/mpv_ass/span.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "color"
+
+module Ass
+  # Represents a styled ASS text fragment.
+  class Span
+    # Gets or changes the plain text fragment content.
+    # @return [String] plain text content
+    attr_accessor :content
+    alias_method :to_s, :content
+
+    # Creates an ASS::Span text fragment.
+    # @param content [String] plain text content
+    def initialize(content=nil)
+      @content = content
+      @tags = {}
+    end
+
+    # Sets the font name.
+    # @param name [String] font family name
+    # @return [self]
+    def font(name)
+      @tags["fn"] = name.to_s
+      self
+    end
+
+    # Sets bold text rendering.
+    # @param value [Boolean] whether bold styling is enabled
+    # @return [self]
+    def bold(value=true)
+      @tags["b"] = value ? 1 : 0
+      self
+    end
+
+    # Sets italic text rendering.
+    # @param value [Boolean] whether italic styling is enabled
+    # @return [self]
+    def italic(value=true)
+      @tags["i"] = value ? 1 : 0
+      self
+    end
+
+    # Sets underline text rendering.
+    # @param value [Boolean] whether underline styling is enabled
+    # @return [self]
+    def underline(value=true)
+      @tags["u"] = value ? 1 : 0
+      self
+    end
+
+    # Sets strikethrough text rendering.
+    # @param value [Boolean] whether strikethrough styling is enabled
+    # @return [self]
+    def strike(value=true)
+      @tags["s"] = value ? 1 : 0
+      self
+    end
+
+    # Sets the font size.
+    # @param value [Integer] font size
+    # @return [self]
+    def size(value)
+      @tags["fs"] = value.to_i
+      self
+    end
+
+    # Sets the font color.
+    # @param value [Ass::Color, Array<Integer>, Symbol] font color
+    # @return [self]
+    def color(value)
+      @tags["1c"] = value.is_a?(Color) ? value : Color.new(value)
+      self
+    end
+
+    # Sets the outline thickness and color.
+    # @param size [Integer] outline thickness value
+    # @param color [Ass::Color, Array<Integer>, Symbol] outline color value
+    # @return [self]
+    def outline(size, color)
+      @tags["3c"] = color.is_a?(Color) ? color : Color.new(color)
+      @tags["bord"] = size.to_i
+      self
+    end
+
+    # Sets the shadow size.
+    # @param size [Integer] shadow size value
+    # @return [self]
+    def shadow(size)
+      @tags["shad"] = size.to_i
+      self
+    end
+
+    # Sets the blur strength.
+    # @param strength [Numeric] blur strength value
+    # @return [self]
+    def blur(strength)
+      @tags["blur"] = strength.to_f
+      self
+    end
+
+    # Removes all style tags.
+    # @return [self]
+    def bare
+      @tags.clear
+      self
+    end
+
+    # Converts the text fragment to ASS syntax.
+    # @return [String] ASS text fragment representation
+    def to_script
+      tags = @tags.map do |(key, value)|
+        value = value.to_script if value.is_a?(Color)
+        "\\#{key}#{value}"
+      end
+      head, tail = "{#{tags.join}}", "{\\r}" unless tags.empty?
+      content = @content.to_s.gsub("\\", "\\\\").gsub("{", "\\{").gsub("}", "\\}").gsub("\n", "\\N")
+      "#{head}#{content}#{tail}"
+    end
+  end
+end

data/lib/mpv_ass/text.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "span"
+
+module Ass
+  # Represents an ASS text containing styled fragments with layout tags.
+  class Text
+    ALIGN = {
+      top_left:    7, top:    8, top_right:    9,
+      left:        4, center: 5, right:        6,
+      bottom_left: 1, bottom: 2, bottom_right: 3,
+    }.freeze
+
+    # Creates an ASS::Text.
+    # @param spans [Array<Ass::Span, String>] initial text fragments
+    def initialize(*spans)
+      @tags = {}
+      @spans = []
+      add(*spans)
+    end
+
+    # Adds new fragments to the current text.
+    # @param spans [Array<Ass::Span, String>] text fragments to append
+    # @return [self]
+    def add(*spans)
+      spans.each{ |span| @spans << (span.is_a?(Span) ? span : Span.new(span)) }
+      self
+    end
+
+    # Replaces the current text fragments.
+    # @param spans [Array<Ass::Span, String>] new text fragments
+    # @return [self]
+    def set(*spans)
+      @spans.clear
+      add(*spans)
+    end
+
+    # Gets the current text fragments.
+    # @return [Array<Ass::Span>] text fragments
+    def get()
+      @spans.dup.freeze
+    end
+
+    # Sets the absolute position of the text.
+    # @param x [Numeric] horizontal coordinate
+    # @param y [Numeric] vertical coordinate
+    # @return [self]
+    def position(x, y)
+      @tags["pos"] = x.round(2), y.round(2)
+      self
+    end
+
+    # Sets the alignment anchor of the text.
+    # @param value [Integer, Symbol] 1..9 number or symbolic alignment name
+    # @return [self]
+    def align(value)
+      @tags["an"] = value.is_a?(Symbol) ? ALIGN.fetch(value) : value.to_i
+      self
+    end
+
+    # Removes all layout tags.
+    # @return [self]
+    def bare
+      @tags.clear
+      self
+    end
+
+    # Converts the text to ASS syntax.
+    # @return [String] ASS text representation
+    def to_script
+      tags = @tags.map do |(key, value)|
+        value = "(#{value.join(",")})" if value.is_a?(Array)
+        "\\#{key}#{value}"
+      end
+      head = "{#{tags.join}}" unless tags.empty?
+      "#{head}#{@spans.map(&:to_script).join}"
+    end
+
+    # Returns the plain text content of each fragment.
+    # @return [Array<String>] plain text fragments
+    def to_a
+      @spans.map(&:to_s)
+    end
+
+    # Returns the full plain text content.
+    # @return [String] concatenated plain text
+    def to_s
+      to_a.join
+    end
+  end
+end

data/lib/mpv_ass.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "mpv_ass/text"