mp4-rb 0.1.0

data/lib/m4s/binary/trex.rb

@@ -0,0 +1,25 @@
+module M4S::Binary
+  class DefaultSampleFlags < BinData::Record
+    endian :big
+
+    bit2  :is_leading
+    bit2  :sample_depends_on
+    bit2  :sample_is_depended_on
+    bit2  :sample_has_redundancy
+    bit3  :sample_padding_value
+    bit1  :sample_is_sync
+    bit16 :sample_degradation_priority
+  end
+
+  class Trex < BinData::Record
+    endian :big
+
+    uint8  :version
+    bit24  :flags
+    uint32 :track_id
+    uint32 :default_sample_description_index
+    uint32 :default_sample_duration
+    uint32 :default_sample_size
+    default_sample_flags :default_sample_flags
+  end
+end

data/lib/m4s/binary/trun.rb

@@ -0,0 +1,30 @@
+module M4S
+  module Binary
+    class Trun < BinData::Record
+      endian :big
+
+      FLAGS = {
+        data_offset: 0x000001,
+        first_sample_flags: 0x000004,
+        sample_duration: 0x000100,
+        sample_size: 0x000200,
+        sample_flags: 0x000400,
+        sample_composition_time_offset: 0x000800,
+      }.freeze
+
+      uint8  :version
+      bit24  :flags
+      uint32 :sample_count
+
+      int32  :data_offset, onlyif: -> { flags & FLAGS[:data_offset] != 0 }
+      uint32 :first_sample_flags, onlyif: -> { flags & FLAGS[:first_sample_flags] != 0 }
+
+      array :samples, initial_length: :sample_count do
+        uint32 :sample_duration, onlyif: -> { parent.flags & FLAGS[:sample_duration] != 0 }
+        uint32 :sample_size, onlyif: -> { parent.flags & FLAGS[:sample_size] != 0 }
+        uint32 :sample_flags, onlyif: -> { parent.flags & FLAGS[:sample_flags] != 0 }
+        int32  :sample_composition_time_offset, onlyif: -> { parent.flags & FLAGS[:sample_composition_time_offset] != 0 }
+      end
+    end
+  end
+end

data/lib/m4s/dash/manifest.rb

@@ -0,0 +1,149 @@
+module M4S::Dash
+  module Manifest
+    extend self
+
+    VIDEO_TRACK = 'video/mp4'.freeze
+    AUDIO_TRACK = 'audio/mp4'.freeze
+    TRACKS_PRIORITY = { VIDEO_TRACK => 0, AUDIO_TRACK => 1 }.freeze
+    SCHEMA_LOCATION = 'urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd'.freeze
+    PROFILE = 'urn:mpeg:dash:profile:isoff-live:2011'.freeze
+
+    def generate(mp4, init_segment_path:, segment_path:)
+      media_presentation_duration = calculate_media_presentation_duration(mp4)
+      max_segment_duration = calculate_max_segment_duration(mp4)
+
+      init_template  = join_path(init_segment_path,  'init-$RepresentationID$.mp4')
+      media_template = join_path(segment_path,       'chunk-$RepresentationID$-$Number%05d$.m4s')
+
+      builder = Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+        xml.MPD(
+          'xmlns:xsi'          => 'http://www.w3.org/2001/XMLSchema-instance',
+          'xmlns'              => 'urn:mpeg:dash:schema:mpd:2011',
+          'xmlns:xlink'        => 'http://www.w3.org/1999/xlink',
+          'xsi:schemaLocation' => SCHEMA_LOCATION,
+          'profiles'           => PROFILE,
+          'type'               => 'static',
+          'mediaPresentationDuration' => format_duration(media_presentation_duration),
+          'maxSegmentDuration'        => format_duration(max_segment_duration),
+          'minBufferTime'             => format_duration(max_segment_duration * 2.0),
+        ) do
+          xml.ProgramInformation
+          xml.ServiceDescription(id: '0')
+          xml.Period(id: '0', start: 'PT0.0S') do
+            sorted_tracks(mp4).each_with_index do |track, index|
+              render_adaptation_set(xml, mp4, track, index, init_template, media_template)
+            end
+          end
+        end
+      end
+
+      builder.to_xml
+    end
+
+    def calculate_max_segment_duration(mp4)
+      track = primary_track(mp4)
+      max = mp4.max_segment_duration_ticks(track.fetch('track_id')).to_f
+      max / track.fetch('timescale').to_f
+    end
+
+    def calculate_media_presentation_duration(mp4)
+      track = primary_track(mp4)
+      mp4.track_sample_delta_sum(track.fetch('track_id')).to_f / track.fetch('timescale')
+    end
+
+    def format_duration(float_seconds)
+      total_seconds = float_seconds.to_f
+      minutes = (total_seconds / 60).to_i
+      seconds = total_seconds % 60
+
+      if minutes.positive?
+        seconds.positive? ? "PT#{minutes}M#{seconds.round(1)}S" : "PT#{minutes}M"
+      else
+        "PT#{seconds.round(1)}S"
+      end
+    end
+
+    private
+
+    def sorted_tracks(mp4)
+      mp4.tracks.sort_by { |t| TRACKS_PRIORITY.fetch(t['mime_type'], TRACKS_PRIORITY.size) }
+    end
+
+    def primary_track(mp4)
+      mp4.tracks.find { |t| t.fetch('handler_type') == 'vide' } ||
+        mp4.tracks.find { |t| t.fetch('handler_type') == 'soun' }
+    end
+
+    def render_adaptation_set(xml, mp4, track, index, init_template, media_template)
+      xml.AdaptationSet(adaptation_set_options(track, index)) do
+        xml.Representation(representation_options(track, index)) do
+          if track.fetch('mime_type') == AUDIO_TRACK
+            xml.AudioChannelConfiguration(
+              schemeIdUri: 'urn:mpeg:dash:23003:3:audio_channel_configuration:2011',
+              value: track.fetch('channel_count') || 2,
+            )
+          end
+
+          xml.SegmentTemplate(
+            timescale: track.fetch('timescale'),
+            initialization: init_template,
+            media: media_template,
+            startNumber: '1',
+          ) do
+            xml.SegmentTimeline do
+              mp4.segment_duration_ticks_by_index(track.fetch('track_id')).each_with_index do |segment, seg_i|
+                if seg_i.zero?
+                  xml.S(t: '0', d: segment.fetch('duration'))
+                else
+                  xml.S(d: segment.fetch('duration'))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def adaptation_set_options(track, index)
+      opts = { id: index.to_s, startWithSAP: '1', segmentAlignment: 'true', bitstreamSwitching: 'true' }
+      if track.fetch('mime_type') == VIDEO_TRACK
+        opts.merge!(
+          contentType: 'video',
+          maxWidth:  track.fetch('width').to_s,
+          maxHeight: track.fetch('height').to_s,
+          par:       track.fetch('par'),
+        )
+      else
+        opts.merge!(contentType: 'audio')
+      end
+      opts
+    end
+
+    def representation_options(track, index)
+      opts = {
+        id: index.to_s,
+        mimeType: track.fetch('mime_type'),
+        codecs: track.fetch('codec'),
+        bandwidth: bandwidth(track),
+      }
+      if track.fetch('mime_type') == VIDEO_TRACK
+        opts.merge!(width: track.fetch('width'), height: track.fetch('height'), sar: track.fetch('sar'))
+      elsif track.fetch('mime_type') == AUDIO_TRACK
+        opts.merge!(audioSamplingRate: track.fetch('sample_rate'))
+      end
+      opts
+    end
+
+    def bandwidth(track)
+      value = track.fetch('avg_bitrate').to_i
+      value = track.fetch('max_bitrate').to_i if value.zero?
+      value.positive? ? value : 128_000
+    end
+
+    def join_path(prefix, tail)
+      return tail if prefix.to_s.empty?
+
+      [prefix, tail].join('/')
+    end
+  end
+end

data/lib/m4s/layout/atom.rb

@@ -0,0 +1,44 @@
+module M4S::Layout
+  class Atom
+    attr_accessor :cache, :track, :segment_index, :track_id
+
+    def self.generate(cache, opts = {})
+      new(cache, opts).generate
+    end
+
+    def initialize(cache, opts = {})
+      @cache = cache
+      @track = opts.fetch(:track, nil)
+      @track_id = track.fetch('track_id') if track
+      @segment_index = opts.fetch(:segment_index, 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
+  end
+end

data/lib/m4s/layout/builder.rb

@@ -0,0 +1,32 @@
+module M4S::Layout
+  module Builder
+    module_function
+
+    def call(cache, source, track_id, segment_index)
+      track = cache.track(track_id)
+
+      container = Container.new(root: true)
+
+      container.add_atom Styp.generate(cache)
+      container.add_atom Sidx.generate(cache, track: track, segment_index: segment_index)
+
+      container.size
+      container.add_container :moof do |moof|
+        moof.add_atom Mfhd.generate(cache, segment_index: segment_index)
+
+        moof.add_container :traf do |traf|
+          traf.add_atom Tfhd.generate(cache, track: track, segment_index: segment_index)
+          traf.add_atom Tfdt.generate(cache, track: track, segment_index: segment_index)
+          trun_boilerplate = Trun.generate(cache, track: track, segment_index: segment_index)
+
+          data_offset = moof.size + traf.size + trun_boilerplate.size + ::MP4::Constants::GENERIC_HEADER_SIZE
+          traf.add_atom Trun.generate(cache, track: track, segment_index: segment_index, data_offset: data_offset)
+        end
+      end
+
+      container.add_atom Mdat.generate(cache, source: source, track: track, segment_index: segment_index)
+
+      container
+    end
+  end
+end

data/lib/m4s/layout/container.rb

@@ -0,0 +1,59 @@
+module M4S::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
+      binary_descendants.size + (root ? 0 : ::MP4::Constants::GENERIC_HEADER_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/m4s/layout/ctts.rb

@@ -0,0 +1,20 @@
+module M4S
+  module Layout
+    class Ctts < Atom
+      using ::MP4::Ext::Refinements
+
+      private
+
+      def name
+        'ctts'
+      end
+
+      def binary_content
+        @binary_content ||= ::MP4::Binary::Ctts.new(
+          entry_count: 0,
+          entries_list: [],
+        ).to_binary_s
+      end
+    end
+  end
+end

data/lib/m4s/layout/dinf.rb

@@ -0,0 +1,17 @@
+module M4S
+  module 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
+end

data/lib/m4s/layout/elst.rb

@@ -0,0 +1,33 @@
+module M4S
+  module 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: matrix.size,
+          matrix: matrix,
+        ).to_binary_s
+      end
+
+      def matrix
+        @matrix ||= cache.elst_entries(track_id).map do |entry|
+          {
+            segment_duration: 0,
+            media_time: entry.fetch('media_time'),
+            media_rate: entry.fetch('media_rate'),
+            media_rate_fraction: entry.fetch('media_rate_fraction'),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/m4s/layout/ftyp.rb

@@ -0,0 +1,21 @@
+module M4S::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/m4s/layout/hdlr.rb

@@ -0,0 +1,22 @@
+module M4S
+  module 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
+end

data/lib/m4s/layout/init_mp4_builder.rb

@@ -0,0 +1,57 @@
+module M4S::Layout
+  module InitMp4Builder
+    module_function
+
+    def call(cache, track_id)
+      # binding.pry
+      track = cache.track(track_id)
+
+      container = Container.new(root: true)
+
+      container.add_atom Ftyp.generate(cache)
+
+      container.add_container :moov do |moov|
+        moov.add_atom Mvhd.generate(cache)
+
+        moov.add_container :trak do |trak|
+          trak.add_atom Tkhd.generate(cache, track: track)
+
+          trak.add_container :edts do |edts|
+            edts.add_atom Elst.generate(cache, track: track)
+          end
+
+          trak.add_container :mdia do |mdia|
+            # if track.fetch('handler_type') == 'vide'
+            mdia.add_atom Mdhd.generate(cache, track: track)
+            mdia.add_atom Hdlr.generate(cache, track: track)
+
+            mdia.add_container :minf do |minf|
+              minf.add_atom VSmhd.generate(cache, track: track)
+              minf.add_atom Dinf.generate(cache, track: track)
+
+              minf.add_container :stbl do |stbl|
+                stbl.add_atom Stsd.generate(cache, track: track)
+                stbl.add_atom Stts.generate(cache, track: track)
+
+                if track['handler_type'] == 'vide'
+                  stbl.add_atom Stss.generate(cache, track: track)
+                  stbl.add_atom Ctts.generate(cache, track: track) if track['have_composition_time'].nonzero?
+                end
+
+                stbl.add_atom Stsc.generate(cache, track: track)
+                stbl.add_atom Stsz.generate(cache, track: track)
+                stbl.add_atom Stco.generate(cache, track: track)
+              end
+            end
+          end
+        end
+
+        moov.add_container :mvex do |mvex|
+          mvex.add_atom Trex.generate(cache)
+        end
+      end
+
+      container
+    end
+  end
+end

data/lib/m4s/layout/mdat.rb

@@ -0,0 +1,61 @@
+module M4S::Layout
+  class Mdat < Atom
+    using ::MP4::Ext::Refinements
+
+    attr_reader :source, :track_id
+
+    def initialize(cache, opts = {})
+      super(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
+
+      samples = cache.segment_bytes_sizes_offsets(track.fetch('track_id'), segment_index)
+
+      if source.respond_to?(:fetch)
+        range(buffer, samples)
+      else
+        progressive(buffer, samples)
+      end
+
+      buffer.seek(0)
+
+      @binary_content = BinData::String.new(buffer.read).to_binary_s
+    end
+
+    def range(buffer, samples)
+      range_from = samples.first.fetch('offset')
+      range_to = samples.last.fetch('offset') + samples.last.fetch('size')
+      bytes = StringIO.new(source.fetch(range_from, range_to))
+
+      samples.each do |chunk|
+        offset = chunk.fetch('offset') - range_from
+        bytes.seek(offset)
+        chunk_bytes = bytes.read(chunk.fetch('size'))
+
+        buffer.write chunk_bytes
+      end
+    end
+
+    def progressive(buffer, samples)
+      samples.each do |chunk|
+        source.set_seek chunk.fetch('offset')
+        chunk_bytes = source.read(chunk.fetch('size'))
+
+        buffer.write chunk_bytes
+      end
+    end
+  end
+end

data/lib/m4s/layout/mdhd.rb

@@ -0,0 +1,25 @@
+module M4S
+  module 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: 0,
+          language: [0, 0, 0],
+        ).to_binary_s
+      end
+    end
+  end
+end

data/lib/m4s/layout/mfhd.rb

@@ -0,0 +1,17 @@
+module M4S::Layout
+  class Mfhd < Atom
+    using ::MP4::Ext::Refinements
+
+    def name
+      'mfhd'
+    end
+
+    def binary_content
+      @binary_content ||= M4S::Binary::Mfhd.new(
+        version: 0,
+        flags: 0,
+        sequence_number: segment_index,
+      ).to_binary_s
+    end
+  end
+end

data/lib/m4s/layout/mvhd.rb

@@ -0,0 +1,32 @@
+module M4S::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: DEFAULT_TIMESCALE,
+        duration: 0,
+        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_next_track_id
+      cache.next_track_id
+    end
+  end
+end

data/lib/m4s/layout/sidx.rb

@@ -0,0 +1,36 @@
+module M4S::Layout
+  class Sidx < Atom
+    using ::MP4::Ext::Refinements
+
+    def name
+      'sidx'
+    end
+
+    def binary_content
+      @binary_content ||= M4S::Binary::Sidx.new(
+        version: 1,
+        flags: 0,
+        reference_id: 1,
+        timescale: track.fetch('timescale'),
+        earliest_presentation_time: earliest_presentation_time,
+        first_offset: 0,
+        reference_count: 1,
+        references: [
+          { reference_type: 0, referenced_size: segment_size, subsegment_duration: segment_duration, starts_with_sap: 1, sap_type: 0, sap_delta_time: 0 },
+        ],
+      ).to_binary_s
+    end
+
+    def segment_duration
+      cache.segment_duration_ticks(track.fetch('track_id'), segment_index)
+    end
+
+    def earliest_presentation_time
+      cache.segment_earliest_presentation_ticks(track.fetch('track_id'), segment_index)
+    end
+
+    def segment_size
+      cache.segment_size_bytes(track.fetch('track_id'), segment_index)
+    end
+  end
+end