libav-ruby 0.1.0

data/lib/libav/video_writer.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "thread"
+require_relative "output_context"
+require_relative "video_encoder"
+require_relative "audio_encoder"
+
+module LibAV
+  class VideoWriter
+    ASYNC_STOP = Object.new.freeze
+    QUEUE_DEPTH = 4
+
+    attr_reader :width, :height
+
+    def self.open(path, **options)
+      writer = new(path, **options)
+      return writer unless block_given?
+
+      begin
+        yield writer
+      ensure
+        writer.close
+      end
+    end
+
+    def initialize(path, width:, height:, fps:, async: false, audio: nil, **options)
+      @path = File.path(path)
+      @width = Integer(width)
+      @height = Integer(height)
+      @output = OutputContext.new(@path)
+      @encoder = VideoEncoder.new(
+        @output, width: @width, height: @height, fps:, **options
+      )
+      @audio_encoder = AudioEncoder.new(@output, **audio_options(audio)) if audio
+      @output.open!
+      @mutex = Mutex.new
+      self.async = async
+    rescue StandardError
+      close_resources
+      raise
+    end
+
+    def <<(frame)
+      push(frame)
+    end
+
+    def push(frame)
+      raise_if_unavailable!
+      rgba = normalize_frame(frame)
+      @async ? enqueue(rgba) : encode(rgba)
+      self
+    end
+
+    def async
+      @async == true
+    end
+
+    def async=(enabled)
+      enabled = !!enabled
+      return enabled if enabled == async
+      raise ClosedError, "video writer is closed" if @closed
+      raise ArgumentError, "async mode cannot be disabled after it has started" unless enabled
+
+      @queue = SizedQueue.new(QUEUE_DEPTH)
+      @async = true
+      @worker = Thread.new { worker_loop }
+      enabled
+    end
+
+    def push_audio(pcm_f32_interleaved)
+      raise_if_unavailable!
+      raise Error, "this writer has no audio track" unless @audio_encoder
+
+      @mutex.synchronize { @audio_encoder.push(pcm_f32_interleaved) }
+      self
+    end
+
+    def close
+      return if @closed
+
+      error = nil
+      begin
+        stop_worker if async
+        raise_worker_error!
+        @mutex.synchronize do
+          @encoder.flush
+          @audio_encoder&.flush
+        end
+      rescue StandardError => caught
+        error = caught
+      ensure
+        cleanup_error = close_resources
+        error ||= cleanup_error
+        @closed = true
+      end
+      raise error if error
+
+      nil
+    end
+
+    def closed?
+      @closed == true
+    end
+
+    private
+
+    def normalize_frame(frame)
+      frame_width, frame_height, data = frame_parts(frame)
+      frame_width ||= width
+      frame_height ||= height
+      raise ArgumentError, "frame dimensions must be #{width}x#{height}" unless
+        frame_width == width && frame_height == height
+      validate_pixel_metadata(frame)
+
+      data = data.to_str.b
+      expected = width * height * 4
+      raise ArgumentError, "RGBA frame must contain #{expected} bytes, got #{data.bytesize}" unless
+        data.bytesize == expected
+
+      data.dup
+    rescue NoMethodError, TypeError
+      raise ArgumentError, "frame must provide packed RGBA bytes"
+    end
+
+    def frame_parts(frame)
+      return [nil, nil, frame] if frame.respond_to?(:to_str)
+      if frame.respond_to?(:to_hash)
+        hash = frame.to_hash
+        return [
+          hash[:width] || hash["width"],
+          hash[:height] || hash["height"],
+          hash[:data] || hash["data"]
+        ]
+      end
+      return [frame.width, frame.height, frame.data] if
+        frame.respond_to?(:width) && frame.respond_to?(:height) && frame.respond_to?(:data)
+
+      [nil, nil, nil]
+    end
+
+    def validate_pixel_metadata(frame)
+      return unless frame.respond_to?(:channels) || frame.respond_to?(:dtype)
+
+      channels = frame.channels if frame.respond_to?(:channels)
+      dtype = frame.dtype if frame.respond_to?(:dtype)
+      raise ArgumentError, "image frames must have 4 RGBA channels" unless channels.nil? || channels == 4
+      raise ArgumentError, "image frames must use :u8 components" unless dtype.nil? || dtype.to_sym == :u8
+    end
+
+    def encode(rgba)
+      @mutex.synchronize { @encoder.encode(rgba) }
+    end
+
+    def enqueue(rgba)
+      loop do
+        raise_worker_error!
+        @queue.push(rgba, true)
+        break
+      rescue ThreadError
+        Thread.pass
+      end
+    end
+
+    def stop_worker
+      enqueue(ASYNC_STOP)
+      @worker.join
+    end
+
+    def worker_loop
+      loop do
+        frame = @queue.pop
+        break if frame.equal?(ASYNC_STOP)
+
+        encode(frame)
+      end
+    rescue StandardError => error
+      @worker_error = error
+    end
+
+    def raise_if_unavailable!
+      raise ClosedError, "video writer is closed" if @closed
+
+      raise_worker_error!
+    end
+
+    def raise_worker_error!
+      raise @worker_error if @worker_error
+    end
+
+    def close_resources
+      error = nil
+      begin
+        @output&.close
+      rescue StandardError => caught
+        error = caught
+      ensure
+        @encoder&.close
+        @audio_encoder&.close
+      end
+      error
+    end
+
+    def audio_options(audio)
+      if audio.respond_to?(:transform_keys)
+        options = audio.transform_keys(&:to_sym)
+        options[:codec] ||= :opus if File.extname(@path).downcase == ".webm"
+        return options
+      end
+
+      raise ArgumentError, "audio must be a Hash of encoder options"
+    end
+  end
+end

data/lib/libav.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "logger"
+require_relative "libav/version"
+require_relative "libav/errors"
+require_relative "libav/native"
+require_relative "libav/video_frame"
+require_relative "libav/texel_support"
+require_relative "libav/video_writer"
+require_relative "libav/video_reader"
+require_relative "libav/audio_frame"
+require_relative "libav/audio_writer"
+require_relative "libav/audio_reader"
+
+module LibAV
+  class << self
+    attr_accessor :logger
+    attr_reader :log_level
+
+    def native_versions
+      Native.versions.dup
+    end
+
+    def log_level=(level)
+      Native.log_level = level
+      @log_level = level.respond_to?(:to_sym) ? level.to_sym : level
+    end
+  end
+end
+
+LibAV::Native.load!
+LibAV.logger = Logger.new($stderr)
+LibAV.logger.level = Logger::WARN
+LibAV.log_level = :warn
+LibAV::Native.install_log_callback!

data/native/abi_probe.c

@@ -0,0 +1,72 @@
+#include <stddef.h>
+#include <stdio.h>
+
+#include <libavcodec/avcodec.h>
+#include <libavcodec/packet.h>
+#include <libavformat/avformat.h>
+#include <libavutil/channel_layout.h>
+#include <libavutil/frame.h>
+
+#define FIELD(type, field) \
+    printf("%s.%s=%zu\n", #type, #field, offsetof(type, field))
+
+int main(void)
+{
+    printf("pointer_size=%zu\n", sizeof(void *));
+    printf("channel_layout_size=%zu\n", sizeof(AVChannelLayout));
+
+    FIELD(AVOutputFormat, flags);
+
+    FIELD(AVFormatContext, oformat);
+    FIELD(AVFormatContext, pb);
+    FIELD(AVFormatContext, nb_streams);
+    FIELD(AVFormatContext, streams);
+    FIELD(AVFormatContext, duration);
+
+    FIELD(AVStream, index);
+    FIELD(AVStream, time_base);
+    FIELD(AVStream, start_time);
+    FIELD(AVStream, duration);
+    FIELD(AVStream, nb_frames);
+    FIELD(AVStream, r_frame_rate);
+    FIELD(AVStream, avg_frame_rate);
+    FIELD(AVStream, codecpar);
+
+    FIELD(AVCodecContext, codec_type);
+    FIELD(AVCodecContext, priv_data);
+    FIELD(AVCodecContext, bit_rate);
+    FIELD(AVCodecContext, flags);
+    FIELD(AVCodecContext, time_base);
+    FIELD(AVCodecContext, width);
+    FIELD(AVCodecContext, height);
+    FIELD(AVCodecContext, gop_size);
+    FIELD(AVCodecContext, pix_fmt);
+    FIELD(AVCodecContext, sample_rate);
+    FIELD(AVCodecContext, sample_fmt);
+    FIELD(AVCodecContext, frame_size);
+    FIELD(AVCodecContext, framerate);
+    FIELD(AVCodecContext, ch_layout);
+
+    FIELD(AVFrame, data);
+    FIELD(AVFrame, linesize);
+    FIELD(AVFrame, extended_data);
+    FIELD(AVFrame, width);
+    FIELD(AVFrame, height);
+    FIELD(AVFrame, nb_samples);
+    FIELD(AVFrame, format);
+    FIELD(AVFrame, pts);
+    FIELD(AVFrame, best_effort_timestamp);
+    FIELD(AVFrame, duration);
+    FIELD(AVFrame, sample_rate);
+    FIELD(AVFrame, ch_layout);
+
+    FIELD(AVPacket, pts);
+    FIELD(AVPacket, dts);
+    FIELD(AVPacket, data);
+    FIELD(AVPacket, size);
+    FIELD(AVPacket, stream_index);
+    FIELD(AVPacket, duration);
+    FIELD(AVPacket, time_base);
+
+    return 0;
+}

data/native/generate_layout.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "optparse"
+require "rbconfig"
+require "tmpdir"
+
+TYPE_NAMES = {
+  "AVOutputFormat" => :output_format,
+  "AVFormatContext" => :format_context,
+  "AVStream" => :stream,
+  "AVCodecContext" => :codec_context,
+  "AVFrame" => :frame,
+  "AVPacket" => :packet
+}.freeze
+
+options = {}
+OptionParser.new do |parser|
+  parser.banner = "Usage: ruby native/generate_layout.rb [options]"
+  parser.on("--codec-major MAJOR", Integer, "libavcodec major (60 or 61)") do |value|
+    options[:major] = value
+  end
+  parser.on("--include DIRECTORY", "FFmpeg include directory") do |value|
+    options[:include] = File.expand_path(value)
+  end
+  parser.on("--output FILE", "Ruby layout file to write") do |value|
+    options[:output] = File.expand_path(value)
+  end
+  parser.on("--verify", "verify that the existing layout matches the native headers") do
+    options[:verify] = true
+  end
+end.parse!
+
+major = options.fetch(:major) { abort "missing --codec-major" }
+abort "codec major must be 60 or 61" unless [60, 61].include?(major)
+include_directory = options.fetch(:include) { abort "missing --include" }
+output = options.fetch(
+  :output,
+  File.expand_path("../lib/libav/native/v#{major}/layout.rb", __dir__)
+)
+probe = File.expand_path("abi_probe.c", __dir__)
+compiler = ENV.fetch("CC", RbConfig::CONFIG.fetch("CC", "cc"))
+
+raw = Dir.mktmpdir("libav-abi") do |directory|
+  binary = File.join(directory, "abi_probe")
+  command = [compiler, "-I#{include_directory}", probe, "-o", binary]
+  _stdout, stderr, status = Open3.capture3(*command)
+  abort "ABI probe compilation failed:\n#{stderr}" unless status.success?
+
+  stdout, run_stderr, run_status = Open3.capture3(binary)
+  abort "ABI probe failed:\n#{run_stderr}" unless run_status.success?
+
+  stdout
+end
+
+metadata = {}
+values = Hash.new { |hash, key| hash[key] = {} }
+raw.each_line do |line|
+  name, offset = line.strip.split("=", 2)
+  unless name.include?(".")
+    metadata[name] = Integer(offset)
+    next
+  end
+
+  native_type, field = name.split(".", 2)
+  type = TYPE_NAMES.fetch(native_type)
+  values[type][field.to_sym] = Integer(offset)
+end
+abort "ABI probe requires 64-bit pointers" unless metadata.fetch("pointer_size") == 8
+abort "unexpected AVChannelLayout size" unless metadata.fetch("channel_layout_size") == 24
+
+body = values.map do |type, fields|
+  entries = fields.map { |field, offset| "#{field}: #{offset}" }.join(", ")
+  "        #{type}: {#{entries}}"
+end.join(",\n")
+
+source = <<~RUBY
+  # frozen_string_literal: true
+
+  module LibAV
+    module Native
+      module Layout
+        V#{major} = {
+  #{body}
+        }.freeze
+      end
+    end
+  end
+RUBY
+
+if options[:verify]
+  load output
+  generated = LibAV::Native::Layout.const_get(:"V#{major}")
+  expected = values.transform_values(&:to_h).to_h
+  abort "ABI layout mismatch: regenerate #{output}" unless generated == expected
+
+  puts "ABI layout verified: #{output}"
+else
+  FileUtils.mkdir_p(File.dirname(output))
+  File.write(output, source)
+  puts output
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: libav-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+description: Encode and decode video and audio frames through FFmpeg shared libraries
+  without spawning subprocesses.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/frames_to_mp4.rb
+- examples/stagecraft_offscreen_to_mp4.rb
+- examples/vizcore_scene_to_mp4.rb
+- lib/libav.rb
+- lib/libav/audio_encoder.rb
+- lib/libav/audio_frame.rb
+- lib/libav/audio_reader.rb
+- lib/libav/audio_writer.rb
+- lib/libav/errors.rb
+- lib/libav/native.rb
+- lib/libav/native/layout.rb
+- lib/libav/native/v60/layout.rb
+- lib/libav/native/v61/layout.rb
+- lib/libav/output_context.rb
+- lib/libav/texel_support.rb
+- lib/libav/version.rb
+- lib/libav/video_encoder.rb
+- lib/libav/video_frame.rb
+- lib/libav/video_reader.rb
+- lib/libav/video_writer.rb
+- native/abi_probe.c
+- native/generate_layout.rb
+homepage: https://github.com/ydah/libav-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/libav-ruby
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Frame-level Ruby bindings for FFmpeg
+test_files: []