rays-video 0.2.0 → 0.3.0

data/test/test_video.rb

@@ -10,8 +10,32 @@ class TestVideo < Test::Unit::TestCase
     Rays::Video.new(w, h, fps: fps, pixel_density: pd)
   end
 
-  def image(w = 10, h = 10)
-    Rays::Image.new(w, h)
+  def image(gray = 0)
+    Rays::Image.new(10, 10).paint {fill gray / 255.0; rect 0, 0, 10, 10}
+  end
+
+  def gray(image)
+    (image[5, 5].red * 255).round
+  end
+
+  def grays(video)
+    video.map {|image| gray image}
+  end
+
+  def color(*args)
+    Rays::Color.new(*args)
+  end
+
+  def load_video(colors, ext = 'gif', &block)
+    tmpdir do |dir|
+      v = video
+      v.append(*colors.map {|c|
+        Rays::Image.new(10, 10).paint {fill(*c); rect 0, 0, 10, 10}
+      })
+      path = File.join dir, "test.#{ext}"
+      v.save path
+      block.call Rays::Video.load(path)
+    end
   end
 
   def test_initialize()
@@ -42,28 +66,60 @@ class TestVideo < Test::Unit::TestCase
   end
 
   def test_insert()
-    v = video;                      assert_equal [],              v.map(&:width)
-    v.append image(1), image(2);    assert_equal [1, 2],          v.map(&:width)
-    v.insert 1, image(3);           assert_equal [1, 3, 2],       v.map(&:width)
-    v.insert 2, image(4), image(5); assert_equal [1, 3, 4, 5, 2], v.map(&:width)
-    
+    v = video;                        assert_equal [],                       grays(v)
+    v.append image(10), image(20);    assert_equal [10, 20],                 grays(v)
+    v.insert 1, image(30);            assert_equal [10, 30, 20],             grays(v)
+    v.insert 2, image(40), image(50); assert_equal [10, 30, 40, 50, 20],     grays(v)
+    v.insert 5, image(60);            assert_equal [10, 30, 40, 50, 20, 60], grays(v)
+
+    assert_raise(IndexError)    {v.insert 7, image}
+    assert_raise(ArgumentError) {v.insert 0, Rays::Image.new(10, 5)}
+    assert_raise(ArgumentError) {v.insert 0, Rays::Image.new(5,  10)}
+    assert_raise(ArgumentError) {v.insert 0, Rays::Image.new(10, 10, pixel_density: 2)}
+  end
+
+  def test_insert_with_pixel_density()
+    v = video 10, 10, 30, 2
+    v.append Rays::Image.new(10, 10, pixel_density: 2)
+    assert_equal 1, v.size
+
+    assert_raise(ArgumentError) {v.append Rays::Image.new(10, 10, pixel_density: 1)}
+    assert_raise(ArgumentError) {v.append Rays::Image.new(20, 20, pixel_density: 2)}
   end
 
   def test_append()
-    v = video;                   assert_equal [],        v.map(&:width)
-    v.append image(1);           assert_equal [1],       v.map(&:width)
-    v.append image(2), image(3); assert_equal [1, 2, 3], v.map(&:width)
-    
+    v = video;                     assert_equal [],                       grays(v)
+    v.append image(10);            assert_equal [10],                     grays(v)
+    v.append image(20), image(30); assert_equal [10, 20, 30],             grays(v)
+    v.push   image(40);            assert_equal [10, 20, 30, 40],         grays(v)
+    v << image(50) << image(60);   assert_equal [10, 20, 30, 40, 50, 60], grays(v)
+
+    assert_same v, v.append(image)
+    assert_same v, v.push(image)
+    assert_same v, v << image
   end
 
   def test_remove()
-    v = video;                             assert_equal [],        v.map(&:width)
-    v.append image(1), image(2), image(3); assert_equal [1, 2, 3], v.map(&:width)
-    v.remove 1;                            assert_equal [1, 3],    v.map(&:width)
+    v = video;                                assert_equal [],           grays(v)
+    v.append image(10), image(20), image(30); assert_equal [10, 20, 30], grays(v)
+    v.remove 1;                               assert_equal [10, 30],     grays(v)
 
     assert_raise(NotImplementedError) {v.remove 1..}
   end
 
+  def test_set_at()
+    v = video
+    v.append image(10), image(20), image(30)
+    v[1] = image(40); assert_equal [10, 40, 30], grays(v)
+    v[0] = image(50); assert_equal [50, 40, 30], grays(v)
+    v[2] = image(60); assert_equal [50, 40, 60], grays(v)
+
+    assert_raise(IndexError)    {v[3]  = image}
+    assert_raise(RangeError)    {v[-1] = image}
+    assert_raise(IndexError)    {video[0] = image}
+    assert_raise(ArgumentError) {v[0] = Rays::Image.new(5, 5)}
+  end
+
   def test_size()
     v = video;             assert_equal 0, v.size
     v.append image, image; assert_equal 2, v.size
@@ -85,29 +141,29 @@ class TestVideo < Test::Unit::TestCase
 
   def test_each()
     v = video
-    v.append image(1), image(2), image(3)
+    v.append image(10), image(20), image(30)
 
     assert_equal(
-      [[0, 1], [1, 2], [2, 3]],
-      v.map.with_index {|image, index| [index, image.width]})
+      [[0, 10], [1, 20], [2, 30]],
+      v.map.with_index {|image, index| [index, gray(image)]})
   end
 
   def test_to_image()
-    v = video.tap {_1.append image(1), image(2), image(3)}
-               assert_equal 1, v.to_image.width
-    v.pos = 1; assert_equal 2, v.to_image.width
-    v.pos = 2; assert_equal 3, v.to_image.width
-    v.pos = 3; assert_equal 3, v.to_image.width
-    v.pos = 9; assert_equal 3, v.to_image.width
+    v = video.tap {_1.append image(10), image(20), image(30)}
+               assert_equal 10, gray(v.to_image)
+    v.pos = 1; assert_equal 20, gray(v.to_image)
+    v.pos = 2; assert_equal 30, gray(v.to_image)
+    v.pos = 3; assert_equal 30, gray(v.to_image)
+    v.pos = 9; assert_equal 30, gray(v.to_image)
   end
 
   def test_at()
     v = video
-    v.append image(1), image(2), image(3)
-    assert_equal 1, v[0].width
-    assert_equal 3, v[2].width
+    v.append image(10), image(20), image(30)
+    assert_equal 10, gray(v[0])
+    assert_equal 30, gray(v[2])
 
-    assert_raise(IndexError) {v[-1]}
+    assert_raise(RangeError) {v[-1]}
     assert_raise(IndexError) {v[3]}
   end
 
@@ -157,6 +213,87 @@ class TestVideo < Test::Unit::TestCase
     end
   end
 
+  def test_load_mp4_frames_in_any_order()
+    colors = 40.times.map {|i| [0, 0, 0].tap {_1[i % 3] = 1}}
+    load_video colors, 'mp4' do |v|
+      # sequential, skip forward, seek back, jump to the end, back to the head
+      [0, 1, 2, 10, 5, 39, 0, 20].each do |i|
+        rgb = v[i][5, 5].to_a[0, 3]
+        assert_equal i % 3, rgb.index(rgb.max), "frame #{i}: #{rgb}"
+      end
+    end
+  end
+
+  def test_load_frame_is_readonly()
+    load_video [[1, 0, 0], [0, 1, 0]] do |v|
+      f = v[0]
+      assert_true  f.frozen?
+      assert_equal color(1, 0, 0, 1), f[5, 5]
+      assert_raise(FrozenError) {f.paint {}}
+      assert_raise(FrozenError) {f[5, 5] = color(0, 0, 1, 1)}
+
+      d = f.dup
+      assert_false d.frozen?
+      d[5, 5] = color(0, 0, 1, 1)
+      assert_equal color(0, 0, 1, 1), d[5, 5]
+      assert_equal color(1, 0, 0, 1), f[5, 5]
+    end
+  end
+
+  def test_load_frame_keeps_its_own_index()
+    load_video [[1, 0, 0], [0, 1, 0]] do |v|
+      a, b = v[0], v[1]
+      assert_equal color(1, 0, 0, 1), a[5, 5]
+      assert_equal color(0, 1, 0, 1), b[5, 5]
+      assert_equal color(1, 0, 0, 1), a[5, 5]
+
+      v.pos = 1
+      assert_equal color(0, 1, 0, 1), v.to_image[5, 5]
+      assert_equal color(1, 0, 0, 1), a[5, 5]
+    end
+  end
+
+  def test_load_transparent_frame_replaces_previous_pixels()
+    load_video [[1, 0, 0], [0, 0, 0, 0]] do |v|
+      assert_equal color(1, 0, 0, 1), v[0][5, 5]
+      assert_equal color(0, 0, 0, 0), v[1][5, 5]
+      assert_equal color(1, 0, 0, 1), v[0][5, 5]
+    end
+  end
+
+  def test_load_frame_replaced_by_dup_is_writable()
+    load_video [[1, 0, 0], [0, 1, 0]] do |v|
+      v[1] = v[1].dup
+      assert_false v[1].frozen?
+
+      v[1].paint {fill 0, 0, 1; rect 0, 0, 10, 10}
+      v.pos = 1
+      assert_equal color(0, 0, 1, 1), v.to_image[5, 5]
+      assert_equal color(1, 0, 0, 1), v[0][5, 5]
+    end
+  end
+
+  def test_load_frames_appended_to_another_video()
+    load_video [[1, 0, 0], [0, 1, 0]] do |v|
+      w = video
+      w.append v[1], v[0]
+      assert_true  w[0].frozen?
+      assert_equal color(0, 1, 0, 1), w[0][5, 5]
+      assert_equal color(1, 0, 0, 1), w[1][5, 5]
+      assert_equal color(1, 0, 0, 1), v[0][5, 5]
+    end
+  end
+
+  def test_load_dup_plays_independently()
+    load_video [[1, 0, 0], [0, 1, 0]] do |v|
+      w = v.dup
+      v.pos, w.pos = 0, 1
+      assert_equal color(1, 0, 0, 1), v.to_image[5, 5]
+      assert_equal color(0, 1, 0, 1), w.to_image[5, 5]
+      assert_equal color(1, 0, 0, 1), v.to_image[5, 5]
+    end
+  end
+
   def test_exts()
     assert_include Rays::Video.exts, 'mp4'
     assert_include Rays::Video.exts, 'gif'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays-video
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-04 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: beeps
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rays
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 description: Video encoding/decoding with audio support using Rays and Beeps.
 email: xordog@gmail.com
 executables: []
@@ -81,10 +81,10 @@ files:
 - ".github/workflows/release-gem.yml"
 - ".github/workflows/tag.yml"
 - ".github/workflows/test.yml"
-- ".github/workflows/utils.rb"
 - CONTRIBUTING.md
 - ChangeLog.md
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -103,7 +103,6 @@ files:
 - lib/rays/video.rb
 - rays-video.gemspec
 - src/ios/video.mm
-- src/ios/video_audio_in.h
 - src/ios/video_audio_in.mm
 - src/osx/video.mm
 - src/osx/video_audio_in.h
@@ -136,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Video support for Rays.

data/.github/workflows/utils.rb

@@ -1,127 +0,0 @@
-require 'shellwords'
-
-ALL_REPO        = 'xord/all'
-ALL_DIR         = '../all'
-ALL_FETCH_DEPTH = 100
-
-RENAMES = {reflex: 'reflexion'}
-
-def sh(cmd)
-  puts cmd
-  system cmd
-end
-
-def setup_dependencies(only: nil)
-  gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
-  return unless gemspec_path
-
-  gemspec = File.read gemspec_path
-  name    = File.basename gemspec_path, '.gemspec'
-
-  exts = File.readlines('Rakefile')
-    .map {|l| l[%r|^\s*require\W+([\w\-\_]+)/extension\W+$|, 1]}
-    .compact
-    .reject {|ext| ext == name}
-  exts = exts & [only].flatten.map(&:to_s) if only
-  return if exts.empty?
-
-  unless setup_dependencies_via_monorepo(exts)
-    setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  end
-
-  exts.each {|ext| sh %( cd ../#{ext} && rake ext )}
-end
-
-def setup_dependencies_via_monorepo(exts)
-  return false unless checkout_monorepo
-  exts.each {|ext| sh %( ln -snf all/#{ext} ../#{ext} )}
-  true
-end
-
-def checkout_monorepo()
-  uuid = `git log -1 --format=%B`[/^\[\[([0-9a-fA-F-]+)\]\]$/, 1]
-  return false unless uuid
-
-  commit = setup_monorepo uuid
-  return false unless commit
-
-  Dir.chdir(ALL_DIR) {sh %( git checkout -q #{commit} )}
-  true
-end
-
-def setup_monorepo(uuid)
-  unless File.directory? ALL_DIR
-    url = "https://github.com/#{ALL_REPO}.git"
-    sh %( git clone --no-tags --depth #{ALL_FETCH_DEPTH} #{url} #{ALL_DIR} )
-  end
-  loop do
-    commit = find_monorepo_commit uuid
-    return commit if commit
-
-    deepened = Dir.chdir ALL_DIR do
-      before = `git rev-list --count HEAD`.to_i
-      sh %( git fetch --deepen #{ALL_FETCH_DEPTH} )
-      `git rev-list --count HEAD`.to_i > before
-    end
-    return nil unless deepened
-  end
-end
-
-def find_monorepo_commit(uuid)
-  Dir.chdir ALL_DIR do
-    out = `git log origin/HEAD -F --grep="[[#{uuid}]]" --format=%H -1`.strip
-    out.empty? ? nil : out
-  end
-end
-
-def setup_dependencies_via_each_repo_by_version(gemspec, exts)
-  exts.each do |ext|
-    gem   = RENAMES[ext.to_sym].then {|s| s || ext}
-    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*~>\s*([\d\.]+)\s*['"]/, 1]
-    opts  = '-c advice.detachedHead=false --depth 1'
-    clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
-
-    # 'rake subtree:push' pushes all subrepos, so cloning by new tag
-    # often fails before tagging each new tag
-    sh %( #{clone} --branch v#{ver} || #{clone} )
-  end
-end
-
-def tag_versions()
-  changes = changelogs
-  tags    = `git tag`.lines chomp: true
-  vers    = `git log --oneline ./VERSION`
-    .lines(chomp: true)
-    .map {|line| line.split.first[/^\w+$/]}
-    .map {|sha| [`git cat-file -p #{sha}:./VERSION 2>/dev/null`[/[\d\.]+/], sha]}
-    .select {|ver, sha| ver && sha}
-    .reverse
-    .to_h
-
-  vers.to_a.reverse.each do |ver, sha|
-    tag = "v#{ver}"
-    break if tags.include?(tag)
-    sh %( git tag -a -m \"#{changes[tag]&.gsub '"', '\\"'}\" #{tag} #{sha} )
-  end
-end
-
-def release(*paths)
-  tag   = ENV['GITHUB_REF']&.sub(%r|^refs/tags/|, '') || raise('GITHUB_REF tag not set')
-  notes = (changelogs[tag] || '').shellescape
-  paths = paths.flatten.join ' '
-
-  sh(%( gh release create #{tag} #{paths} --notes #{notes} )) ||
-    sh(%( gh release upload #{tag} #{paths} --clobber )) ||
-    raise('failed to upload to releases')
-end
-
-def changelogs()
-  File.read('ChangeLog.md')
-    .split(/^\s*##\s*\[\s*(v[\d\.]+)\s*\].*$/)
-    .slice(1..)
-    .each_slice(2)
-    .to_h
-    .transform_values(&:strip!)
-rescue Errno::ENOENT
-  raise 'failed to get changelogs'
-end

data/src/ios/video_audio_in.h

@@ -1,22 +0,0 @@
-// -*- mode: objc -*-
-#pragma once
-#ifndef __RAYS_VIDEO_SRC_IOS_VIDEO_AUDIO_IN_H__
-#define __RAYS_VIDEO_SRC_IOS_VIDEO_AUDIO_IN_H__
-
-
-#import <AVFoundation/AVFoundation.h>
-#include "../video_audio_in.h"
-
-
-namespace Rays
-{
-
-
-	VideoAudioIn::Data* VideoAudioIn_Data_create (
-		AVAsset* asset, AVAssetTrack* audio_track);
-
-
-}// Rays
-
-
-#endif//EOH