bmff 0.0.1

data/test/bmff/box/test_media.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMedia < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mdia")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Media, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mdia", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_media_data.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMediaData < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mdat")
+    io.write_byte("abcdefg") # data
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MediaData, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mdat", box.type)
+  end
+end

data/test/bmff/box/test_media_header.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMediaHeader < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mdhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3482338006) # creation_time
+    io.write_uint32(3482338007) # modification_time
+    io.write_uint32(1000000) # timescale
+    io.write_uint32(30000000) # duration
+    io.write_byte("\x15\xC7") # language (eng)
+    io.write_uint16(0) # pre_defined
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MediaHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mdhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3482338006, box.creation_time)
+    assert_equal(3482338007, box.modification_time)
+    assert_equal(1000000, box.timescale)
+    assert_equal(30000000, box.duration)
+    assert_equal("eng", box.language)
+    assert_equal(0, box.pre_defined)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mdhd")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint64(3482338006) # creation_time
+    io.write_uint64(3482338007) # modification_time
+    io.write_uint32(1000000) # timescale
+    io.write_uint64(30000000) # duration
+    io.write_byte("\x2A\x0E") # language (jpn)
+    io.write_uint16(0) # pre_defined
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MediaHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mdhd", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3482338006, box.creation_time)
+    assert_equal(3482338007, box.modification_time)
+    assert_equal(1000000, box.timescale)
+    assert_equal(30000000, box.duration)
+    assert_equal("jpn", box.language)
+    assert_equal(0, box.pre_defined)
+  end
+end

data/test/bmff/box/test_media_information.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMediaInformation < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("minf")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MediaInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("minf", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_movie.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovie < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("moov")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::Movie, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("moov", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_movie_extends.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieExtends < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mvex")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieExtends, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mvex", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_movie_extends_header.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieExtendsHeader < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mehd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1000000) # fragment_duration
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieExtendsHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mehd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1000000, box.fragment_duration)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mehd")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint64(1000000) # fragment_duration
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieExtendsHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mehd", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1000000, box.fragment_duration)
+  end
+end

data/test/bmff/box/test_movie_fragment.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieFragment < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("moof")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieFragment, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("moof", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_movie_fragment_header.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieFragmentHeader < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # sequence_number
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.sequence_number)
+  end
+end

data/test/bmff/box/test_movie_fragment_random_access.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieFragmentRandomAccess < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mfra")
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieFragmentRandomAccess, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mfra", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_movie_fragment_random_access_offset.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieFragmentRandomAccessOffset < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mfro")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # mfra_size
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieFragmentRandomAccessOffset, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mfro", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.mfra_size)
+  end
+end

data/test/bmff/box/test_movie_header.rb

@@ -0,0 +1,110 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxMovieHeader < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mvhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3482338006) # creation_time
+    io.write_uint32(3482338007) # modification_time
+    io.write_uint32(1000000) # timescale
+    io.write_uint32(30000000) # duration
+    io.write_int32(65536) # rate
+    io.write_int16(256) # volume
+    io.write_byte("\x00\x00") # reserved1
+    io.write_uint32(0) # reserved2
+    io.write_uint32(0) # reserved2
+    io.write_int32(65536) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(65536) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(1073741824) # matrix
+    io.write_byte("\x00\x00\x00\x00" * 6) # pre_defined
+    io.write_uint32(1) # next_track_id
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mvhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3482338006, box.creation_time)
+    assert_equal(3482338007, box.modification_time)
+    assert_equal(1000000, box.timescale)
+    assert_equal(30000000, box.duration)
+    assert_equal(65536, box.rate)
+    assert_equal(256, box.volume)
+    assert_equal("\x00\x00", box.reserved1)
+    assert_equal([0, 0], box.reserved2)
+    assert_equal([65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], box.matrix)
+    assert_equal(["\x00\x00\x00\x00"] * 6, box.pre_defined)
+    assert_equal(1, box.next_track_id)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mvhd")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint64(3482338006) # creation_time
+    io.write_uint64(3482338007) # modification_time
+    io.write_uint32(1000000) # timescale
+    io.write_uint64(30000000) # duration
+    io.write_int32(65536) # rate
+    io.write_int16(256) # volume
+    io.write_byte("\x00\x00") # reserved1
+    io.write_uint32(0) # reserved2
+    io.write_uint32(0) # reserved2
+    io.write_int32(65536) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(65536) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(0) # matrix
+    io.write_int32(1073741824) # matrix
+    io.write_byte("\x00\x00\x00\x00" * 6) # pre_defined
+    io.write_uint32(1) # next_track_id
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::MovieHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mvhd", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3482338006, box.creation_time)
+    assert_equal(3482338007, box.modification_time)
+    assert_equal(1000000, box.timescale)
+    assert_equal(30000000, box.duration)
+    assert_equal(65536, box.rate)
+    assert_equal(256, box.volume)
+    assert_equal("\x00\x00", box.reserved1)
+    assert_equal([0, 0], box.reserved2)
+    assert_equal([65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], box.matrix)
+    assert_equal(["\x00\x00\x00\x00"] * 6, box.pre_defined)
+    assert_equal(1, box.next_track_id)
+  end
+end

data/test/bmff/box/test_null_media_header.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxNullMediaHeader < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("nmhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::NullMediaHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("nmhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+  end
+end

data/test/bmff/box/test_padding_bits.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxPaddingBits < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("padb")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # sample_count
+    # sample
+    2.times do |i|
+      io.write_uint8(118) # reserved1, pad1, reserved2, pad2
+    end
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::PaddingBits, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("padb", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_equal([false, false], box.reserved1)
+    assert_equal([7, 7], box.pad1)
+    assert_equal([false, false], box.reserved2)
+    assert_equal([6, 6], box.pad2)
+  end
+end

data/test/bmff/box/test_pixel_aspect_ratio.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxPixelAspectRatio < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("pasp")
+    io.write_uint32(16) # h_spacing
+    io.write_uint32(9) # v_spacing
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::PixelAspectRatio, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("pasp", box.type)
+    assert_equal(16, box.h_spacing)
+    assert_equal(9, box.v_spacing)
+  end
+end

data/test/bmff/box/test_progressive_download_info.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxProgressiveDownloadInfo < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("pdin")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(0) # rate
+    io.write_uint32(0) # initial_delay
+    io.write_uint32(255) # rate
+    io.write_uint32(65535) # initial_delay
+    io.write_uint32(16777215) # rate
+    io.write_uint32(4294967295) # initial_delay
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_instance_of(BMFF::Box::ProgressiveDownloadInfo, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("pdin", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal([0, 255, 16777215], box.rate)
+    assert_equal([0, 65535, 4294967295], box.initial_delay)
+  end
+end