mp4-rb 0.1.0

data/lib/m4s/layout/stco.rb

@@ -0,0 +1,21 @@
+module M4S
+  module Layout
+    class Stco < Atom
+      using ::MP4::Ext::Refinements
+
+      private
+
+      def name
+        'stco'
+      end
+
+      def binary_content
+        @binary_content ||= ::MP4::Binary::Stco.new(
+          chunks_count: 0,
+          offsets: [],
+        ).to_binary_s
+      end
+
+    end
+  end
+end

data/lib/m4s/layout/stsc.rb

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

data/lib/m4s/layout/stsd.rb

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

data/lib/m4s/layout/stss.rb

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

data/lib/m4s/layout/stsz.rb

@@ -0,0 +1,19 @@
+module M4S
+  module Layout
+    class Stsz < Atom
+      using ::MP4::Ext::Refinements
+
+      private
+
+      def name
+        'stsz'
+      end
+
+      def binary_content
+        return @binary_content if defined?(@binary_content)
+
+        @binary_content = ::MP4::Binary::Stsz.new(sample_size: 0, sample_count: 0).to_binary_s
+      end
+    end
+  end
+end

data/lib/m4s/layout/stts.rb

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

data/lib/m4s/layout/styp.rb

@@ -0,0 +1,17 @@
+module M4S::Layout
+  class Styp < Atom
+    using ::MP4::Ext::Refinements
+
+    def name
+      'styp'
+    end
+
+    def binary_content
+      @binary_content ||= M4S::Binary::Styp.new(
+        major_brand: 'msdh',
+        minor_version: 0,
+        compatible_brands: %w[msdh msix],
+      ).to_binary_s
+    end
+  end
+end

data/lib/m4s/layout/tfdt.rb

@@ -0,0 +1,21 @@
+module M4S::Layout
+  class Tfdt < Atom
+    using ::MP4::Ext::Refinements
+
+    def name
+      'tfdt'
+    end
+
+    def binary_content
+      @binary_content ||= M4S::Binary::Tfdt.new(
+        version: M4S::Binary::Tfdt::VERSION_1,
+        flags: 0,
+        base_media_decode_time: earliest_presentation_time,
+      ).to_binary_s
+    end
+
+    def earliest_presentation_time
+      cache.segment_earliest_presentation_ticks(track.fetch('track_id'), segment_index)
+    end
+  end
+end

data/lib/m4s/layout/tfhd.rb

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

data/lib/m4s/layout/tkhd.rb

@@ -0,0 +1,34 @@
+module M4S::Layout
+  class Tkhd < Atom
+    DEFAULT_TIMESCALE = 1000
+
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'tkhd'
+    end
+
+    def binary_content
+      @binary_content ||= ::MP4::Binary::Tkhd.new(
+        version: 0,
+        flags: [0, 0, 3],
+        creation_time: 0,
+        modification_time: 0,
+        track_id: 1,
+        duration: 0,
+        layer: 0,
+        alternate_group: track.fetch('alternate_group'),
+        volume: track.fetch('volume'),
+        matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+        width: track.fetch('width'),
+        height: track.fetch('height'),
+      ).to_binary_s
+    end
+
+    def calculate_timescale
+      DEFAULT_TIMESCALE
+    end
+  end
+end

data/lib/m4s/layout/trex.rb

@@ -0,0 +1,33 @@
+module M4S
+  module Layout
+    class Trex < Atom
+      using ::MP4::Ext::Refinements
+
+      private
+
+      def name
+        'trex'
+      end
+
+      def binary_content
+        @binary_content ||= ::M4S::Binary::Trex.new(
+          version: 0,
+          flags: 0,
+          track_id: 1,
+          default_sample_description_index: 1,
+          default_sample_duration: 0,
+          default_sample_size: 0,
+          default_sample_flags: {
+            is_leading: 0,
+            sample_depends_on: 0,
+            sample_is_depended_on: 0,
+            sample_has_redundancy: 0,
+            sample_padding_value: 0,
+            sample_is_sync: 1,
+            sample_degradation_priority: 0,
+          },
+        ).to_binary_s
+      end
+    end
+  end
+end

data/lib/m4s/layout/trun.rb

@@ -0,0 +1,89 @@
+module M4S::Layout
+  class Trun < Atom
+    using ::MP4::Ext::Refinements
+
+    attr_accessor :data_offset
+
+    def initialize(cache, opts = {})
+      super(cache, opts)
+
+      @data_offset = opts.fetch(:data_offset, 0)
+    end
+
+    def name
+      'trun'
+    end
+
+    def binary_content
+      flags = M4S::Binary::Trun::FLAGS
+
+      @binary_content ||= M4S::Binary::Trun.new(
+        version: 0,
+        flags: flags[:data_offset] | flags[:sample_duration] | flags[:sample_size] | flags[:sample_flags] | flags[:sample_composition_time_offset],
+        sample_count: entries_list.size,
+        data_offset: data_offset,
+        first_sample_flags: 0,
+        samples: entries_list,
+      ).to_binary_s
+    end
+
+    def entries_list
+      @entries_list ||= generate_entries_list
+    end
+
+    def generate_entries_list
+      buffer = []
+
+      cache.segment_samples(track.fetch('track_id'), segment_index).each do |sample|
+        sample_flags =
+          if sample.fetch('keyframe') == 'TRUE'
+            {
+              sample_degradation_priority: 0,
+              sample_depends_on: 2, # Сэмпл не зависит от других сэмплов
+              sample_is_depended_on: 0, # Другие сэмплы зависят от этого сэмпла (ключевой кадр)
+              sample_has_redundancy: 0,
+              sample_padding_value: 0,
+              sample_is_difference_sample: 1,
+            }
+          else
+            {
+              sample_degradation_priority: 0,
+              sample_depends_on: 1, # Сэмпл не зависит от других сэмплов
+              sample_is_depended_on: 1, # Другие сэмплы зависят от этого сэмпла (ключевой кадр)
+              sample_has_redundancy: 0,
+              sample_padding_value: 0,
+              sample_is_difference_sample: 0,
+            }
+          end
+
+        buffer << {
+          sample_duration: sample.fetch('delta'),
+          sample_size: sample.fetch('size'),
+          sample_flags: encode_sample_flags(sample_flags),
+          sample_composition_time_offset: sample.fetch('c_delta'),
+        }
+      end
+
+      buffer
+    end
+
+    def encode_sample_flags(flags_hash)
+      sample_degradation_priority = flags_hash[:sample_degradation_priority] & 0xFFFF
+      sample_depends_on = flags_hash[:sample_depends_on] & 0x3
+      sample_is_depended_on = flags_hash[:sample_is_depended_on] & 0x3
+      sample_has_redundancy = flags_hash[:sample_has_redundancy] & 0x3
+      sample_padding_value = flags_hash[:sample_padding_value] & 0x7
+      sample_is_difference_sample = flags_hash[:sample_is_difference_sample] & 0x1
+
+      flags = 0
+      flags |= (sample_degradation_priority << 16)
+      flags |= (sample_depends_on << 14)
+      flags |= (sample_is_depended_on << 12)
+      flags |= (sample_has_redundancy << 10)
+      flags |= (sample_padding_value << 7)
+      flags |= (sample_is_difference_sample << 6)
+
+      flags
+    end
+  end
+end

data/lib/m4s/layout/vsmhd.rb

@@ -0,0 +1,51 @@
+module M4S
+  module Layout
+    class VSmhd < Atom
+      using ::MP4::Ext::Refinements
+
+      private
+
+      def name
+        return 'vmhd' if video?
+        return 'smhd' if sound?
+
+        raise NotImplementedError, ''
+      end
+
+      def binary_content
+        return @binary_content if defined?(@binary_content)
+
+        serializer_klass = if video?
+                             ::MP4::Binary::Vmhd
+                           elsif sound?
+                             ::MP4::Binary::Smhd
+                           else
+                             raise "Unknown track handler type #{track.fetch('handler_type')}"
+                           end
+
+        @binary_content = serializer_klass.new(handler_attrs).to_binary_s
+      end
+
+      def handler_attrs
+        if video?
+          {
+            flags: [0, 0, 0],
+            opcolor: [0, 0, 0],
+          }
+        elsif sound?
+          {
+            flags: [0, 0, 0],
+          }
+        end
+      end
+
+      def video?
+        @video ||= track.fetch('handler_type') == 'vide'
+      end
+
+      def sound?
+        @sound ||= track.fetch('handler_type') == 'soun'
+      end
+    end
+  end
+end

data/lib/m4s/m3u8/general_playlist.rb

@@ -0,0 +1,52 @@
+module M4S::M3U8
+  module GeneralPlaylist
+    extend self
+
+    VIDEO_TRACK = 'video/mp4'.freeze
+    AUDIO_TRACK = 'audio/mp4'.freeze
+    TRACKS_PRIORITY = { VIDEO_TRACK => 0, AUDIO_TRACK => 1 }.freeze
+    AUDIO_GROUP_ID = 'audio'.freeze
+
+    def generate(mp4, base_path = nil)
+      video_tracks = mp4.tracks.select { |t| t['mime_type'] == VIDEO_TRACK }
+      audio_tracks = mp4.tracks.select { |t| t['mime_type'] == AUDIO_TRACK }
+
+      lines = ['#EXTM3U', '#EXT-X-VERSION:7', '#EXT-X-INDEPENDENT-SEGMENTS']
+
+      audio_tracks.each do |track|
+        lines << audio_media_line(track, base_path)
+      end
+
+      video_tracks.each do |track|
+        lines << stream_inf_line(track, audio_tracks.any?)
+        lines << playlist_uri(track, base_path)
+      end
+
+      "#{lines.join("\n")}\n"
+    end
+
+    private
+
+    def audio_media_line(track, base_path)
+      %(#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="#{AUDIO_GROUP_ID}",NAME="default",DEFAULT=YES,AUTOSELECT=YES,URI="#{playlist_uri(track, base_path)}")
+    end
+
+    def stream_inf_line(track, has_audio)
+      bandwidth = bandwidth_for(track)
+      resolution = "#{track.fetch('width')}x#{track.fetch('height')}"
+      codecs = track.fetch('codec')
+      base   = %(#EXT-X-STREAM-INF:BANDWIDTH=#{bandwidth},RESOLUTION=#{resolution},CODECS="#{codecs}")
+      has_audio ? base + %(,AUDIO="#{AUDIO_GROUP_ID}") : base
+    end
+
+    def bandwidth_for(track)
+      value = track.fetch('avg_bitrate').to_i
+      value = track.fetch('max_bitrate').to_i if value.zero?
+      value.positive? ? value : 500_000
+    end
+
+    def playlist_uri(track, base_path)
+      [base_path, "playlist-#{track.fetch('track_id').pred}.m3u8"].compact.join('/')
+    end
+  end
+end

data/lib/m4s/m3u8/media_playlist.rb

@@ -0,0 +1,32 @@
+module M4S::M3U8
+  module MediaPlaylist
+    module_function
+
+    def generate(mp4, track, init_segment_path:, segment_path:)
+      track_id = track.fetch('track_id')
+      timescale = track.fetch('timescale').to_f
+      init_file = [init_segment_path, "init-#{track_id.pred}.mp4"].compact.join
+
+      segment_durations_seconds = mp4.segment_duration_ticks_by_index(track_id).map { |s| s.fetch('duration') / timescale }
+      target_duration = segment_durations_seconds.max.to_f.ceil.clamp(1, nil)
+
+      lines = [
+        '#EXTM3U',
+        "#EXT-X-TARGETDURATION:#{target_duration}",
+        '#EXT-X-VERSION:7',
+        '#EXT-X-MEDIA-SEQUENCE:0',
+        '#EXT-X-PLAYLIST-TYPE:VOD',
+        '#EXT-X-INDEPENDENT-SEGMENTS',
+        %(#EXT-X-MAP:URI="#{init_file}"),
+      ]
+
+      segment_durations_seconds.each_with_index do |duration, index|
+        lines << "#EXTINF:#{format('%.6f', duration)},"
+        lines << [segment_path, "chunk-#{track_id.pred}-#{format('%05d', index.next)}.m4s"].compact.join('/')
+      end
+
+      lines << '#EXT-X-ENDLIST'
+      "#{lines.join("\n")}\n"
+    end
+  end
+end

data/lib/mp4/binary/avc1.rb

@@ -0,0 +1,98 @@
+require 'bindata'
+
+module MP4::Binary
+  class BtrtAtom < BinData::Record
+    endian :big
+    uint32 :a_size
+    string :a_type, read_length: 4, assert: -> { value == "btrt" }
+    uint32 :buffer_size_db
+    uint32 :max_bitrate
+    uint32 :avg_bitrate
+  end
+
+  class PaspAtom < BinData::Record
+    endian :big
+
+    uint32 :a_size
+    string :a_type, read_length: 4, assert: -> { value == "pasp" }
+    uint32 :h_spacing
+    uint32 :v_spacing
+
+    def sample_aspect_ratio
+      "#{h_spacing}:#{v_spacing}"
+    end
+  end
+
+  class Avc1 < BinData::Record
+    endian :big
+    array  :reserved1, type: :uint8, initial_length: 6
+    uint16 :data_reference_index
+    uint16 :pre_defined
+    uint16 :reserved2
+    array  :pre_defined2, type: :uint32, initial_length: 3
+    uint16 :width
+    uint16 :height
+    uint32 :horizresolution
+    uint32 :vertresolution
+    uint32 :reserved3
+    uint16 :frame_count
+    string :compressorname, read_length: 32
+    uint16 :depth
+    int16  :pre_defined3
+
+    struct :avcC do
+      endian :big
+      uint32 :a_size
+      string :a_type, read_length: 4, assert: -> { value == "avcC" }
+      uint8 :configuration_version
+      uint8 :avc_profile_indication
+      uint8 :profile_compatibility
+      uint8 :avc_level_indication
+      bit2  :reserved
+      bit6  :length_size_minus_one
+      bit3  :reserved_2
+      bit5  :num_of_sps
+
+      array :sps, initial_length: :num_of_sps do
+        uint16 :sps_length
+        string :sps_data, read_length: :sps_length
+      end
+
+      uint8 :num_of_pps
+      array :pps, initial_length: :num_of_pps do
+        uint16 :pps_length
+        string :pps_data, read_length: :pps_length
+      end
+    end
+
+    rest :all_rest
+
+    def bitrate
+      return @bitrate if defined?(@bitrate)
+
+      index_of_btrt = all_rest.index('btrt')
+
+      return unless index_of_btrt
+
+      atom_start_pos = index_of_btrt - 4
+      atom_size = BinData::Uint32be.read(all_rest[atom_start_pos..atom_start_pos + 4]).to_i
+      atom_bytes = all_rest[atom_start_pos..atom_start_pos + 4 + atom_size]
+
+      @bitrate = BtrtAtom.read(atom_bytes)
+    end
+
+    def pasp
+      return @pasp if defined?(@pasp)
+
+      index_of_pasp = all_rest.index('pasp')
+
+      return unless index_of_pasp
+
+      atom_start_pos = index_of_pasp - 4
+      atom_size = BinData::Uint32be.read(all_rest[atom_start_pos..atom_start_pos + 4]).to_i
+      atom_bytes = all_rest[atom_start_pos..atom_start_pos + 4 + atom_size]
+
+      @pasp = PaspAtom.read(atom_bytes)
+    end
+  end
+end

data/lib/mp4/binary/box_head.rb

@@ -0,0 +1,8 @@
+module MP4::Binary
+  class BoxHead < BinData::Record
+    endian :big
+
+    uint32 :box_size
+    string :box_name, :read_length => 4
+  end
+end

data/lib/mp4/binary/co64.rb

@@ -0,0 +1,11 @@
+module MP4::Binary
+  class Co64 < BinData::Record
+    endian :big
+
+    uint8 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :chunks_count
+    array :offsets, initial_length: :chunks_count, type: :uint64
+  end
+end

data/lib/mp4/binary/codec.rb

@@ -0,0 +1,8 @@
+module MP4::Binary
+  class Codec < BinData::Record
+    endian :big
+    uint32 :content_size
+    string :codec_type, read_length: 4
+    rest :content
+  end
+end

data/lib/mp4/binary/ctts.rb

@@ -0,0 +1,14 @@
+module MP4::Binary
+  class Ctts < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8, value: [0, 0, 0]
+
+    uint32 :entry_count
+    array :entries_list, initial_length: :entry_count do
+      uint32 :sample_count
+      int32 :composition_offset
+    end
+  end
+end

data/lib/mp4/binary/ctts_reader.rb

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

data/lib/mp4/binary/dinf.rb

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

data/lib/mp4/binary/dref.rb

@@ -0,0 +1,5 @@
+module MP4::Binary
+  class Dref < BinData::Record
+    endian :big
+  end
+end

data/lib/mp4/binary/elst.rb

@@ -0,0 +1,16 @@
+module MP4::Binary
+  class Elst < BinData::Record
+    endian :big
+
+    bit1 :version, value: 0
+    array :flags, initial_length: 3, type: :uint8
+
+    uint32 :entries_count
+    array :matrix, initial_length: :entries_count do
+      uint32 :segment_duration
+      int32 :media_time
+      int16 :media_rate
+      int16 :media_rate_fraction, value: 0
+    end
+  end
+end

data/lib/mp4/binary/fixed_point16.rb

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