mp4-rb 0.1.0

data/lib/mp4/nolan/service/sound.rb

@@ -0,0 +1,36 @@
+module MP4::Nolan
+  module Service::Sound
+    module_function
+
+    def compute(cache, segment_index, track:, from_timestamp:, to_timestamp:, sample_timescale:)
+      track_id = track.fetch('track_id')
+      relative_from = from_timestamp || 0
+
+      min_chunk_offset = 0
+      current_chunk_index = 0
+
+      cache.samples_between_ms(track_id, relative_from, to_timestamp).each_with_index do |original_sample, sample_index_incr|
+        if current_chunk_index != original_sample.fetch('chunk_index')
+          current_chunk_index = original_sample.fetch('chunk_index')
+          min_chunk_offset = original_sample.fetch('offset')
+        end
+
+        cache.add_segment_sample(
+          track_id: track_id,
+          segment_index: segment_index,
+          chunk_index: original_sample.fetch('chunk_index'),
+          sample_index: sample_index_incr.succ,
+          sample_size: original_sample.fetch('size'),
+          sample_offset: original_sample.fetch('offset'),
+          chunk_offset: min_chunk_offset,
+          original_chunk_offset: min_chunk_offset,
+          sample_delta: original_sample.fetch('delta'),
+          delta_sum: original_sample.fetch('delta_sum'),
+          absolute_delta_sum: 0,
+          composition_offset: original_sample.fetch('c_delta'),
+          is_keyframe: original_sample.fetch('keyframe'),
+        )
+      end
+    end
+  end
+end

data/lib/mp4/nolan/service/track.rb

@@ -0,0 +1,9 @@
+module MP4::Nolan
+  module Service::Track
+    module_function
+
+    def copy(dest_cache, track)
+      dest_cache.add_track(**track.transform_keys(&:to_sym))
+    end
+  end
+end

data/lib/mp4/nolan/service/video.rb

@@ -0,0 +1,35 @@
+module MP4::Nolan
+  module Service::Video
+    module_function
+
+    def compute(cache, segment_index, track:, from_timestamp:, to_timestamp:, sample_timescale:)
+      track_id = track.fetch('track_id')
+
+      min_chunk_offset = 0
+      current_chunk_index = 0
+
+      cache.samples_between_ms(track_id, from_timestamp, to_timestamp).each_with_index do |original_sample, sample_index_incr|
+        if current_chunk_index != original_sample.fetch('chunk_index')
+          current_chunk_index = original_sample.fetch('chunk_index')
+          min_chunk_offset = original_sample.fetch('offset')
+        end
+
+        cache.add_segment_sample(
+          track_id: track_id,
+          segment_index: segment_index,
+          chunk_index: original_sample.fetch('chunk_index'),
+          sample_index: sample_index_incr.succ,
+          sample_size: original_sample.fetch('size'),
+          sample_offset: original_sample.fetch('offset'),
+          chunk_offset: min_chunk_offset,
+          original_chunk_offset: min_chunk_offset,
+          sample_delta: original_sample.fetch('delta'),
+          delta_sum: original_sample.fetch('delta_sum'),
+          absolute_delta_sum: 0,
+          composition_offset: original_sample.fetch('c_delta'),
+          is_keyframe: original_sample.fetch('keyframe'),
+        )
+      end
+    end
+  end
+end

data/lib/mp4/nolan/service.rb

@@ -0,0 +1,84 @@
+module MP4::Nolan
+  module Service
+    module_function
+
+    def divide_into_segments(cache)
+      segments = compute_segments(cache)
+
+      segments.each_with_index do |segment_args, segment_index|
+        compile_segment(cache, segment_index, *segment_args)
+      end
+
+      nil
+    end
+
+    def compute_segments(cache)
+      track_id = cache.first_video_track_id
+      return [] if track_id.nil?
+
+      video_track = cache.track(track_id)
+      timescale = video_track.fetch('timescale')
+
+      divide_video_by_keyframes(cache, track_id, timescale)
+    end
+
+    def compile_segment(cache, segment_index, _from_keyframe, _to_keyframe, segment_start_timestamp, segment_end_timestamp, _duration, previous_chunk_end_delta_sum, sample_timescale)
+      cache.tracks.each do |track|
+        case track['handler_type']
+        when 'vide'
+          Video.compute(cache, segment_index,
+                        track: track,
+                        from_timestamp: segment_start_timestamp,
+                        to_timestamp: segment_end_timestamp,
+                        sample_timescale: sample_timescale,)
+        when 'soun'
+          Sound.compute(cache, segment_index,
+                        track: track,
+                        from_timestamp: previous_chunk_end_delta_sum,
+                        to_timestamp: segment_end_timestamp,
+                        sample_timescale: sample_timescale,)
+        else
+          MP4.logger.warn "Nolan::Service: skipping unsupported track #{track['handler_type']}"
+        end
+      end
+    end
+
+    def divide_video_by_keyframes(cache, track_id, timescale)
+      first_keyframe   = cache.first_sample(track_id)
+      latest_keyframe  = cache.last_sample(track_id)
+      return [] if first_keyframe.nil? || latest_keyframe.nil?
+
+      original_keyframes = cache.keyframes_grouped_by_second(track_id)
+      return [] if original_keyframes.empty?
+
+      chunks = []
+      last_index = original_keyframes.size - 1
+
+      original_keyframes.each_with_index do |keyframe, idx|
+        keyframes =
+          if idx == last_index
+            [keyframe.fetch('sample_index'), latest_keyframe.fetch('sample_index')]
+          elsif idx.zero? && keyframe.fetch('delta_sum').to_i.nonzero?
+            [first_keyframe.fetch('sample_index'), keyframe.fetch('sample_index')]
+          else
+            [keyframe.fetch('sample_index'), original_keyframes[idx + 1].fetch('sample_index') - 1]
+          end
+
+        previous_chunk_end_delta_sum = chunks.dig(-1, 3)
+        duration = cache.sum_delta_between(track_id, keyframes.first, keyframes.last).to_f
+
+        chunks << [
+          keyframes.fetch(0),
+          keyframes.fetch(1),
+          cache.sample_delta_sum_ms(track_id, keyframes.first).to_i,
+          cache.sample_delta_sum_ms(track_id, keyframes.last).to_i,
+          (duration / timescale.to_f).round(3),
+          previous_chunk_end_delta_sum,
+          timescale,
+        ]
+      end
+
+      chunks
+    end
+  end
+end

data/lib/mp4/nolan.rb

@@ -0,0 +1,3 @@
+module MP4::Nolan
+  # Namespace method
+end

data/lib/mp4/parser/main_boxes.rb

@@ -0,0 +1,43 @@
+module MP4::Parser
+  module MainBoxes
+    class BoxAlreadyDefinedError < StandardError; end
+    class UnnamedBoxFoundError < StandardError; end
+
+    module_function
+
+    def parse(source, _offset = 0, _nested = [])
+      struct = {}
+
+      10.times do
+        break if source.eof?
+
+        current_offset = source.pos
+        header = get_header(source)
+        box_name = header[:box_name]
+        box_size = header[:box_size]
+
+        raise BoxAlreadyDefinedError.new(message: "Box #{box_name} already defined") if struct.key?(box_name)
+        raise UnnamedBoxFoundError.new(message: "Box #{box_name} already defined") if box_name.empty?
+
+        struct[box_name.to_sym] = [current_offset, box_size]
+
+        source.set_seek(current_offset + box_size)
+      end
+
+      struct
+    end
+
+    def get_header(source)
+      bytes = source.read(8)
+      box_size = BinData::Uint32be.read(bytes[0..4])
+      box_name = bytes[4..8]
+      ::MP4.logger.debug { "top-level box: #{box_name}/#{box_size}" } if ::MP4.verbose?
+      if box_size == 1
+        extra_size_bytes = source.read(8)
+        box_size = BinData::Uint64be.read(extra_size_bytes)
+      end
+
+      { box_size: box_size, box_name: box_name }
+    end
+  end
+end

data/lib/mp4/parser/moov.rb

@@ -0,0 +1,40 @@
+module MP4::Parser
+  class Moov
+    attr_reader :bytes, :mvhd, :tracks
+
+    def self.parse(bytes)
+      metadata = new(bytes)
+      metadata.parse
+      metadata
+    end
+
+    def initialize(bytes)
+      @bytes = bytes
+      @tracks = []
+    end
+
+    def parse
+      _header = bytes.read(8)
+
+      until bytes.eof?
+        box_size = BinData::Uint32be.read(bytes.read(4))
+        box_type = bytes.read(4)
+        box_bytes = StringIO.new(bytes.read(box_size - MP4::Constants::GENERIC_HEADER_SIZE))
+
+        send("parse_#{box_type}", box_bytes)
+      end
+    end
+
+    def parse_mvhd(bytes)
+      @mvhd = MP4::Binary::Mvhd.read(bytes).snapshot
+    end
+
+    def parse_trak(bytes)
+      @tracks << MP4::Parser::Track.parse(bytes)
+    end
+
+    def parse_iods(_bytes); end
+
+    def parse_udta(_bytes); end
+  end
+end

data/lib/mp4/parser/service.rb

@@ -0,0 +1,47 @@
+module MP4::Parser
+  class Service
+    attr_reader :source, :ftyp, :moov, :mdat
+
+    def initialize(source:)
+      @source = source
+    end
+
+    def call
+      parse
+    end
+
+    def parse
+      main_boxes = MainBoxes.parse(source)
+      parse_ftyp(*main_boxes.fetch(:ftyp))
+      parse_moov(*main_boxes.fetch(:moov))
+      parse_mdat(*main_boxes.fetch(:mdat))
+
+      self
+    end
+
+    def parse_ftyp(offset, box_size)
+      source.set_seek(offset + MP4::Constants::GENERIC_HEADER_SIZE)
+
+      @ftyp = MP4::Binary::Ftyp.read(
+        StringIO.new(source.read(box_size - MP4::Constants::GENERIC_HEADER_SIZE)),
+      ).snapshot
+    end
+
+    def parse_moov(offset, box_size)
+      source.set_seek(offset)
+
+      @moov = Moov.parse(
+        StringIO.new(source.read(box_size)),
+      )
+    end
+
+    def parse_mdat(offset, _box_size)
+      @mdat = { offset: offset }
+    end
+  end
+end
+
+# require_relative './lib/constants'
+# require_relative './lib/main_boxes'
+# require_relative './lib/moov'
+# require_relative './lib/recursive_parser'

data/lib/mp4/parser/track.rb

@@ -0,0 +1,56 @@
+module MP4::Parser
+  class Track
+    attr_reader :bytes
+
+    def self.parse(bytes)
+      new(bytes).parse
+    end
+
+    def initialize(bytes)
+      @bytes = bytes
+    end
+
+    def parse
+      parse_recursive
+    end
+
+    private
+
+    def parse_recursive(nested_bytes = nil, list = [])
+      structure = []
+      nested_bytes ||= bytes
+
+      loop do
+        box_bytes = nested_bytes
+        break if box_bytes.eof? || box_bytes.nil?
+
+        box_offset = box_bytes.pos
+        box_size = BinData::Uint32be.read(box_bytes.read(4))
+        box_type = box_bytes.read(4)
+
+        box_bytes = StringIO.new(box_bytes.read(box_size - MP4::Constants::GENERIC_HEADER_SIZE))
+
+        structure << [box_type, box_offset, box_size, box_bytes]
+      end
+
+      structure.each_with_object({}) do |(box_type, _box_offset, _box_size, box_bytes), buffer|
+        ::MP4.logger.debug { "parsing atom: #{list.join('->')} #{box_type}" } if ::MP4.verbose?
+
+        buffer[box_type.to_sym] = if MP4::Constants::PARSERS.key?(box_type)
+                                    parse_atom(box_type, box_bytes)
+                                  else
+                                    parse_recursive(box_bytes, [*list, box_type])
+                                  end
+      end
+    end
+
+    def parse_atom(box_type, box_bytes)
+      MP4::Constants::PARSERS.fetch(box_type)
+
+      serializer_klass = Kernel.const_get(MP4::Constants::PARSERS.fetch(box_type))
+
+      serializer_klass.read(box_bytes).snapshot
+    end
+
+  end
+end

data/lib/mp4/rb/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mp4
+  module Rb
+    VERSION = "0.1.0"
+  end
+end

data/lib/mp4/rb.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "rb/version"
+
+module Mp4
+  module Rb
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/mp4/source/base.rb

@@ -0,0 +1,20 @@
+module MP4::Source
+  module Base
+    REQUIRED_METHODS = %i[read set_seek reset_seek open! eof? pos uri].freeze
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def from_uri(_uri)
+        raise NotImplementedError, "#{name}.from_uri must be implemented"
+      end
+    end
+
+    def fetch(from, to)
+      set_seek(from)
+      read(to - from + 1)
+    end
+  end
+end

data/lib/mp4/source/local.rb

@@ -0,0 +1,79 @@
+module MP4::Source
+  class Local
+    include Base
+
+    attr_reader :path_to_file
+
+    def self.from_uri(uri, base_dir: nil)
+      raise ArgumentError, "expected local: URI, got #{uri.inspect}" unless uri.start_with?('local:')
+
+      path = uri.sub(/\Alocal:/, '')
+      resolved = resolve_path(path, base_dir)
+      new(resolved.to_s)
+    end
+
+    def self.resolve_path(path, base_dir)
+      candidate = Pathname.new(path)
+      return candidate if base_dir.nil?
+
+      root = Pathname.new(base_dir).expand_path
+      absolute = (candidate.absolute? ? candidate : root.join(candidate)).expand_path
+
+      unless absolute.to_s.start_with?(root.to_s + File::SEPARATOR) || absolute.to_s == root.to_s
+        raise ArgumentError, "path escapes base_dir: #{path.inspect}"
+      end
+
+      absolute
+    end
+
+    def initialize(path_to_file)
+      @path_to_file = path_to_file.to_s
+    end
+
+    def uri
+      "local:#{@path_to_file}"
+    end
+
+    def read(n)
+      file.read(n)
+    end
+
+    def set_seek(n)
+      file.seek(n)
+    end
+
+    def reset_seek
+      file.seek(0)
+    end
+
+    def open!
+      file
+      self
+    end
+
+    def eof?
+      file.eof?
+    end
+
+    def pos
+      file.pos
+    end
+
+    def mtime
+      File.mtime(@path_to_file)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def close
+      @file&.close
+      @file = nil
+    end
+
+    private
+
+    def file
+      @file ||= File.open(@path_to_file, 'rb')
+    end
+  end
+end

data/lib/mp4/source/s3.rb

@@ -0,0 +1,118 @@
+module MP4::Source
+  class S3
+    include Base
+
+    attr_reader :bucket, :key
+
+    class << self
+      def from_uri(uri, client: nil)
+        match = uri.match(%r{\As3://(?<bucket>[^/]+)/(?<key>.+)\z})
+        raise ArgumentError, "expected s3://BUCKET/KEY URI, got #{uri.inspect}" unless match
+
+        new(bucket: match[:bucket], key: match[:key], client: client)
+      end
+
+      def shared_client
+        @shared_client_mutex ||= Mutex.new
+        @shared_client_mutex.synchronize do
+          @shared_client ||= build_client
+        end
+      end
+
+      def reset_shared_client!
+        @shared_client_mutex&.synchronize { @shared_client = nil }
+      end
+
+      private
+
+      def build_client
+        require 'aws-sdk-s3'
+        options = {
+          region: ENV.fetch('AWS_REGION', 'us-east-1'),
+          http_open_timeout: Integer(ENV.fetch('S3_HTTP_OPEN_TIMEOUT', '5')),
+          http_read_timeout: Integer(ENV.fetch('S3_HTTP_READ_TIMEOUT', '30')),
+          http_idle_timeout: Integer(ENV.fetch('S3_HTTP_IDLE_TIMEOUT', '30')),
+        }
+        endpoint = ENV['MINIO_ENDPOINT'] || ENV['S3_ENDPOINT']
+        if endpoint
+          options[:endpoint]         = endpoint
+          options[:force_path_style] = true
+        end
+        access = ENV['MINIO_ACCESS_KEY_ID'] || ENV['AWS_ACCESS_KEY_ID']
+        secret = ENV['MINIO_SECRET_ACCESS_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
+        if access && secret
+          options[:access_key_id]     = access
+          options[:secret_access_key] = secret
+        end
+        Aws::S3::Client.new(**options)
+      end
+    end
+
+    def initialize(bucket:, key:, client: nil)
+      @bucket    = bucket
+      @key       = key
+      @client    = client
+      @position  = 0
+      @file_size = nil
+    end
+
+    def uri
+      "s3://#{@bucket}/#{@key}"
+    end
+
+    def open!
+      size
+      self
+    end
+
+    def read(n)
+      return ''.b if eof?
+
+      to = [@position + n - 1, size - 1].min
+      data = get_range(@position, to)
+      @position += data.bytesize
+      data
+    end
+
+    def fetch(from, to)
+      get_range(from, to)
+    end
+
+    def set_seek(n)
+      @position = n.clamp(0, size)
+    end
+
+    def reset_seek
+      @position = 0
+    end
+
+    def eof?
+      @position >= size
+    end
+
+    def pos
+      @position
+    end
+
+    def size
+      @file_size ||= client.head_object(bucket: @bucket, key: @key).content_length.to_i
+    end
+
+    def close
+      # No per-instance connection to close; connections live in the shared
+      # client's connection pool and are reused across sources.
+      nil
+    end
+
+    private
+
+    def client
+      @client ||= self.class.shared_client
+    end
+
+    def get_range(from, to)
+      resp = client.get_object(bucket: @bucket, key: @key, range: "bytes=#{from}-#{to}")
+      resp.body.read.b
+    end
+  end
+end