mp4-rb 0.1.0

data/lib/mp4/binary/fixed_point8.rb

@@ -0,0 +1,19 @@
+module MP4::Binary
+  class FixedPoint8 < BinData::BasePrimitive
+    def value_to_binary_string(value)
+      value = (value.to_i * (2.0**8)).to_i
+
+      BinData::Int16be.new(value).to_binary_s
+    end
+
+    def read_and_return_value(io)
+      raw_value = BinData::Int16be.read read_uint32(io)
+
+      (raw_value / (2.0**8)).to_i
+    end
+
+    def read_uint32(io)
+      io.readbytes(2)
+    end
+  end
+end

data/lib/mp4/binary/ftyp.rb

@@ -0,0 +1,9 @@
+module MP4::Binary
+  class Ftyp < BinData::Record
+    endian :big
+
+    string :major_brand, length: 4
+    uint32 :minor_version
+    rest :compatible_brands
+  end
+end

data/lib/mp4/binary/gmhd.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Gmhd < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/hdlr.rb

@@ -0,0 +1,13 @@
+module MP4::Binary
+  class Hdlr < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint32 :pre_defined, value: 0
+    string :handler_type, length: 4
+    skip length: 4 * 3
+    rest :handler_name
+  end
+end

data/lib/mp4/binary/hev1.rb

@@ -0,0 +1,73 @@
+module MP4::Binary
+  class FieldInfoBox < BinData::Record
+    endian :big
+    uint32 :atom_size
+    string :atom_type, length: 4, assert: "fiel"
+    uint8  :counts
+    uint8  :order
+  end
+
+  class PixelAspectRatioBox < BinData::Record
+    endian :big
+    uint32 :atom_size
+    string :atom_type, length: 4, assert: "pasp"
+    uint32 :h_spacing
+    uint32 :v_spacing
+  end
+
+  class BitRateBox < BinData::Record
+    endian :big
+    uint32 :atom_size
+    string :atom_type, length: 4, assert: "btrt"
+    uint32 :buffer_size_db
+    uint32 :max_bitrate
+    uint32 :avg_bitrate
+  end
+
+  class CodecOptions < BinData::Record
+    endian :big
+    array  :reserved1, type: :uint8, initial_length: 6
+    uint16 :data_reference_index
+    uint16 :reserved2
+    uint16 :reserved3
+    uint32 :reserved4
+    uint16 :reserved5
+    uint16 :reserved6
+    uint32 :reserved7
+    uint16 :width
+    uint16 :height
+    uint32 :horizontal_resolution
+    uint32 :vertical_resolution
+    uint32 :reserved8
+    uint16 :frame_count
+    string :compressor_name, length: 32
+    uint16 :bit_depth
+    int16  :reserved9
+    rest :all_rest
+  end
+
+  module Hev1
+
+    def self.read(bytes)
+      hev1 = CodecOptions.read(bytes)
+      pasp = find_atom(bytes, 'pasp', PixelAspectRatioBox)
+      bitrate = find_atom(bytes, 'btrt', BitRateBox)
+
+      {
+        width: hev1.width,
+        height: hev1.height,
+        pasp: pasp,
+        bitrate: bitrate,
+      }
+    end
+
+    def self.find_atom(bytes, atom_name, atom_handler)
+      atom_name_position = bytes.index(atom_name)
+      atom_start_pos = atom_name_position - 4
+      atom_size = BinData::Uint32be.read(bytes[atom_start_pos..atom_start_pos + 4]).to_i
+      atom_bytes = bytes[atom_start_pos..atom_start_pos + 4 + atom_size]
+
+      atom_handler.read(atom_bytes)
+    end
+  end
+end

data/lib/mp4/binary/hmhd.rb

@@ -0,0 +1,14 @@
+module MP4::Binary
+  class Hmhd < BinData::Record
+    endian :big
+
+    uint8  :version, value: 0
+    bit24  :flags,   value: 0
+
+    uint16 :max_pdu_size
+    uint16 :avg_pdu_size
+    uint32 :max_bitrate
+    uint32 :avg_bitrate
+    uint32 :reserved, value: 0
+  end
+end

data/lib/mp4/binary/iods.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Iods < ::BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/mdhd.rb

@@ -0,0 +1,18 @@
+module MP4::Binary
+  class Mdhd < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint32 :creation_time
+    uint32 :modification_time
+    uint32 :timescale
+    uint32 :duration
+
+    bit1 :pad, value: 0
+    array :language, initial_length: 3, type: :bit5
+
+    skip length: 2
+  end
+end

data/lib/mp4/binary/mp4a.rb

@@ -0,0 +1,76 @@
+module MP4::Binary
+  class Base128Size < BinData::Primitive
+    endian :big
+    array :size_bytes, type: :uint8, read_until: -> { (element & 0x80).zero? }
+
+    def get
+      size_bytes.inject(0) { |acc, byte| (acc << 7) | (byte & 0x7f) }
+    end
+
+    def set(v)
+      self.size_bytes = []
+      while v.positive?
+        self.size_bytes.unshift((v & 0x7f) | 0x80)
+        v >>= 7
+      end
+      self.size_bytes[-1] &= 0x7f
+    end
+  end
+
+  class DecoderSpecificInfo < BinData::Record
+    endian :big
+    uint8  :tag, assert: 0x05  # Tag for DecoderSpecificInfo
+    base128_size :len
+    string :info, read_length: :len
+  end
+
+  class DecoderConfigDescriptor < BinData::Record
+    endian :big
+    uint8  :tag, assert: 0x04
+    base128_size :len
+    uint8  :object_type_indication
+    bit6   :stream_type
+    bit1   :up_stream
+    bit1   :reserved
+    uint24 :buffer_size_db
+    uint32 :max_bitrate
+    uint32 :avg_bitrate
+    decoder_specific_info :dec_specific_info
+  end
+
+  class EsDescriptor < BinData::Record
+    endian :big
+    uint8  :tag, assert: 0x03  # Tag for ESDescriptor
+    base128_size :len
+    uint16 :es_id
+    bit1   :stream_dependence_flag
+    bit1   :url_flag
+    bit1   :ocr_stream_flag
+    bit5   :stream_priority
+    decoder_config_descriptor :dec_config_desc
+  end
+
+  class Esds < BinData::Record
+    endian :big
+    uint32 :atom_size
+    string :atom_type, read_length: 4, assert: -> { value == "esds" }
+    uint8  :version
+    bit24  :flags
+    es_descriptor :es_descriptor
+  end
+
+  class Mp4a < BinData::Record
+    endian :big
+    array  :reserved1, type: :uint8, initial_length: 6
+    uint16 :data_reference_index
+    uint16 :version
+    uint16 :revision_level
+    uint32 :vendor
+    uint16 :channel_count
+    uint16 :sample_size
+    uint16 :compression_id
+    uint16 :packet_size
+    uint32 :sample_rate
+    esds :esds
+  end
+end

data/lib/mp4/binary/mvhd.rb

@@ -0,0 +1,39 @@
+module MP4::Binary
+  class Mvhd < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint32 :creation_time
+    uint32 :modification_time
+    uint32 :timescale
+    uint32 :duration
+
+    fixed_point16 :rate
+    fixed_point8 :volume
+
+    skip length: 2 + 4 + 4
+
+    array :matrix, initial_length: 9, type: :uint32
+
+    skip length: 4 * 6
+
+    uint32 :next_track_id
+  end
+end
+# ISO/IEC 14496-12:2015(E)
+# SEMANTICS:
+# `version` - is an integer that specifies the version of this box (0 or 1 in this specification) creation_time is an integer that declares the creation time of the presentation (in seconds
+# `since` - midnight, Jan. 1, 1904, in UTC time)
+# `modification_time` - is an integer that declares the most recent time the presentation was
+# `modified` - (in seconds since midnight, Jan. 1, 1904, in UTC time)
+# `timescale` - is an integer that specifies the time‐scale for the entire presentation; this is the
+# `number` - of time units that pass in one second. For example, a time coordinate system that
+# `measures` - time in sixtieths of a second has a time scale of 60.
+# `duration` - is an integer that declares length of the presentation (in the indicated timescale). This
+# `property` - is derived from the presentation’s tracks: the value of this field corresponds to the duration of the longest track in the presentation. If the duration cannot be determined then duration is set to all 1s.
+# `rate` - is a fixed point 16.16 number that indicates the preferred rate to play the presentation; 1.0 (0x00010000) is normal forward playback
+# `volume` - is a fixed point 8.8 number that indicates the preferred playback volume. 1.0 (0x0100) is full volume.
+# `matrix - provides a transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex values (0,0,0x40000000).
+# `next_track_ID` - is a non‐zero integer that indicates a value to use for the track ID of the next track to be added to this presentation. Zero is not a valid track ID value. The value of next_track_ID shall be larger than the largest track‐ID in use. If this value is equal to all 1s (32‐bit maxint), and a new media track is to be added, then a search must be made in the file for an unused track identifier.

data/lib/mp4/binary/nmhd.rb

@@ -0,0 +1,8 @@
+module MP4::Binary
+  class Nmhd < BinData::Record
+    endian :big
+
+    uint8 :version, value: 0
+    bit24 :flags,   value: 0
+  end
+end

data/lib/mp4/binary/saio.rb

@@ -0,0 +1,25 @@
+module MP4::Binary
+  class Saio < BinData::Record
+    endian :big
+
+    uint8  :version
+    bit24  :flags
+
+    uint32 :aux_info_type,           onlyif: -> { (flags & 0x000001).nonzero? }
+    uint32 :aux_info_type_parameter, onlyif: -> { (flags & 0x000001).nonzero? }
+
+    uint32 :entry_count
+    array  :offsets_32,
+           type: :uint32,
+           initial_length: :entry_count,
+           onlyif: -> { version.zero? }
+    array  :offsets_64,
+           type: :uint64,
+           initial_length: :entry_count,
+           onlyif: -> { version == 1 }
+
+    def offsets
+      version.zero? ? offsets_32.to_a : offsets_64.to_a
+    end
+  end
+end

data/lib/mp4/binary/saiz.rb

@@ -0,0 +1,17 @@
+module MP4::Binary
+  class Saiz < BinData::Record
+    endian :big
+
+    uint8  :version
+    bit24  :flags
+
+    uint32 :aux_info_type,           onlyif: -> { (flags & 0x000001).nonzero? }
+    uint32 :aux_info_type_parameter, onlyif: -> { (flags & 0x000001).nonzero? }
+
+    uint8  :default_sample_info_size
+    uint32 :sample_count
+    array  :sample_info_sizes,
+           type: :uint8,
+           initial_length: -> { default_sample_info_size.zero? ? sample_count : 0 }
+  end
+end

data/lib/mp4/binary/sbgp.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Sbgp < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/sdtp.rb

@@ -0,0 +1,18 @@
+module MP4::Binary
+  class SampleDependency < BinData::Record
+    endian :big
+
+    bit2 :reserved
+    bit2 :sample_depends_on
+    bit2 :sample_is_depended_on
+    bit2 :sample_has_redundancy
+  end
+
+  class Sdtp < BinData::Record
+    endian :big
+
+    array :samples, read_until: :eof do
+      sample_dependency :sample_dependency
+    end
+  end
+end

data/lib/mp4/binary/senc.rb

@@ -0,0 +1,12 @@
+module MP4::Binary
+  class Senc < BinData::Record
+    endian :big
+
+    uint8 :version
+    bit24 :flags
+
+    uint32 :sample_count
+
+    rest :raw_entries
+  end
+end

data/lib/mp4/binary/sgpd.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Sgpd < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/smhd.rb

@@ -0,0 +1,11 @@
+module MP4::Binary
+  class Smhd < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    int16 :balance, value: 0
+    uint16 :reserved, value: 0
+  end
+end

data/lib/mp4/binary/stco.rb

@@ -0,0 +1,13 @@
+module MP4::Binary
+  class Stco < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :chunks_count
+    array :offsets, initial_length: :chunks_count do
+      uint32 :chunk_offset
+    end
+  end
+end

data/lib/mp4/binary/stco_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class StcoReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/sthd.rb

@@ -0,0 +1,8 @@
+module MP4::Binary
+  class Sthd < BinData::Record
+    endian :big
+
+    uint8 :version, value: 0
+    bit24 :flags,   value: 0
+  end
+end

data/lib/mp4/binary/stsc.rb

@@ -0,0 +1,15 @@
+module MP4::Binary
+  class Stsc < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :chunk_count
+    array :table, initial_length: :chunk_count do
+      uint32 :first_chunk
+      uint32 :samples_per_chunk
+      uint32 :sample_description_index
+    end
+  end
+end

data/lib/mp4/binary/stsc_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class StscReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/stsd.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Stsd < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/stsd_atom.rb

@@ -0,0 +1,11 @@
+module MP4::Binary
+  class StsdAtom < BinData::Record
+    endian :big
+
+    uint8  :version
+    bit24  :flags
+
+    uint32 :codecs_count
+    array  :codecs, type: :codec, initial_length: :codecs_count
+  end
+end

data/lib/mp4/binary/stsd_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class StsdReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/stss.rb

@@ -0,0 +1,13 @@
+module MP4::Binary
+  class Stss < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :sync_samples_count
+    array :sync_sample, initial_length: :sync_samples_count do
+      uint32 :sample_number
+    end
+  end
+end

data/lib/mp4/binary/stss_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class StssReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/stsz.rb

@@ -0,0 +1,18 @@
+module MP4::Binary
+  class Stsz < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :sample_size
+    uint32 :sample_count
+    array :sample_sizes, initial_length: :sample_count, onlyif: :has_list? do
+      uint32 :sample_size
+    end
+
+    def has_list?
+      sample_size.zero?
+    end
+  end
+end

data/lib/mp4/binary/stsz_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class StszReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/stts.rb

@@ -0,0 +1,14 @@
+module MP4::Binary
+  class Stts < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :entries_count
+    array :time_to_sample, initial_length: :entries_count do
+      uint32 :sample_count
+      uint32 :sample_delta
+    end
+  end
+end

data/lib/mp4/binary/stts_reader.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class SttsReader < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/tkhd.rb

@@ -0,0 +1,46 @@
+module MP4::Binary
+  class Tkhd < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint32 :creation_time
+    uint32 :modification_time
+    uint32 :track_id
+    skip length: 4
+    uint32 :duration
+
+    skip length: 4 + 4
+
+    int16 :layer
+    int16 :alternate_group
+    fixed_point8 :volume
+
+    skip length: 2
+
+    array :matrix, initial_length: 9, type: :uint32
+
+    fixed_point16 :width
+    fixed_point16 :height
+  end
+end
+# ISO/IEC 14496-12:2015(E)
+# SEMANTICS:
+# `version` is an integer that specifies the version of this box (0 or 1 in this specification)
+# `flags` is a 24‐bit integer with flags; the following values are defined:
+# - `Track_enabled`: Indicates that the track is enabled. Flag value is 0x000001. A disabled track (the low bit is zero) is treated as if it were not present.
+# - `Track_in_movie`: Indicates that the track is used in the presentation. Flag value is 0x000002. Track_in_preview: Indicates that the track is used when previewing the presentation. Flag value is 0x000004.
+# - `Track_size_is_aspect_ratio`: Indicates that the width and height fields are not expressed in pixel units. The values have the same units but these units are not specified. The values are only an indication of the desired aspect ratio. If the aspect ratios of this track and other related tracks are not identical, then the respective positioning of the tracks is undefined, possibly defined by external contexts. Flag value is 0x000008.
+# `creation_time` is an integer that declares the creation time of this track (in seconds since midnight, Jan. 1, 1904, in UTC time).
+# `modification_time` is an integer that declares the most recent time the track was modified (in seconds since midnight, Jan. 1, 1904, in UTC time).
+# `track_ID` is an integer that uniquely identifies this track over the entire life‐time of this presentation. Track IDs are never re‐used and cannot be zero.
+# `duration` is an integer that indicates the duration of this track (in the timescale indicated in the Movie Header Box). The value of this field is equal to the sum of the durations of all of the track’s edits. If there is no edit list, then the duration is the sum of the sample durations, converted into the timescale in the Movie Header Box. If the duration of this track cannot be determined then duration is set to all 1s.
+# `layer` specifies the front‐to‐back ordering of video tracks; tracks with lower numbers are closer to the viewer. 0 is the normal value, and ‐1 would be in front of track 0, and so on.
+# `alternate_group` is an integer that specifies a group or collection of tracks. If this field is 0 there is no information on possible relations to other tracks. If this field is not 0, it should be the same for tracks that contain alternate data for one another and different for tracks belonging to different such groups. Only one track within an alternate group should be played or streamed at any one time, and must be distinguishable from other tracks in the group via attributes such as bitrate, codec, language, packet size etc. A group may have only one member.
+# `volume` is a fixed 8.8 value specifying the track's relative audio volume. Full volume is 1.0 (0x0100) and is the normal value. Its value is irrelevant for a purely visual track. Tracks may be composed by combining them according to their volume, and then using the overall Movie Header Box volume setting; or more complex audio composition (e.g. MPEG‐4 BIFS) may be used.
+# `matrix` provides a transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex (0,0,0x40000000).
+# `width` and `height` fixed‐point 16.16 values are track‐dependent as follows:
+# For text and subtitle tracks, they may, depending on the coding format, describe the suggested size of the rendering area. For such tracks, the value 0x0 may also be used to indicate that the data may be rendered at any size, that no preferred size has been indicated and that the actual size may be determined by the external context or by reusing the width and height of another track. For those tracks, the flag track_size_is_aspect_ratio may also be used.
+# For non‐visual tracks (e.g. audio), they should be set to zero.
+# For all other tracks, they specify the track's visual presentation size. These need not be the same as the pixel dimensions of the images, which is documented in the sample description(s); all images in the sequence are scaled to this size, before any overall transformation of the track represented by the matrix. The pixel dimensions of the images are the default values.

data/lib/mp4/binary/udta.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Udta < BinData::Record
+    rest :content
+  end
+end

data/lib/mp4/binary/vmhd.rb

@@ -0,0 +1,11 @@
+module MP4::Binary
+  class Vmhd < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint16 :graphicsmode, value: 0
+    array :opcolor, initial_length: 3, type: :uint16
+  end
+end