bmff 0.0.1

data/test/bmff/box/test_sample_to_chunk.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxSampleToChunk < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stsc")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    # entry
+    3.times do |i|
+      io.write_uint32(i) # first_chunk
+      io.write_uint32(10 + i) # samples_per_chunk
+      io.write_uint32(20 + i) # sample_description_index
+    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::SampleToChunk, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stsc", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([0, 1, 2], box.first_chunk)
+    assert_equal([10, 11, 12], box.samples_per_chunk)
+    assert_equal([20, 21, 22], box.sample_description_index)
+  end
+end

data/test/bmff/box/test_shadow_sync_sample.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 TestBMFFBoxShadowSyncSample < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stsh")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint32(i) # shadowed_sample_number
+      io.write_uint32(10 + i) # sync_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::ShadowSyncSample, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stsh", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([0, 1, 2], box.shadowed_sample_number)
+    assert_equal([10, 11, 12], box.sync_sample_number)
+  end
+end

data/test/bmff/box/test_sound_media_header.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxSoundMediaHeader < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("smhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_int16(0) # balance
+    io.write_uint16(0) # reserved1
+    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::SoundMediaHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("smhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.balance)
+    assert_equal(0, box.reserved1)
+  end
+end

data/test/bmff/box/test_sub_sample_information.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxSubSampleInformation < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("subs")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    # entry
+    3.times do |i|
+      io.write_uint32(i) # sample_delta
+      io.write_uint16(2) # subsample_count
+      2.times do |j|
+        io.write_uint16(j) # subsample_size
+        io.write_uint8(10 + j) # subsample_priority
+        io.write_uint8(0) # discardable
+        io.write_uint32(0) # reserved1
+      end
+    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::SubSampleInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("subs", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([0, 1, 2], box.sample_delta)
+    assert_equal([2, 2, 2], box.subsample_count)
+    3.times do |i|
+      assert_equal([0, 1], box.subsamples[i].subsample_size)
+      assert_equal([10, 11], box.subsamples[i].subsample_priority)
+      assert_equal([0, 0], box.subsamples[i].discardable)
+      assert_equal([0, 0], box.subsamples[i].reserved1)
+    end
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("subs")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    # entry
+    3.times do |i|
+      io.write_uint32(i) # sample_delta
+      io.write_uint16(2) # subsample_count
+      2.times do |j|
+        io.write_uint32(j) # subsample_size
+        io.write_uint8(10 + j) # subsample_priority
+        io.write_uint8(0) # discardable
+        io.write_uint32(0) # reserved1
+      end
+    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::SubSampleInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("subs", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([0, 1, 2], box.sample_delta)
+    assert_equal([2, 2, 2], box.subsample_count)
+    3.times do |i|
+      assert_equal([0, 1], box.subsamples[i].subsample_size)
+      assert_equal([10, 11], box.subsamples[i].subsample_priority)
+      assert_equal([0, 0], box.subsamples[i].discardable)
+      assert_equal([0, 0], box.subsamples[i].reserved1)
+    end
+  end
+end

data/test/bmff/box/test_sync_sample.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxSyncSample < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stss")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint32(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::SyncSample, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stss", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([0, 1, 2], box.sample_number)
+  end
+end

data/test/bmff/box/test_text_meta_data_sample_entry.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTextMetaDataSampleEntry < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mett")
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint8(0) # reserved1
+    io.write_uint16(0) # data_reference_index
+    io.write_null_terminated_string("application/zip") # content_encoding
+    io.write_null_terminated_string("text/html") # mime_format
+    # bit_rate_box
+    io.write_uint32(20)
+    io.write_ascii("btrt")
+    io.write_uint32(65535) # buffer_size_db
+    io.write_uint32(1000000) # max_bitrate
+    io.write_uint32(500000) # avg_bitrate
+    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::TextMetaDataSampleEntry, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mett", box.type)
+    assert_equal([0, 0, 0, 0, 0, 0], box.reserved1)
+    assert_equal(0, box.data_reference_index)
+    assert_equal("application/zip", box.content_encoding)
+    assert_equal("text/html", box.mime_format)
+    assert_instance_of(BMFF::Box::BitRate, box.bit_rate_box)
+    assert_equal(20, box.bit_rate_box.actual_size)
+    assert_equal("btrt", box.bit_rate_box.type)
+    assert_equal(65535, box.bit_rate_box.buffer_size_db)
+    assert_equal(1000000, box.bit_rate_box.max_bitrate)
+    assert_equal(500000, box.bit_rate_box.avg_bitrate)
+  end
+end

data/test/bmff/box/test_time_to_sample.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 TestBMFFBoxTimeToSample < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stts")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint32(20 + i) # sample_count
+      io.write_uint32(10 + i) # sample_delta
+    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::TimeToSample, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stts", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(3, box.entry_count)
+    assert_equal([20, 21, 22], box.sample_count)
+    assert_equal([10, 11, 12], box.sample_delta)
+  end
+end

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

data/test/bmff/box/test_track_extends.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 TestBMFFBoxTrackExtends < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("trex")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # track_id
+    io.write_uint32(2) # default_sample_description_index
+    io.write_uint32(3) # default_sample_duration
+    io.write_uint32(4) # default_sample_size
+    io.write_uint32(5) # default_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::TrackExtends, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("trex", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.track_id)
+    assert_equal(2, box.default_sample_description_index)
+    assert_equal(3, box.default_sample_duration)
+    assert_equal(4, box.default_sample_size)
+    assert_equal(5, box.default_sample_flags)
+  end
+end

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

data/test/bmff/box/test_track_fragment_base_media_decode_time.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 TestBMFFBoxTrackFragmentBaseMediaDecodeTime < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfdt")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(1) # base_media_decode_time
+    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::TrackFragmentBaseMediaDecodeTime, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfdt", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(1, box.base_media_decode_time)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfdt")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint64(4294967296) # base_media_decode_time
+    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::TrackFragmentBaseMediaDecodeTime, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfdt", box.type)
+    assert_equal(1, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(4294967296, box.base_media_decode_time)
+  end
+end

data/test/bmff/box/test_track_fragment_header.rb

@@ -0,0 +1,200 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxTrackFragmentHeader < MiniTest::Unit::TestCase
+  def test_parse_flags_full_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x01 | 0x02 | 0x08 | 0x10 | 0x20) # flags
+    io.write_uint32(1) # track_id
+    io.write_uint64(2) # base_data_offset
+    io.write_uint32(3) # sample_description_index
+    io.write_uint32(4) # default_sample_duration
+    io.write_uint32(5) # default_sample_size
+    io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(59, box.flags)
+    assert_equal(1, box.track_id)
+    assert_equal(2, box.base_data_offset)
+    assert_equal(3, box.sample_description_index)
+    assert_equal(4, box.default_sample_duration)
+    assert_equal(5, box.default_sample_size)
+    assert_equal(6, box.default_sample_flags)
+  end
+
+  def test_parse_flags_base_data_offset_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x01) # flags
+    io.write_uint32(1) # track_id
+    io.write_uint64(2) # base_data_offset
+    #io.write_uint32(3) # sample_description_index
+    #io.write_uint32(4) # default_sample_duration
+    #io.write_uint32(5) # default_sample_size
+    #io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(1, box.flags)
+    assert_equal(1, box.track_id)
+    assert_equal(2, box.base_data_offset)
+    assert_nil(box.sample_description_index)
+    assert_nil(box.default_sample_duration)
+    assert_nil(box.default_sample_size)
+    assert_nil(box.default_sample_flags)
+  end
+
+  def test_parse_flags_sample_description_index_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x02) # flags
+    io.write_uint32(1) # track_id
+    #io.write_uint64(2) # base_data_offset
+    io.write_uint32(3) # sample_description_index
+    #io.write_uint32(4) # default_sample_duration
+    #io.write_uint32(5) # default_sample_size
+    #io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(2, box.flags)
+    assert_equal(1, box.track_id)
+    assert_nil(box.base_data_offset)
+    assert_equal(3, box.sample_description_index)
+    assert_nil(box.default_sample_duration)
+    assert_nil(box.default_sample_size)
+    assert_nil(box.default_sample_flags)
+  end
+
+  def test_parse_flags_default_sample_duration_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x08) # flags
+    io.write_uint32(1) # track_id
+    #io.write_uint64(2) # base_data_offset
+    #io.write_uint32(3) # sample_description_index
+    io.write_uint32(4) # default_sample_duration
+    #io.write_uint32(5) # default_sample_size
+    #io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(8, box.flags)
+    assert_equal(1, box.track_id)
+    assert_nil(box.base_data_offset)
+    assert_nil(box.sample_description_index)
+    assert_equal(4, box.default_sample_duration)
+    assert_nil(box.default_sample_size)
+    assert_nil(box.default_sample_flags)
+  end
+
+  def test_parse_flags_default_sample_size_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x10) # flags
+    io.write_uint32(1) # track_id
+    #io.write_uint64(2) # base_data_offset
+    #io.write_uint32(3) # sample_description_index
+    #io.write_uint32(4) # default_sample_duration
+    io.write_uint32(5) # default_sample_size
+    #io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(16, box.flags)
+    assert_equal(1, box.track_id)
+    assert_nil(box.base_data_offset)
+    assert_nil(box.sample_description_index)
+    assert_nil(box.default_sample_duration)
+    assert_equal(5, box.default_sample_size)
+    assert_nil(box.default_sample_flags)
+  end
+
+  def test_parse_flags_default_sample_flags_present
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("tfhd")
+    io.write_uint8(0) # version
+    io.write_uint24(0x20) # flags
+    io.write_uint32(1) # track_id
+    #io.write_uint64(2) # base_data_offset
+    #io.write_uint32(3) # sample_description_index
+    #io.write_uint32(4) # default_sample_duration
+    #io.write_uint32(5) # default_sample_size
+    io.write_uint32(6) # default_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::TrackFragmentHeader, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("tfhd", box.type)
+    assert_equal(0, box.version)
+    assert_equal(32, box.flags)
+    assert_equal(1, box.track_id)
+    assert_nil(box.base_data_offset)
+    assert_nil(box.sample_description_index)
+    assert_nil(box.default_sample_duration)
+    assert_nil(box.default_sample_size)
+    assert_equal(6, box.default_sample_flags)
+  end
+end