bmff 0.0.1

data/lib/bmff/box/video_media_header.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+class BMFF::Box::VideoMediaHeader < BMFF::Box::Full
+  attr_accessor :graphicsmode, :opcolor
+  register_box "vmhd"
+
+  def parse_data
+    super
+    @graphicsmode = io.get_uint16
+    @opcolor = [io.get_uint16, io.get_uint16, io.get_uint16]
+  end
+end

data/lib/bmff/box/visual_sample_entry.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+class BMFF::Box::VisualSampleEntry < BMFF::Box::SampleEntry
+  attr_accessor :pre_defined1, :reserved2, :pre_defined2, :width, :height, :horizresolution, :vertresolution,
+                :reserved3, :frame_count, :compressorname, :depth, :pre_defined3,
+                :clean_aperture_box, :pixel_aspect_ratio_box
+  include(BMFF::Box::Container)
+
+  def parse_data
+    super
+    @pre_defined1 = io.get_uint16
+    @reserved2 = io.get_uint16
+    @pre_defined2 = [io.get_uint32, io.get_uint32, io.get_uint32]
+    @width = io.get_uint16
+    @height = io.get_uint16
+    @horizresolution = io.get_uint32
+    @vertresolution = io.get_uint32
+    @reserved3 = io.get_uint32
+    @frame_count = io.get_uint16
+    compressorname_size = io.get_uint8 & 0x1F
+    compressorname_buffer = io.get_ascii(31)
+    @compressorname = compressorname_buffer[0, compressorname_size]
+    @depth = io.get_uint16
+    @pre_defined3 = io.get_int16
+    until eob?
+      box = BMFF::Box.get_box(io, self)
+      add_child box
+      case box
+      when BMFF::Box::CleanAperture
+        @clean_aperture_box = box
+      when BMFF::Box::PixelAspectRatio
+        @pixel_aspect_ratio_box = box
+      end
+    end
+  end
+end

data/lib/bmff/box/xml_meta_data_sample_entry.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+class BMFF::Box::XMLMetaDataSampleEntry < BMFF::Box::MetaDataSampleEntry
+  attr_accessor :content_encoding, :namespace, :schema_location, :bit_rate_box
+  register_box "metx"
+  include(BMFF::Box::Container)
+
+  def parse_data
+    super
+    @content_encoding = io.get_null_terminated_string unless eob?
+    @namespace = io.get_null_terminated_string unless eob?
+    @schema_location = io.get_null_terminated_string unless eob?
+    unless eob?
+      @bit_rate_box = BMFF::Box.get_box(io, self, BMFF::Box::BitRate)
+      add_child @bit_rate_box
+    end
+  end
+end

data/lib/bmff/box.rb

@@ -0,0 +1,115 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+module BMFF::Box; end
+
+require "bmff/box/map"
+require "bmff/box/base"
+require "bmff/box/full"
+require "bmff/box/container"
+require "bmff/box/unknown"
+
+require "bmff/box/file_type"
+require "bmff/box/media_data"
+require "bmff/box/free_space"
+require "bmff/box/progressive_download_info"
+require "bmff/box/movie"
+require "bmff/box/movie_header"
+require "bmff/box/track"
+require "bmff/box/track_header"
+require "bmff/box/track_reference"
+require "bmff/box/track_reference_type"
+require "bmff/box/track_group"
+require "bmff/box/track_group_type"
+require "bmff/box/media"
+require "bmff/box/media_header"
+require "bmff/box/handler"
+require "bmff/box/media_information"
+require "bmff/box/video_media_header"
+require "bmff/box/sound_media_header"
+require "bmff/box/hint_media_header"
+require "bmff/box/null_media_header"
+require "bmff/box/sample_table"
+require "bmff/box/sample_entry"
+require "bmff/box/hint_sample_entry"
+require "bmff/box/bit_rate"
+require "bmff/box/meta_data_sample_entry"
+require "bmff/box/xml_meta_data_sample_entry"
+require "bmff/box/text_meta_data_sample_entry"
+require "bmff/box/uri"
+require "bmff/box/uri_init"
+require "bmff/box/uri_meta_sample_entry"
+require "bmff/box/pixel_aspect_ratio"
+require "bmff/box/clean_aperture"
+require "bmff/box/colour_information"
+require "bmff/box/visual_sample_entry"
+require "bmff/box/audio_sample_entry"
+require "bmff/box/sample_description"
+require "bmff/box/sample_size"
+require "bmff/box/compact_sample_size"
+require "bmff/box/degradation_priority"
+require "bmff/box/time_to_sample"
+require "bmff/box/composition_offset"
+require "bmff/box/composition_to_decode"
+require "bmff/box/sync_sample"
+require "bmff/box/shadow_sync_sample"
+require "bmff/box/sample_dependency_type"
+require "bmff/box/edit"
+require "bmff/box/edit_list"
+require "bmff/box/data_information"
+require "bmff/box/data_entry_url"
+require "bmff/box/data_entry_urn"
+require "bmff/box/data_reference"
+require "bmff/box/sample_to_chunk"
+require "bmff/box/chunk_offset"
+require "bmff/box/chunk_large_offset"
+require "bmff/box/padding_bits"
+require "bmff/box/sub_sample_information"
+require "bmff/box/sample_auxiliary_information_sizes"
+require "bmff/box/sample_auxiliary_information_offsets"
+require "bmff/box/movie_extends"
+require "bmff/box/movie_extends_header"
+require "bmff/box/track_extends"
+require "bmff/box/movie_fragment"
+require "bmff/box/movie_fragment_header"
+require "bmff/box/track_fragment"
+require "bmff/box/track_fragment_header"
+require "bmff/box/track_run"
+require "bmff/box/movie_fragment_random_access"
+require "bmff/box/track_fragment_random_access"
+require "bmff/box/movie_fragment_random_access_offset"
+require "bmff/box/track_fragment_base_media_decode_time"
+require "bmff/box/level_assignment"
+require "bmff/box/user_data"
+require "bmff/box/copyright"
+require "bmff/box/track_selection"
+
+module BMFF::Box
+  def self.get_box(io, parent, box_class = nil)
+    offset = io.pos
+    size = io.get_uint32
+    type = io.get_ascii(4)
+
+    if box_class
+      klass = box_class
+    else
+      klass = get_box_class(type)
+    end
+    box = klass.new
+    box.io = io
+    box.offset = offset
+    box.parent = parent
+    box.size = size
+    box.type = type
+
+    box.parse
+    return box
+  end
+
+  def self.get_box_class(type)
+    if klass = Map.get_box_class(type)
+      return klass
+    end
+    return BMFF::Box::Unknown
+  end
+end

data/lib/bmff/file_container.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+class BMFF::FileContainer
+  include(BMFF::Box::Container)
+  alias :boxes :children
+
+  def initialize(io)
+    @source_stream = io
+  end
+
+  def self.parse(io)
+    io.extend(BMFF::BinaryAccessor)
+    container = self.new(io)
+    until io.eof?
+      container.add_child BMFF::Box.get_box(io, container)
+    end
+    return container
+  end
+end

data/lib/bmff/version.rb

@@ -0,0 +1,3 @@
+module BMFF
+  VERSION = "0.0.1"
+end

data/lib/bmff.rb

@@ -0,0 +1,7 @@
+require "bmff/version"
+require "bmff/binary_accessor"
+require "bmff/box"
+require "bmff/file_container"
+
+module BMFF
+end

data/test/bmff/box/test_audio_sample_entry.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxAudioSampleEntry < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("mp4a")
+    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(1) # data_reference_index
+    io.write_uint32(0) # reserved2
+    io.write_uint32(0) # reserved2
+    io.write_uint16(2) # channelcount
+    io.write_uint16(16) # samplesize
+    io.write_uint16(0) # pre_defined
+    io.write_uint16(0) # reserved3
+    io.write_uint32(2890137600) # samplerate
+    size = io.pos
+    io.pos = 0
+    io.write_uint32(size)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil, BMFF::Box::AudioSampleEntry)
+    assert_instance_of(BMFF::Box::AudioSampleEntry, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("mp4a", box.type)
+    assert_equal([0, 0, 0, 0, 0, 0], box.reserved1)
+    assert_equal(1, box.data_reference_index)
+    assert_equal([0, 0], box.reserved2)
+    assert_equal(2, box.channelcount)
+    assert_equal(16, box.samplesize)
+    assert_equal(0, box.pre_defined)
+    assert_equal(0, box.reserved3)
+    assert_equal(2890137600, box.samplerate)
+  end
+end

data/test/bmff/box/test_base.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxBase < MiniTest::Unit::TestCase
+  def test_parse_largesize
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(1)
+    io.write_ascii("xxxx")
+    io.write_uint64(16)
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_equal(16, box.actual_size)
+    assert_equal(1, box.size)
+    assert_equal(16, box.largesize)
+    assert_equal("xxxx", box.type)
+  end
+
+  def test_parse_eof_size
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("xxxx")
+    io.pos = 0
+
+    box = BMFF::Box.get_box(io, nil)
+    assert_nil(box.actual_size)
+    assert_equal(0, box.size)
+    assert_nil(box.largesize)
+    assert_equal("xxxx", box.type)
+  end
+end

data/test/bmff/box/test_bit_rate.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 TestBMFFBoxBitRate < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    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::BitRate, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("btrt", box.type)
+    assert_equal(65535, box.buffer_size_db)
+    assert_equal(1000000, box.max_bitrate)
+    assert_equal(500000, box.avg_bitrate)
+  end
+end

data/test/bmff/box/test_chunk_large_offset.rb

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

data/test/bmff/box/test_chunk_offset.rb

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

data/test/bmff/box/test_clean_aperture.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxCleanAperture < MiniTest::Unit::TestCase
+  def test_parse
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("clap")
+    io.write_uint32(160) # clean_aperture_width_n
+    io.write_uint32(161) # clean_aperture_width_d
+    io.write_uint32(90) # clean_aperture_height_n
+    io.write_uint32(91) # clean_aperture_height_d
+    io.write_uint32(320) # horiz_off_n
+    io.write_uint32(321) # horiz_off_d
+    io.write_uint32(180) # vert_off_n
+    io.write_uint32(181) # vert_off_d
+    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::CleanAperture, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("clap", box.type)
+    assert_equal(160, box.clean_aperture_width_n)
+    assert_equal(161, box.clean_aperture_width_d)
+    assert_equal(90, box.clean_aperture_height_n)
+    assert_equal(91, box.clean_aperture_height_d)
+    assert_equal(320, box.horiz_off_n)
+    assert_equal(321, box.horiz_off_d)
+    assert_equal(180, box.vert_off_n)
+    assert_equal(181, box.vert_off_d)
+  end
+end

data/test/bmff/box/test_colour_information.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxColourInformation < MiniTest::Unit::TestCase
+  def test_parse_nclx
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("colr")
+    io.write_ascii("nclx") # colour_type
+    io.write_uint16(1) # colour_primaries
+    io.write_uint16(2) # transfer_characteristics
+    io.write_uint16(3) # matrix_coefficients
+    io.write_uint8(128) # full_range_flag reserved
+    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::ColourInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("colr", box.type)
+    assert_equal("nclx", box.colour_type)
+    assert_equal(1, box.colour_primaries)
+    assert_equal(2, box.transfer_characteristics)
+    assert_equal(3, box.matrix_coefficients)
+    assert(box.full_range_flag)
+    assert_equal(0, box.reserved1)
+  end
+
+  def test_parse_ricc
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("colr")
+    io.write_ascii("rICC") # colour_type
+    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::ColourInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("colr", box.type)
+    assert_equal("rICC", box.colour_type)
+    assert_equal(:restricted, box.icc_profile)
+  end
+
+  def test_parse_prof
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("colr")
+    io.write_ascii("prof") # colour_type
+    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::ColourInformation, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("colr", box.type)
+    assert_equal("prof", box.colour_type)
+    assert_equal(:unrestricted, box.icc_profile)
+  end
+end

data/test/bmff/box/test_compact_sample_size.rb

@@ -0,0 +1,99 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxCompactSampleSize < MiniTest::Unit::TestCase
+  def test_parse_filed_size_4
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stz2")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint24(0) # reserved1
+    io.write_uint8(4) # field_size
+    io.write_uint32(7) # sample_count
+    io.write_uint8(18) # entry_size 1 + 2
+    io.write_uint8(165) # entry_size 10 + 5
+    io.write_uint8(15) # entry_size 0 + 15
+    io.write_uint8(240) # entry_size 15 + 0 padding
+    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::CompactSampleSize, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stz2", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.reserved1)
+    assert_equal(4, box.field_size)
+    assert_equal(7, box.sample_count)
+    assert_equal([1, 2, 10, 5, 0, 15, 15], box.entry_size)
+  end
+
+  def test_parse_filed_size_8
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stz2")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint24(0) # reserved1
+    io.write_uint8(8) # field_size
+    io.write_uint32(3) # sample_count
+    3.times do |i|
+      io.write_uint8(i) # entry_size
+    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::CompactSampleSize, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stz2", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.reserved1)
+    assert_equal(8, box.field_size)
+    assert_equal(3, box.sample_count)
+    assert_equal([0, 1, 2], box.entry_size)
+  end
+
+  def test_parse_filed_size_16
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("stz2")
+    io.write_uint8(0) # version
+    io.write_uint24(0) # flags
+    io.write_uint24(0) # reserved1
+    io.write_uint8(16) # field_size
+    io.write_uint32(3) # sample_count
+    3.times do |i|
+      io.write_uint16(i) # entry_size
+    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::CompactSampleSize, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("stz2", box.type)
+    assert_equal(0, box.version)
+    assert_equal(0, box.flags)
+    assert_equal(0, box.reserved1)
+    assert_equal(16, box.field_size)
+    assert_equal(3, box.sample_count)
+    assert_equal([0, 1, 2], box.entry_size)
+  end
+end

data/test/bmff/box/test_composition_offset.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+# vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2 autoindent:
+
+require_relative '../../minitest_helper'
+require 'bmff/box'
+require 'stringio'
+
+class TestBMFFBoxCompositionOffset < MiniTest::Unit::TestCase
+  def test_parse_v0
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("ctts")
+    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_count
+      io.write_uint32(10 + i) # sample_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::CompositionOffset, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("ctts", 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_count)
+    assert_equal([10, 11, 12], box.sample_offset)
+  end
+
+  def test_parse_v1
+    io = StringIO.new("", "r+:ascii-8bit")
+    io.extend(BMFF::BinaryAccessor)
+    io.write_uint32(0)
+    io.write_ascii("ctts")
+    io.write_uint8(1) # version
+    io.write_uint24(0) # flags
+    io.write_uint32(3) # entry_count
+    3.times do |i|
+      io.write_uint32(i) # sample_count
+      io.write_int32(10 + i) # sample_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::CompositionOffset, box)
+    assert_equal(size, box.actual_size)
+    assert_equal("ctts", 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_count)
+    assert_equal([10, 11, 12], box.sample_offset)
+  end
+end