mp4-rb 0.1.0

data/lib/mp4/constants.rb

@@ -0,0 +1,87 @@
+module MP4::Constants
+  GENERIC_HEADER_SIZE = 8
+
+  TRAK_ATOMS = [
+    TKHD_ATOM = 'tkhd'.freeze,
+    TREF_ATOM = 'tref'.freeze,
+    TRGR_ATOM = 'trgr'.freeze,
+    ELST_ATOM = 'elst'.freeze,
+    META_ATOM = 'meta'.freeze,
+    MDHD_ATOM = 'mdhd'.freeze,
+    HDLR_ATOM = 'hdlr'.freeze,
+    ELNG_ATOM = 'elng'.freeze,
+    # minf
+    VMHD_ATOM = 'vmhd'.freeze,
+    SMHD_ATOM = 'smhd'.freeze,
+    HMHD_ATOM = 'hmhd'.freeze,
+    STHD_ATOM = 'sthd'.freeze,
+    NMHD_ATOM = 'nmhd'.freeze,
+    DINF_ATOM = 'dinf'.freeze, # TODO
+    # 'dref', # TODO
+    # stbl
+    STSD_ATOM = 'stsd'.freeze,
+    STTS_ATOM = 'stts'.freeze,
+    CTTS_ATOM = 'ctts'.freeze,
+    CSLG_ATOM = 'cslg'.freeze,
+    STSC_ATOM = 'stsc'.freeze,
+    STSZ_ATOM = 'stsz'.freeze,
+    STZ2_ATOM = 'stz2'.freeze,
+    STCO_ATOM = 'stco'.freeze,
+    CO64_ATOM = 'co64'.freeze,
+    STSS_ATOM = 'stss'.freeze,
+    STSH_ATOM = 'stsh'.freeze,
+    PADB_ATOM = 'padb'.freeze,
+    STDP_ATOM = 'stdp'.freeze,
+    SDTP_ATOM = 'sdtp'.freeze,
+    SBGP_ATOM = 'sbgp'.freeze,
+    # 'sgpd',
+    SUBS_ATOM = 'subs'.freeze,
+    SAIZ_ATOM = 'saiz'.freeze,
+    SAIO_ATOM = 'saio'.freeze,
+  ].freeze
+
+  CACHED_ATOMS = %w[dinf stbl stsd].freeze
+
+  PARSERS = {
+    'mvhd' => '::MP4::Binary::Mvhd',
+    'iods' => '::MP4::Binary::Iods',
+    'tkhd' => '::MP4::Binary::Tkhd',
+    'tref' => '::MP4::Binary::Tref',
+    'trgr' => '::MP4::Binary::Trgr',
+    'elst' => '::MP4::Binary::Elst',
+    'meta' => '::MP4::Binary::Meta',
+    'mdhd' => '::MP4::Binary::Mdhd',
+    'hdlr' => '::MP4::Binary::Hdlr',
+    'elng' => '::MP4::Binary::Elng',
+    # minf
+    'vmhd' => '::MP4::Binary::Vmhd',
+    'smhd' => '::MP4::Binary::Smhd',
+    'hmhd' => '::MP4::Binary::Hmhd',
+    'sthd' => '::MP4::Binary::Sthd',
+    'nmhd' => '::MP4::Binary::Nmhd',
+    'dinf' => '::MP4::Binary::Dinf',
+    # stbl
+    'stsd' => '::MP4::Binary::Stsd',
+    'stts' => '::MP4::Binary::Stts',
+    'ctts' => '::MP4::Binary::Ctts',
+    'cslg' => '::MP4::Binary::Cslg',
+    'stsc' => '::MP4::Binary::Stsc',
+    'stsz' => '::MP4::Binary::Stsz',
+    'stz2' => '::MP4::Binary::Stz2',
+    'stco' => '::MP4::Binary::Stco',
+    'co64' => '::MP4::Binary::Co64',
+    'stss' => '::MP4::Binary::Stss',
+    'stsh' => '::MP4::Binary::Stsh',
+    'padb' => '::MP4::Binary::Padb',
+    'stdp' => '::MP4::Binary::Stdp',
+    'sdtp' => '::MP4::Binary::Sdtp',
+    'gmhd' => '::MP4::Binary::Gmhd',
+    'sgpd' => '::MP4::Binary::Sgpd', # TODO: add support
+    'sbgp' => '::MP4::Binary::Sbgp', # TODO: add support
+    'subs' => '::MP4::Binary::Subs',
+    'saiz' => '::MP4::Binary::Saiz',
+    'saio' => '::MP4::Binary::Saio',
+    'senc' => '::MP4::Binary::Senc',
+    'udta' => '::MP4::Binary::Udta',
+  }.freeze
+end

data/lib/mp4/ext/refinements.rb

@@ -0,0 +1,19 @@
+module MP4::Ext
+  module Refinements
+    refine Hash do
+      def dig!(*keys)
+        val = self
+        keys.each { |key| val = val.fetch(key) }
+        val
+      end
+    end
+
+    refine Array do
+      def dig!(*keys)
+        val = self
+        keys.each { |key| val = val.fetch(key) }
+        val
+      end
+    end
+  end
+end

data/lib/mp4/layout/atom.rb

@@ -0,0 +1,47 @@
+module MP4::Layout
+  class Atom
+    attr_accessor :cache, :media_cache, :track_id
+
+    def self.generate(cache, media_cache, opts = {})
+      new(cache, media_cache, opts).generate
+    end
+
+    def initialize(cache, media_cache, opts = {})
+      @cache = cache
+      @media_cache = media_cache
+      @track_id = opts.fetch(:track_id, nil)
+    end
+
+    def generate
+      [
+        *header,
+        binary_content,
+      ].join
+    end
+
+    private
+
+    def header
+      [
+        BinData::Uint32be.new(size).to_binary_s,
+        BinData::String.new(name).to_binary_s,
+      ]
+    end
+
+    def name
+      raise NotImplementedError.new(message: "#{__callee__} not implemented")
+    end
+
+    def size
+      ::MP4::Constants::GENERIC_HEADER_SIZE + binary_content.size
+    end
+
+    def binary_content
+      raise NotImplementedError.new(message: "#{__callee__} not implemented")
+    end
+
+    def track
+      @track ||= media_cache.track(track_id)
+    end
+  end
+end

data/lib/mp4/layout/base.rb

@@ -0,0 +1,10 @@
+module MP4::Layout::Base
+  private
+
+  def header
+    [
+      BinData::Uint32be.new(size).to_binary_s,
+      BinData::String.new(name).to_binary_s,
+    ]
+  end
+end

data/lib/mp4/layout/builder.rb

@@ -0,0 +1,16 @@
+module MP4::Layout
+  module Builder
+    module_function
+
+    def call(cache, media_cache, source)
+      container = Container.new(root: true)
+
+      container.add_atom Ftyp.generate(cache, media_cache)
+      container.add_atom Free.generate(cache, media_cache, size: container.size)
+      container.add_atom Mdat.generate(cache, media_cache, source: source)
+      container.add_atom Moov.generate(cache, media_cache)
+
+      container
+    end
+  end
+end

data/lib/mp4/layout/container.rb

@@ -0,0 +1,59 @@
+module MP4::Layout
+  class Container
+    # include ::Layout::Base
+
+    attr_accessor :root, :name, :descendants
+
+    def initialize(root: false, name: nil)
+      @root = root
+      @name = name
+      @descendants ||= []
+    end
+
+    def generate
+      return binary_descendants if root
+
+      [
+        BinData::Uint32be.new(size).to_binary_s,
+        BinData::String.new(name).to_binary_s,
+        binary_descendants,
+      ].join
+    end
+
+    def binary_descendants
+      descendants.join
+    end
+
+    def size
+      ::MP4::Constants::GENERIC_HEADER_SIZE + binary_descendants.size
+    end
+
+    def add_container(name, &block)
+      container = self.class.new(name: name)
+
+      block.call(container)
+
+      @descendants << container.generate
+
+      container
+    end
+
+    def add_atom(atom)
+      @descendants << atom
+      atom
+    end
+
+    def add_mdat(mp4, source)
+      @descendants << ::Layout::Mdat.new(mp4: mp4, source: source)
+    end
+
+    def pack
+      return descendants.map(&:pack).join if root
+
+      [
+        *header,
+        descendants.map(&:pack),
+      ].join
+    end
+  end
+end

data/lib/mp4/layout/ctts.rb

@@ -0,0 +1,35 @@
+module MP4::Layout
+  class Ctts < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'ctts'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Ctts.new(
+        entry_count: generate_entries_list.size,
+        entries_list: generate_entries_list,
+      ).to_binary_s
+    end
+
+    def generate_entries_list
+      return @generate_entries_list if defined?(@generate_entries_list)
+
+      buffer = []
+      media_cache.sample_c_delta_pairs(track_id).each do |row|
+        c_delta = row.fetch('c_delta')
+        latest = buffer.last
+        if latest && latest[:composition_offset] == c_delta
+          latest[:sample_count] += 1
+        else
+          buffer << { sample_count: 1, composition_offset: c_delta }
+        end
+      end
+
+      @generate_entries_list = buffer
+    end
+  end
+end

data/lib/mp4/layout/dinf.rb

@@ -0,0 +1,15 @@
+module MP4::Layout
+  class Dinf < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'dinf'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Dinf.new(content: cache.dinf_content(track_id)).to_binary_s
+    end
+  end
+end

data/lib/mp4/layout/elst.rb

@@ -0,0 +1,33 @@
+module MP4::Layout
+  class Elst < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'elst'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Elst.new(
+        version: 0,
+        flags: [0, 0, 0],
+        entries_count: 1,
+        matrix: [compile_matrix],
+      ).to_binary_s
+    end
+
+    def compile_matrix
+      {
+        segment_duration: calculate_duration,
+        media_time: 0,
+        media_rate: 1,
+      }
+    end
+
+    def calculate_duration
+      seconds = media_cache.track_sample_delta_sum(track_id) / track.fetch('timescale').to_f
+      (seconds.round(3) * MP4::Layout::Mvhd::DEFAULT_TIMESCALE).to_i
+    end
+  end
+end

data/lib/mp4/layout/free.rb

@@ -0,0 +1,20 @@
+module MP4::Layout
+  class Free < Atom
+
+    def initialize(_cache, _media_cache, opts = {})
+      @size = opts.fetch(:size)
+    end
+
+    def name
+      'free'
+    end
+
+    def binary_content
+      @binary_content ||= Array.new(50 - @size - MP4::Constants::GENERIC_HEADER_SIZE) { "\x00" }.join
+    end
+
+    def memoized_ftyp
+      @memoized_ftyp ||= @cache.ftyp
+    end
+  end
+end

data/lib/mp4/layout/ftyp.rb

@@ -0,0 +1,21 @@
+module MP4::Layout
+  class Ftyp < Atom
+    using ::MP4::Ext::Refinements
+
+    def name
+      'ftyp'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Ftyp.new(
+        major_brand: memoized_ftyp.fetch('major_brand'),
+        minor_version: memoized_ftyp.fetch('minor_version'),
+        compatible_brands: memoized_ftyp.fetch('compatible_brands'),
+      ).to_binary_s
+    end
+
+    def memoized_ftyp
+      @memoized_ftyp ||= cache.ftyp
+    end
+  end
+end

data/lib/mp4/layout/hdlr.rb

@@ -0,0 +1,20 @@
+module MP4::Layout
+  class Hdlr < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'hdlr'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Hdlr.new(
+        version: 0,
+        flags: [0, 0, 0],
+        handler_type: track.fetch('handler_type'),
+        handler_name: track.fetch('handler_name'),
+      ).to_binary_s
+    end
+  end
+end

data/lib/mp4/layout/mdat.rb

@@ -0,0 +1,33 @@
+module MP4::Layout
+  class Mdat < Atom
+    using ::MP4::Ext::Refinements
+
+    attr_reader :source
+
+    def initialize(cache, media_cache, opts = {})
+      super(cache, media_cache, opts)
+      @source = opts.fetch(:source)
+    end
+
+    private
+
+    def name
+      'mdat'
+    end
+
+    def binary_content
+      return @binary_content if defined?(@binary_content)
+
+      buffer = StringIO.new
+      source.reset_seek
+
+      media_cache.each_sample_ordered_across_tracks do |chunk|
+        source.set_seek chunk.fetch('offset')
+        buffer.write source.read(chunk.fetch('size'))
+      end
+
+      buffer.seek(0)
+      @binary_content = BinData::String.new(buffer.read).to_binary_s
+    end
+  end
+end

data/lib/mp4/layout/mdhd.rb

@@ -0,0 +1,27 @@
+module MP4::Layout
+  class Mdhd < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'mdhd'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Mdhd.new(
+        version: 0,
+        flags: [0, 0, 0],
+        creation_time: 0,
+        modification_time: 0,
+        timescale: track.fetch('timescale'),
+        duration: calculate_duration,
+        language: [0, 0, 0],
+      ).to_binary_s
+    end
+
+    def calculate_duration
+      media_cache.track_sample_delta_sum(track_id)
+    end
+  end
+end

data/lib/mp4/layout/moov.rb

@@ -0,0 +1,58 @@
+module MP4::Layout
+  module Moov
+    extend self
+
+    def generate(cache, media_cache)
+      moov = Container.new(name: 'moov')
+      moov.add_atom Mvhd.generate(cache, media_cache)
+
+      media_cache.tracks_asc.each do |track|
+        moov.add_container(:trak) { |trak| build_trak(cache, media_cache, trak, track) }
+      end
+
+      moov.generate
+    end
+
+    private
+
+    def build_trak(cache, media_cache, trak, track)
+      track_id = track.fetch('track_id')
+
+      trak.add_atom Tkhd.generate(cache, media_cache, track_id: track_id)
+      trak.add_container(:edts) { |edts| edts.add_atom Elst.generate(cache, media_cache, track_id: track_id) }
+      trak.add_container(:mdia) { |mdia| build_mdia(cache, media_cache, mdia, track) }
+    end
+
+    def build_mdia(cache, media_cache, mdia, track)
+      track_id = track.fetch('track_id')
+
+      mdia.add_atom Mdhd.generate(cache, media_cache, track_id: track_id)
+      mdia.add_atom Hdlr.generate(cache, media_cache, track_id: track_id)
+      mdia.add_container(:minf) { |minf| build_minf(cache, media_cache, minf, track) }
+    end
+
+    def build_minf(cache, media_cache, minf, track)
+      track_id = track.fetch('track_id')
+
+      minf.add_atom VSmhd.generate(cache, media_cache, track_id: track_id)
+      minf.add_atom Dinf.generate(cache, media_cache, track_id: track_id)
+      minf.add_container(:stbl) { |stbl| build_stbl(cache, media_cache, stbl, track) }
+    end
+
+    def build_stbl(cache, media_cache, stbl, track)
+      track_id = track.fetch('track_id')
+
+      stbl.add_atom Stsd.generate(cache, media_cache, track_id: track_id)
+      stbl.add_atom Stts.generate(cache, media_cache, track_id: track_id)
+
+      if track['handler_type'] == 'vide'
+        stbl.add_atom Stss.generate(cache, media_cache, track_id: track_id)
+        stbl.add_atom Ctts.generate(cache, media_cache, track_id: track_id) if track['have_composition_time'].to_i.nonzero?
+      end
+
+      stbl.add_atom Stsc.generate(cache, media_cache, track_id: track_id)
+      stbl.add_atom Stsz.generate(cache, media_cache, track_id: track_id)
+      stbl.add_atom Stco.generate(cache, media_cache, track_id: track_id)
+    end
+  end
+end

data/lib/mp4/layout/mvhd.rb

@@ -0,0 +1,46 @@
+module MP4::Layout
+  class Mvhd < Atom
+    DEFAULT_TIMESCALE = 1000
+
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'mvhd'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Mvhd.new(
+        version: 0,
+        flags: [0, 0, 0],
+        creation_time: 0,
+        modification_time: 0,
+        timescale: calculate_timescale,
+        duration: calculate_duration,
+        rate: 1.0,
+        volume: 1.0,
+        matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+        next_track_id: calculate_next_track_id,
+      ).to_binary_s
+    end
+
+    def calculate_timescale
+      DEFAULT_TIMESCALE
+    end
+
+    def calculate_duration
+      durations = media_cache.tracks.map do |tr|
+        tid = tr.fetch('track_id')
+        track_timescale = cache.track(tid).fetch('timescale').to_f
+        seconds = media_cache.track_sample_delta_sum(tid) / track_timescale
+        (seconds.round(3) * calculate_timescale).to_i
+      end
+      durations.max.to_i.nonzero? || DEFAULT_TIMESCALE
+    end
+
+    def calculate_next_track_id
+      cache.next_track_id
+    end
+  end
+end

data/lib/mp4/layout/stco.rb

@@ -0,0 +1,37 @@
+module MP4::Layout
+  class Stco < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'stco'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Stco.new(
+        chunks_count: generate_offsets_list.size,
+        offsets: generate_offsets_list,
+      ).to_binary_s
+    end
+
+    def generate_offsets_list
+      return @generate_offsets_list if defined?(@generate_offsets_list)
+
+      offset_counter = 50
+      buffer = []
+
+      media_cache.each_sample_ordered_across_tracks do |sample|
+        buffer << offset_counter if sample.fetch('track_id') == track_id
+        offset_counter += sample.fetch('size')
+      end
+
+      @generate_offsets_list = buffer
+    end
+
+    def offset_start_point
+      @offset_start_point ||= media_cache.min_sample_offset
+    end
+  end
+end
+# 794164

data/lib/mp4/layout/stsc.rb

@@ -0,0 +1,27 @@
+module MP4::Layout
+  class Stsc < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'stsc'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Stsc.new(
+        chunk_count: sample_to_chunk_table.size,
+        table: sample_to_chunk_table,
+      ).to_binary_s
+    end
+
+    def sample_to_chunk_table
+      return @sample_to_chunk_table if defined?(@sample_to_chunk_table)
+
+      chunk_indices = media_cache.sample_chunk_indices(track_id)
+      @sample_to_chunk_table = chunk_indices.each_with_index.map do |_chunk_index, i|
+        { first_chunk: i + 1, samples_per_chunk: 1, sample_description_index: 1 }
+      end
+    end
+  end
+end

data/lib/mp4/layout/stsd.rb

@@ -0,0 +1,15 @@
+module MP4::Layout
+  class Stsd < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'stsd'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Stsd.new(content: cache.stsd_content(track_id)).to_binary_s
+    end
+  end
+end

data/lib/mp4/layout/stss.rb

@@ -0,0 +1,22 @@
+module MP4::Layout
+  class Stss < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'stss'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Stss.new(
+        sync_samples_count: generate_sync_sample_list.size,
+        sync_sample: generate_sync_sample_list,
+      ).to_binary_s
+    end
+
+    def generate_sync_sample_list
+      @generate_sync_sample_list ||= media_cache.sync_sample_indices(track_id)
+    end
+  end
+end