bmff 0.0.1

data/test/bmff/box/test_track_fragment_random_access.rb

@@ -0,0 +1,96 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTrackFragmentRandomAccess < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfra")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # track_id
+    io.write_uint32(6) # reserved1,
+                       # length_size_of_traf_num (0),
+                       # length_size_of_trun_num (1),
+                       # length_size_of_sample_num (2)
+    io.write_uint32(3) # number_of_entry
+    3.times do |i|
+      io.write_uint32(i) # time
+      io.write_uint32(10 + i) # moof_offset
+
+      io.write_uint8(20 + i) # traf_number
+      io.write_uint16(30 + i) # trun_number
+      io.write_uint24(40 + i) # sample_number
+    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::TrackFragmentRandomAccess, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfra", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.track_id)
+    assert_equal(0, box.reserved1)
+    assert_equal(0, box.length_size_of_traf_num)
+    assert_equal(1, box.length_size_of_trun_num)
+    assert_equal(2, box.length_size_of_sample_num)
+    assert_equal([0, 1, 2], box.time)
+    assert_equal([10, 11, 12], box.moof_offset)
+    assert_equal([20, 21, 22], box.traf_number)
+    assert_equal([30, 31, 32], box.trun_number)
+    assert_equal([40, 41, 42], box.sample_number)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfra")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # track_id
+    io.write_uint32(57) # reserved1,
+                        # length_size_of_traf_num (3),
+                        # length_size_of_trun_num (2),
+                        # length_size_of_sample_num (1)
+    io.write_uint32(3) # number_of_entry
+    3.times do |i|
+      io.write_uint64(4294967296 + i) # time
+      io.write_uint64(4294967306 + i) # moof_offset
+
+      io.write_uint32(20 + i) # traf_number
+      io.write_uint24(30 + i) # trun_number
+      io.write_uint16(40 + i) # sample_number
+    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::TrackFragmentRandomAccess, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfra", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.track_id)
+    assert_equal(0, box.reserved1)
+    assert_equal(3, box.length_size_of_traf_num)
+    assert_equal(2, box.length_size_of_trun_num)
+    assert_equal(1, box.length_size_of_sample_num)
+    assert_equal([4294967296, 4294967297, 4294967298], box.time)
+    assert_equal([4294967306, 4294967307, 4294967308], box.moof_offset)
+    assert_equal([20, 21, 22], box.traf_number)
+    assert_equal([30, 31, 32], box.trun_number)
+    assert_equal([40, 41, 42], box.sample_number)
+  end
+end

data/test/bmff/box/test_track_group.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 TestBMFFBoxTrackGroup < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trgr")
+    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::TrackGroup, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trgr", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_track_group_type.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 TestBMFFBoxTrackGroupType < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("msrc")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # track_group_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::TrackGroupType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("msrc", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.track_group_id)
+  end
+end

data/test/bmff/box/test_track_header.rb

@@ -0,0 +1,118 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTrackHeader < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tkhd")
+    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(1) # track_id
+    io.write_uint32(0) # reserved1
+    io.write_uint32(30000000) # duration
+    io.write_uint32(0) # reserved2
+    io.write_uint32(0) # reserved2
+    io.write_int16(0) # layer
+    io.write_int16(0) # alternate_group
+    io.write_int16(256) # volume
+    io.write_uint16(0) # reserved3
+    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_uint32(1920)
+    io.write_uint32(1080)
+    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::TrackHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tkhd", 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(1, box.track_id)
+    assert_equal(0, box.reserved1)
+    assert_equal(30000000, box.duration)
+    assert_equal([0, 0], box.reserved2)
+    assert_equal(0, box.layer)
+    assert_equal(0, box.alternate_group)
+    assert_equal(256, box.volume)
+    assert_equal(0, box.reserved3)
+    assert_equal([65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], box.matrix)
+    assert_equal(1920, box.width)
+    assert_equal(1080, box.height)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tkhd")
+    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(1) # track_id
+    io.write_uint32(0) # reserved1
+    io.write_uint64(30000000) # duration
+    io.write_uint32(0) # reserved2
+    io.write_uint32(0) # reserved2
+    io.write_int16(0) # layer
+    io.write_int16(0) # alternate_group
+    io.write_int16(0) # volume
+    io.write_uint16(0) # reserved3
+    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_uint32(1920)
+    io.write_uint32(1080)
+    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::TrackHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tkhd", 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(1, box.track_id)
+    assert_equal(0, box.reserved1)
+    assert_equal(30000000, box.duration)
+    assert_equal([0, 0], box.reserved2)
+    assert_equal(0, box.layer)
+    assert_equal(0, box.alternate_group)
+    assert_equal(0, box.volume)
+    assert_equal(0, box.reserved3)
+    assert_equal([65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], box.matrix)
+    assert_equal(1920, box.width)
+    assert_equal(1080, box.height)
+  end
+end

data/test/bmff/box/test_track_reference.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 TestBMFFBoxTrackReference < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tref")
+    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::TrackReference, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tref", box.type)
+    assert_equal([], box.children)
+    assert(box.container?)
+  end
+end

data/test/bmff/box/test_track_reference_type.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTrackReferenceType < MiniTest::Unit::TestCase
+  def test_parse_hint
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hint")
+    io.write_uint32(1) # track_ids
+    io.write_uint32(2) # track_ids
+    io.write_uint32(3) # track_ids
+    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::TrackReferenceType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hint", box.type)
+    assert_equal([1, 2, 3], box.track_ids)
+  end
+
+  def test_parse_cdsc
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("cdsc")
+    io.write_uint32(1) # track_ids
+    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::TrackReferenceType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("cdsc", box.type)
+    assert_equal([1], box.track_ids)
+  end
+
+  def test_parse_hind
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("hind")
+    io.write_uint32(1) # track_ids
+    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::TrackReferenceType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("hind", box.type)
+    assert_equal([1], box.track_ids)
+  end
+
+  def test_parse_vdep
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("vdep")
+    io.write_uint32(1) # track_ids
+    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::TrackReferenceType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("vdep", box.type)
+    assert_equal([1], box.track_ids)
+  end
+
+  def test_parse_cdsc
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("vplx")
+    io.write_uint32(1) # track_ids
+    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::TrackReferenceType, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("vplx", box.type)
+    assert_equal([1], box.track_ids)
+  end
+end

data/test/bmff/box/test_track_run.rb

@@ -0,0 +1,282 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTrackRun < MiniTest::Unit::TestCase
+  def test_parse_v0_flags_full_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x01 | 0x04 | 0x0100 | 0x0200 | 0x0400 | 0x0800) # flags
+    io.write_uint32(3) # sample_count
+    io.write_int32(2) # data_offset
+    io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      io.write_uint32(4 + i) # sample_duration
+      io.write_uint32(5 + i) # sample_size
+      io.write_uint32(6 + i) # sample_flags
+      io.write_uint32(7 + i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(3845, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_equal(2, box.data_offset)
+    assert_equal(3, box.first_sample_flags)
+    assert_equal([4, 5, 6], box.sample_duration)
+    assert_equal([5, 6, 7], box.sample_size)
+    assert_equal([6, 7, 8], box.sample_flags)
+    assert_equal([7, 8, 9], box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_data_offset_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x01) # flags
+    io.write_uint32(3) # sample_count
+    io.write_int32(2) # data_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(1, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_equal(2, box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_nil(box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_first_sample_flags_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x04) # flags
+    io.write_uint32(3) # sample_count
+    io.write_uint32(3) # first_sample_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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(4, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_equal(3, box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_nil(box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_sample_duration_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x0100) # flags
+    io.write_uint32(3) # sample_count
+    #io.write_int32(2) # data_offset
+    #io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      io.write_uint32(4 + i) # sample_duration
+      #io.write_uint32(5 + i) # sample_size
+      #io.write_uint32(6 + i) # sample_flags
+      #io.write_uint32(7 + i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(256, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_equal([4, 5, 6], box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_nil(box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_sample_size_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x0200) # flags
+    io.write_uint32(3) # sample_count
+    #io.write_int32(2) # data_offset
+    #io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      #io.write_uint32(4 + i) # sample_duration
+      io.write_uint32(5 + i) # sample_size
+      #io.write_uint32(6 + i) # sample_flags
+      #io.write_uint32(7 + i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(512, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_equal([5, 6, 7], box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_nil(box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_sample_flags_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x0400) # flags
+    io.write_uint32(3) # sample_count
+    #io.write_int32(2) # data_offset
+    #io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      #io.write_uint32(4 + i) # sample_duration
+      #io.write_uint32(5 + i) # sample_size
+      io.write_uint32(6 + i) # sample_flags
+      #io.write_uint32(7 + i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(1024, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_equal([6, 7, 8], box.sample_flags)
+    assert_nil(box.sample_composition_time_offset)
+  end
+
+  def test_parse_v0_flags_sample_composition_time_offset_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(0) # version
+    io.write_uint24(0x0800) # flags
+    io.write_uint32(3) # sample_count
+    #io.write_int32(2) # data_offset
+    #io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      #io.write_uint32(4 + i) # sample_duration
+      #io.write_uint32(5 + i) # sample_size
+      #io.write_uint32(6 + i) # sample_flags
+      io.write_uint32(7 + i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(0, box.version)
+    assert_equal(2048, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_equal([7, 8, 9], box.sample_composition_time_offset)
+  end
+
+  def test_parse_v1_flags_sample_composition_time_offset_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trun")
+    io.write_uint8(1) # version
+    io.write_uint24(0x0800) # flags
+    io.write_uint32(3) # sample_count
+    #io.write_int32(2) # data_offset
+    #io.write_uint32(3) # first_sample_flags
+    3.times do |i|
+      #io.write_uint32(4 + i) # sample_duration
+      #io.write_uint32(5 + i) # sample_size
+      #io.write_uint32(6 + i) # sample_flags
+      io.write_int32(0 - i) # sample_composition_time_offset
+    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::TrackRun, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trun", box.type)
+    assert_equal(1, box.version)
+    assert_equal(2048, box.flags)
+    assert_equal(3, box.sample_count)
+    assert_nil(box.data_offset)
+    assert_nil(box.first_sample_flags)
+    assert_nil(box.sample_duration)
+    assert_nil(box.sample_size)
+    assert_nil(box.sample_flags)
+    assert_equal([0, -1, -2], box.sample_composition_time_offset)
+  end
+end