ffmpeg_core 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a1322c33ef390363223c0f3a307f269e84ed3484d2491e2d7340111d33d7a6
-  data.tar.gz: d98fcf0cf9881e837783cda58d1d43784c87310db8e22468e5b0623c9a8d6716
+  metadata.gz: 83185cde1635bd7362c737cba6da5c723be5407cd7457ea5bbac2e0b43206365
+  data.tar.gz: bf4dea2ee0d08d1e8af7b8193cef697f2b8dc1fcda8f5d86efed89e1d23c8f4e
 SHA512:
-  metadata.gz: 5e50f4fb86e61b7d7e858ed90a047f37fa92d7ec9c9216cf8238b7aaf7f48b7c78aa237c36a8c154e864976e8b65c0ac78a93697c1047342df113037fed6f035
-  data.tar.gz: 621b5d98bd486b260a4c208c091f18113484d29df66cb005f8e005204dedd324fc5d737e22d662bbf2dbda788f8cdba002a5a313ba18abcc28d926c948c2cf11
+  metadata.gz: fbe0cf4fd2b09c72c143aeeb1281889f7291e816d7602c6d12852503f647fbc71100e106cf41c33c5e76b9728258d3ecc547b1407632748b6512e92086376265
+  data.tar.gz: 056ea62e71626ac7969cee7242fb14936b15aa9098311b631c36f14c87c61289f6da48a41e99e7745fb7032965a3550d9f1c59e56969b43bba6af33f4b25977f

data/CHANGELOG.md

@@ -5,6 +5,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2026-04-14
+
+### Added
+
+- **Compositor — multi-input video composition:**
+  - New `FFmpegCore::Compositor` class for operations requiring multiple input files in a single FFmpeg command
+  - Accepts an array of local paths or remote URLs as `input_paths`
+  - `:filter_complex` option (String or Array — array elements are joined with `;`)
+  - `:maps` option for stream mapping
+  - Progress reporting via block (requires `:duration`)
+  - Typical use cases: overlay (picture-in-picture), concatenation, side-by-side (`hstack`)
+  - README updated with usage examples
+
+## [0.5.0] - 2026-04-13
+
+### Added
+
+- **Probe — extended metadata:**
+  - `subtitle_streams` — array of subtitle streams
+  - `chapters` — file chapters (requires ffprobe `-show_chapters`)
+  - `format_name` — container format name (mp4, mkv, avi…)
+  - `tags` — file-level tags (title, artist, etc.)
+  - `audio_sample_rate` — sample rate of the first audio stream
+  - `audio_channels` — channel count
+  - `audio_channel_layout` — channel layout string (stereo, 5.1…)
+  - `pixel_format` — video pixel format (yuv420p, etc.)
+  - `has_video?` / `has_audio?` — stream presence predicates
+  - `exif` — EXIF tags merged from format and video stream tags (FFmpeg 8.1)
+- **Movie — new operations:**
+  - `cut(output, start_time:, duration:)` / `cut(output, start_time:, end_time:)` — lossless trim via `-c copy`
+  - `extract_audio(output, codec:)` — extract audio track to file
+  - `screenshots(output_dir, count:)` — extract multiple screenshots at equal intervals
+- **Hardware acceleration — AV1 and D3D12 support (FFmpeg 8.0/8.1):**
+  - AV1 via `:nvenc` (`av1_nvenc`), `:vaapi` (`av1_vaapi`), `:vulkan` (`av1_vulkan`)
+  - D3D12 via `:d3d12` (`h264_d3d12va`) for Windows
+
+### Changed
+
+- `Probe#probe!` now passes `-show_chapters` to ffprobe
+
 ## [0.4.1] - 2026-04-09
 
 ### Fixed

data/README.md

@@ -11,12 +11,25 @@ Modern Ruby wrapper for FFmpeg with clean API and proper error handling.
 - Zero runtime dependencies
 - **Real-time progress reporting**
 - **Support for video/audio filters and quality presets**
-- **Hardware Acceleration (NVENC, VAAPI, QSV)**
+- **Hardware Acceleration (NVENC, VAAPI, QSV, Vulkan AV1, D3D12)**
 - **Remote input support (HTTP/HTTPS/RTMP/RTSP)**
+- **Rich metadata: chapters, subtitles, EXIF, audio properties**
+- **Video operations: cut, audio extraction, batch screenshots**
+- **Multi-input composition: overlay, concatenation, side-by-side**
 - Proper error handling with detailed context
 - Thread-safe configuration
 - Simple, intuitive API
 
+## FFmpeg Version Requirements
+
+| Feature | Minimum FFmpeg version |
+|---|---|
+| Core transcoding, probing | Any recent version |
+| AV1 hardware encoding (Vulkan) | 8.0+ |
+| EXIF metadata parsing | 8.1+ |
+| D3D12 hardware acceleration | 8.1+ |
+| Chapter metadata (`chapters`) | Any (via `-show_chapters`) |
+
 ## Requirements
 
 - Ruby 3.2+
@@ -47,7 +60,7 @@ require "ffmpeg_core"
 movie = FFmpegCore::Movie.new("input.mp4")
 # movie = FFmpegCore::Movie.new("http://example.com/video.mp4")
 
-# Get metadata
+# Basic metadata
 movie.duration      # => 120.5 (seconds)
 movie.resolution    # => "1920x1080" (automatically swapped if rotated)
 movie.width         # => 1920
@@ -57,12 +70,32 @@ movie.audio_codec   # => "aac"
 movie.frame_rate    # => 29.97
 movie.bitrate       # => 5000 (kb/s)
 movie.valid?        # => true
+movie.has_video?    # => true
+movie.has_audio?    # => true
 
-# Access detailed metadata via probe
+# Video stream details
 movie.probe.rotation      # => 90 (degrees)
 movie.probe.aspect_ratio  # => "16:9"
 movie.probe.video_profile # => "High"
 movie.probe.video_level   # => 41
+movie.probe.pixel_format  # => "yuv420p"
+
+# Audio stream details
+movie.probe.audio_sample_rate    # => 48000
+movie.probe.audio_channels       # => 2
+movie.probe.audio_channel_layout # => "stereo"
+movie.probe.audio_streams        # => [{ "codec_type" => "audio", ... }, ...]
+
+# Subtitles and chapters
+movie.probe.subtitle_streams # => [{ "codec_name" => "subrip", ... }]
+movie.probe.chapters         # => [{ "tags" => { "title" => "Intro" }, ... }]
+
+# File-level tags and EXIF (FFmpeg 8.1+ for full EXIF support)
+movie.probe.tags  # => { "title" => "My Video", "artist" => "Author" }
+movie.probe.exif  # => { "creation_time" => "2024-06-15T14:30:00Z", ... }
+
+# Container format
+movie.probe.format_name # => "mov,mp4,m4a,3gp,3g2,mj2"
 ```
 
 ### Transcoding
@@ -104,18 +137,103 @@ movie.transcode("out.mp4", {
 })
 ```
 
+### Multi-Input Composition
+
+Use `FFmpegCore::Compositor` when you need multiple input files in a single FFmpeg command — overlay, concatenation, side-by-side, and any other `-filter_complex` operation.
+
+```ruby
+# Overlay (picture-in-picture): place overlay.mp4 on top of background.mp4
+FFmpegCore::Compositor.new(
+  ["background.mp4", "overlay.mp4"],
+  "output.mp4",
+  filter_complex: "[0:v][1:v]overlay=10:10[v]",
+  maps: ["[v]", "0:a"]
+).run
+
+# Concatenate two clips sequentially
+FFmpegCore::Compositor.new(
+  ["part1.mp4", "part2.mp4"],
+  "output.mp4",
+  filter_complex: "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]",
+  maps: ["[v]", "[a]"]
+).run
+
+# Side-by-side (horizontal stack)
+FFmpegCore::Compositor.new(
+  ["left.mp4", "right.mp4"],
+  "output.mp4",
+  filter_complex: "[0:v][1:v]hstack[v]",
+  maps: ["[v]", "0:a"]
+).run
+
+# With progress reporting (requires :duration)
+FFmpegCore::Compositor.new(
+  ["a.mp4", "b.mp4"],
+  "output.mp4",
+  filter_complex: "[0:v][1:v]overlay[v]",
+  maps: ["[v]", "0:a"],
+  duration: 120.0
+).run do |progress|
+  puts "#{(progress * 100).round}%"
+end
+```
+
+> **Note:** Stream indices (`[0:v]`, `[1:v]`, etc.) correspond to the position of each file in the input array.
+
+### Cutting / Trimming
+
+Lossless trim using stream copy — no re-encoding, nearly instant:
+
+```ruby
+# Trim by start time + duration
+movie.cut("clip.mp4", start_time: 30, duration: 60)
+
+# Trim by start and end time
+movie.cut("clip.mp4", start_time: 30, end_time: 90)
+```
+
+> **Note:** `-c copy` seeks to the nearest keyframe. For frame-accurate trimming, use `transcode` with `custom: ["-ss", "30", "-to", "90"]`.
+
+### Audio Extraction
+
+```ruby
+# Extract audio with automatic codec detection from file extension
+movie.extract_audio("audio.aac")
+
+# Specify codec explicitly
+movie.extract_audio("audio.mp3", codec: "libmp3lame")
+movie.extract_audio("audio.opus", codec: "libopus")
+```
+
+### Multiple Screenshots
+
+```ruby
+# Extract 5 screenshots distributed evenly across the video
+paths = movie.screenshots("thumbs/", count: 5)
+# => ["thumbs/screenshot_001.jpg", ..., "thumbs/screenshot_005.jpg"]
+```
+
 ### Hardware Acceleration
 
 Opt-in to hardware-accelerated encoding with automatic encoder detection and graceful fallback.
 
 ```ruby
-# Automatically switches to h264_nvenc if available, falls back to libx264 otherwise
-movie.transcode("out.mp4", hwaccel: :nvenc)
-
-# Supports :nvenc, :vaapi, and :qsv
-movie.transcode("out.mp4", hwaccel: :vaapi)
+# H.264 / HEVC — classic accelerators
+movie.transcode("out.mp4", hwaccel: :nvenc)           # NVIDIA CUDA
+movie.transcode("out.mp4", hwaccel: :vaapi)           # Linux VAAPI
+movie.transcode("out.mp4", hwaccel: :qsv)             # Intel Quick Sync
+
+# AV1 — requires FFmpeg 8.0+
+movie.transcode("out.mp4", video_codec: "libaom-av1", hwaccel: :nvenc)   # NVIDIA
+movie.transcode("out.mp4", video_codec: "libaom-av1", hwaccel: :vaapi)   # VAAPI
+movie.transcode("out.mp4", video_codec: "libaom-av1", hwaccel: :vulkan)  # Vulkan compute
+
+# D3D12 — Windows only, requires FFmpeg 8.1+
+movie.transcode("out.mp4", hwaccel: :d3d12)
 ```
 
+All accelerators gracefully fall back to software encoding if the hardware encoder is not available.
+
 ### Using Filters
 
 FFmpegCore supports raw FFmpeg filter strings for both video (`video_filter` or `-vf`) and audio (`audio_filter` or `-af`).

data/lib/ffmpeg_core/audio_extractor.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module FFmpegCore
+  # Extract audio track from video files
+  class AudioExtractor
+    attr_reader :input_path, :output_path, :options
+
+    def initialize(input_path, output_path, options = {})
+      @input_path = input_path.to_s
+      @output_path = output_path.to_s
+      @options = options
+    end
+
+    def run
+      validate_input!
+      ensure_output_directory!
+
+      command = build_command
+      execute_command(command)
+    end
+
+    private
+
+    def validate_input!
+      return if %r{^(https?|rtmp|rtsp)://}.match?(input_path)
+
+      raise InvalidInputError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
+    end
+
+    def ensure_output_directory!
+      output_dir = File.dirname(output_path)
+      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+    end
+
+    def build_command
+      cmd = [FFmpegCore.configuration.ffmpeg_binary, "-i", input_path]
+      cmd += ["-vn"]
+      cmd += ["-c:a", options[:codec]] if options[:codec]
+      cmd += ["-y", output_path]
+      cmd
+    end
+
+    def execute_command(command)
+      _stdout, stderr, status = Open3.capture3(*command)
+
+      unless status.success?
+        raise TranscodingError.new(
+          "FFmpeg audio extraction failed",
+          command: command.join(" "),
+          exit_status: status.exitstatus,
+          stdout: "",
+          stderr: stderr
+        )
+      end
+
+      output_path
+    end
+  end
+end

data/lib/ffmpeg_core/clipper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module FFmpegCore
+  # Cut/trim video segments
+  class Clipper
+    attr_reader :input_path, :output_path, :options
+
+    def initialize(input_path, output_path, options = {})
+      @input_path = input_path.to_s
+      @output_path = output_path.to_s
+      @options = options
+    end
+
+    def run
+      validate_input!
+      ensure_output_directory!
+
+      command = build_command
+      execute_command(command)
+    end
+
+    private
+
+    def validate_input!
+      return if %r{^(https?|rtmp|rtsp)://}.match?(input_path)
+
+      raise InvalidInputError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
+    end
+
+    def ensure_output_directory!
+      output_dir = File.dirname(output_path)
+      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+    end
+
+    def build_command
+      cmd = [FFmpegCore.configuration.ffmpeg_binary]
+
+      cmd += ["-ss", options[:start_time].to_s] if options[:start_time]
+      cmd += ["-i", input_path]
+
+      if options[:duration]
+        cmd += ["-t", options[:duration].to_s]
+      elsif options[:end_time]
+        cmd += ["-to", options[:end_time].to_s]
+      end
+
+      cmd += ["-c", "copy", "-y", output_path]
+      cmd
+    end
+
+    def execute_command(command)
+      _stdout, stderr, status = Open3.capture3(*command)
+
+      unless status.success?
+        raise TranscodingError.new(
+          "FFmpeg cut failed",
+          command: command.join(" "),
+          exit_status: status.exitstatus,
+          stdout: "",
+          stderr: stderr
+        )
+      end
+
+      output_path
+    end
+  end
+end

data/lib/ffmpeg_core/compositor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module FFmpegCore
+  # Execute FFmpeg operations with multiple input files
+  #
+  # @example Overlay (picture-in-picture)
+  #   FFmpegCore::Compositor.new(
+  #     ["background.mp4", "overlay.mp4"],
+  #     "output.mp4",
+  #     filter_complex: "[0:v][1:v]overlay=10:10[v]",
+  #     maps: ["[v]", "0:a"]
+  #   ).run
+  #
+  # @example Concatenate
+  #   FFmpegCore::Compositor.new(
+  #     ["part1.mp4", "part2.mp4"],
+  #     "output.mp4",
+  #     filter_complex: "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]",
+  #     maps: ["[v]", "[a]"]
+  #   ).run
+  class Compositor
+    attr_reader :input_paths, :output_path, :options
+
+    # @param input_paths [Array<String>] Paths or URLs to input files (at least one required)
+    # @param output_path [String] Path to output file
+    # @param options [Hash] Compositing options
+    # @option options [String] :video_codec Video codec (e.g., "libx264")
+    # @option options [String] :audio_codec Audio codec (e.g., "aac")
+    # @option options [String, Integer] :video_bitrate Video bitrate (e.g., "1000k" or 1000)
+    # @option options [String, Integer] :audio_bitrate Audio bitrate (e.g., "128k" or 128)
+    # @option options [Array<String>, String] :filter_complex FFmpeg filter graph referencing input streams by index
+    #   (e.g., "[0:v][1:v]overlay=0:0[v]"). Array elements are joined with semicolons.
+    # @option options [Array<String>, String] :maps Stream maps selecting outputs from the filter graph
+    #   (e.g., ["[v]", "0:a"])
+    # @option options [Float] :duration Total duration in seconds, used for progress reporting
+    # @option options [Array<String>] :custom Raw FFmpeg flags appended verbatim (e.g., ["-shortest"])
+    # @raise [ArgumentError] if input_paths is empty
+    def initialize(input_paths, output_path, options = {})
+      raise ArgumentError, "At least one input path is required" if Array(input_paths).empty?
+
+      @input_paths = Array(input_paths).map(&:to_s)
+      @output_path = output_path.to_s
+      @options = options
+    end
+
+    # Run the FFmpeg compositing command
+    #
+    # @yield [Float] Progress ratio from 0.0 to 1.0 (requires :duration option)
+    # @return [String] Path to the output file
+    # @raise [InvalidInputError] if a local input file does not exist
+    # @raise [TranscodingError] if FFmpeg exits with a non-zero status
+    def run(&block)
+      validate_inputs!
+      ensure_output_directory!
+
+      command = build_command
+      execute_command(command, &block)
+    end
+
+    private
+
+    def validate_inputs!
+      input_paths.each do |path|
+        next if %r{^(https?|rtmp|rtsp)://}.match?(path)
+
+        raise InvalidInputError, "Input file does not exist: #{path}" unless File.exist?(path)
+      end
+    end
+
+    def ensure_output_directory!
+      output_dir = File.dirname(output_path)
+      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+    end
+
+    def build_command
+      cmd = [FFmpegCore.configuration.ffmpeg_binary]
+
+      input_paths.each { |path| cmd += ["-i", path] }
+
+      cmd += ["-c:v", options[:video_codec]] if options[:video_codec]
+      cmd += ["-c:a", options[:audio_codec]] if options[:audio_codec]
+      cmd += ["-b:v", normalize_bitrate(options[:video_bitrate])] if options[:video_bitrate]
+      cmd += ["-b:a", normalize_bitrate(options[:audio_bitrate])] if options[:audio_bitrate]
+
+      filter = options[:filter_complex] || options[:filter_graph]
+      if filter
+        cmd += ["-filter_complex", filter.is_a?(Array) ? filter.join(";") : filter]
+      end
+
+      maps = options[:maps] || options[:map]
+      Array(maps).each { |map| cmd += ["-map", map] } if maps
+
+      cmd += options[:custom] if options[:custom]
+      cmd += ["-y", output_path]
+      cmd
+    end
+
+    def normalize_bitrate(bitrate)
+      return bitrate.to_s if bitrate.to_s.match?(/\d+[kKmM]/)
+
+      "#{bitrate}k"
+    end
+
+    def execute_command(command, &block)
+      error_log = []
+
+      Open3.popen3(*command) do |_stdin, _stdout, stderr, wait_thr|
+        stderr.each_line("\r") do |line|
+          clean_line = line.strip
+          next if clean_line.empty?
+
+          error_log << clean_line
+          error_log.shift if error_log.size > 20
+          parse_progress(line, &block) if block
+        end
+
+        status = wait_thr.value
+        unless status.success?
+          raise TranscodingError.new(
+            "FFmpeg compositing failed",
+            command: command.join(" "),
+            exit_status: status.exitstatus,
+            stdout: "",
+            stderr: error_log.join("\n")
+          )
+        end
+      end
+
+      output_path
+    end
+
+    def parse_progress(line)
+      return unless line =~ /time=(\d{2}):(\d{2}):(\d{2}\.\d{2})/
+
+      current_time = $1.to_i * 3600 + $2.to_i * 60 + $3.to_f
+      duration = options[:duration]
+      yield([current_time / duration.to_f, 1.0].min) if duration && duration.to_f > 0
+    end
+  end
+end

data/lib/ffmpeg_core/movie.rb

@@ -52,5 +52,47 @@ module FFmpegCore
       screenshotter = Screenshot.new(path, output_path, options)
       screenshotter.extract
     end
+
+    # Cut/trim a segment from video
+    #
+    # @param output_path [String] Path to output file
+    # @param options [Hash] Cut options
+    # @option options [Integer, Float] :start_time Start time in seconds
+    # @option options [Integer, Float] :duration Duration in seconds
+    # @option options [Integer, Float] :end_time End time in seconds (alternative to :duration)
+    # @return [String] Path to output file
+    def cut(output_path, options = {})
+      clipper = Clipper.new(path, output_path, options)
+      clipper.run
+    end
+
+    # Extract audio track from video
+    #
+    # @param output_path [String] Path to output audio file
+    # @param options [Hash] Extraction options
+    # @option options [String] :codec Audio codec (e.g., "libmp3lame", "aac")
+    # @return [String] Path to output file
+    def extract_audio(output_path, options = {})
+      extractor = AudioExtractor.new(path, output_path, options)
+      extractor.run
+    end
+
+    # Extract multiple screenshots at equal intervals
+    #
+    # @param output_dir [String] Directory to save screenshots
+    # @param count [Integer] Number of screenshots to extract (default: 5)
+    # @return [Array<String>] Paths to screenshot files
+    def screenshots(output_dir, count: 5)
+      FileUtils.mkdir_p(output_dir)
+      total = duration || 0
+      interval = total / (count + 1).to_f
+
+      (1..count).map do |i|
+        seek = (interval * i).round(2)
+        output_path = File.join(output_dir, format("screenshot_%03d.jpg", i))
+        Screenshot.new(path, output_path, seek_time: seek).extract
+        output_path
+      end
+    end
   end
 end

data/lib/ffmpeg_core/probe.rb

@@ -111,6 +111,53 @@ module FFmpegCore
       streams.select { |s| s["codec_type"] == "audio" }
     end
 
+    def subtitle_streams
+      streams.select { |s| s["codec_type"] == "subtitle" }
+    end
+
+    def chapters
+      @metadata.fetch("chapters", [])
+    end
+
+    def format_name
+      @metadata.dig("format", "format_name")
+    end
+
+    def tags
+      @metadata.dig("format", "tags") || {}
+    end
+
+    def audio_sample_rate
+      audio_stream&.dig("sample_rate")&.to_i
+    end
+
+    def audio_channels
+      audio_stream&.dig("channels")
+    end
+
+    def audio_channel_layout
+      audio_stream&.dig("channel_layout")
+    end
+
+    def pixel_format
+      video_stream&.dig("pix_fmt")
+    end
+
+    def has_video?
+      !video_stream.nil?
+    end
+
+    def has_audio?
+      !audio_stream.nil?
+    end
+
+    # EXIF metadata: merges format-level and video stream tags (FFmpeg 8.1+)
+    def exif
+      format_tags = @metadata.dig("format", "tags") || {}
+      stream_tags = video_stream&.dig("tags") || {}
+      format_tags.merge(stream_tags)
+    end
+
     def valid?
       !video_stream.nil?
     end
@@ -135,6 +182,7 @@ module FFmpegCore
         "-print_format", "json",
         "-show_format",
         "-show_streams",
+        "-show_chapters",
         path
       ]
 

data/lib/ffmpeg_core/transcoder.rb

@@ -189,25 +189,35 @@ module FFmpegCore
         :h264
       when /x265|hevc/i
         :hevc
+      when /av1|libaom/i
+        :av1
       end
     end
 
     HW_FLAGS = {
       vaapi: ["-hwaccel", "vaapi", "-hwaccel_output_format", "vaapi"],
       qsv: ["-hwaccel", "qsv"],
-      nvenc: ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"]
+      nvenc: ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"],
+      vulkan: ["-hwaccel", "vulkan"],
+      d3d12: ["-hwaccel", "d3d12va"]
     }.freeze
 
     HW_ENCODERS = {
       h264: {
         nvenc: "h264_nvenc",
         vaapi: "h264_vaapi",
-        qsv: "h264_qsv"
+        qsv: "h264_qsv",
+        d3d12: "h264_d3d12va"
       },
       hevc: {
         nvenc: "hevc_nvenc",
         vaapi: "hevc_vaapi",
         qsv: "hevc_qsv"
+      },
+      av1: {
+        nvenc: "av1_nvenc",
+        vaapi: "av1_vaapi",
+        vulkan: "av1_vulkan"
       }
     }.freeze
   end

data/lib/ffmpeg_core/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FFmpegCore
-  VERSION = "0.4.1"
+  VERSION = "0.6.0"
 end

data/lib/ffmpeg_core.rb

@@ -24,4 +24,7 @@ require_relative "ffmpeg_core/configuration"
 require_relative "ffmpeg_core/probe"
 require_relative "ffmpeg_core/transcoder"
 require_relative "ffmpeg_core/screenshot"
+require_relative "ffmpeg_core/clipper"
+require_relative "ffmpeg_core/audio_extractor"
+require_relative "ffmpeg_core/compositor"
 require_relative "ffmpeg_core/movie"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffmpeg_core
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Alexey Poimtsev
@@ -37,6 +37,9 @@ files:
 - Rakefile
 - lefthook.yml
 - lib/ffmpeg_core.rb
+- lib/ffmpeg_core/audio_extractor.rb
+- lib/ffmpeg_core/clipper.rb
+- lib/ffmpeg_core/compositor.rb
 - lib/ffmpeg_core/configuration.rb
 - lib/ffmpeg_core/errors.rb
 - lib/ffmpeg_core/movie.rb
@@ -67,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Modern Ruby wrapper for FFmpeg
 test_files: []