mp4-rb 0.1.0

data/lib/mp4/layout/stsz.rb

@@ -0,0 +1,39 @@
+module MP4::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 = if all_sizes_equeal?
+                         MP4::Binary::Stsz.new(sample_size: sample_size, sample_count: sample_count)
+                       else
+                         MP4::Binary::Stsz.new(sample_count: sample_size_list.size, sample_sizes: sample_size_list)
+                       end
+
+      @binary_content = binary_content.to_binary_s
+    end
+
+    def sample_size_list
+      @sample_size_list ||= media_cache.sample_size_list(track_id)
+    end
+
+    def all_sizes_equeal?
+      media_cache.uniform_sample_size?(track_id)
+    end
+
+    def sample_size
+      media_cache.first_sample_size(track_id)
+    end
+
+    def sample_count
+      media_cache.sample_count(track_id)
+    end
+  end
+end

data/lib/mp4/layout/stts.rb

@@ -0,0 +1,35 @@
+module MP4::Layout
+  class Stts < Atom
+    using ::MP4::Ext::Refinements
+
+    private
+
+    def name
+      'stts'
+    end
+
+    def binary_content
+      @binary_content ||= MP4::Binary::Stts.new(
+        entries_count: generate_time_to_sample_list.size,
+        time_to_sample: generate_time_to_sample_list,
+      ).to_binary_s
+    end
+
+    def generate_time_to_sample_list
+      return @generate_time_to_sample_list if defined?(@generate_time_to_sample_list)
+
+      buffer = []
+      media_cache.sample_delta_pairs(track_id).each do |row|
+        delta = row.fetch('delta')
+        latest = buffer.last
+        if latest && latest[:sample_delta] == delta
+          latest[:sample_count] += 1
+        else
+          buffer << { sample_count: 1, sample_delta: delta }
+        end
+      end
+
+      @generate_time_to_sample_list = buffer
+    end
+  end
+end

data/lib/mp4/layout/tkhd.rb

@@ -0,0 +1,45 @@
+module MP4::Layout
+  class Tkhd < Atom
+    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: track_id,
+        duration: calculate_duration,
+        layer: 0,
+        alternate_group: 0,
+        volume: get_volume,
+        matrix: [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824],
+        width: get_width,
+        height: get_height,
+      ).to_binary_s
+    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
+
+    def get_volume
+      track.fetch('volume').to_f
+    end
+
+    def get_width
+      track.fetch('width').to_f
+    end
+
+    def get_height
+      track.fetch('height').to_f
+    end
+  end
+end

data/lib/mp4/layout/vsmhd.rb

@@ -0,0 +1,49 @@
+module MP4::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

data/lib/mp4/layout.rb

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

data/lib/mp4/metadata/memoize/ftyp.rb

@@ -0,0 +1,13 @@
+module MP4::Metadata
+  module Memoize
+    module Ftyp
+      def self.call(cache, ftyp)
+        cache.add_ftyp(
+          major_brand: ftyp.major_brand.to_s,
+          minor_version: ftyp.minor_version.to_i,
+          compatible_brands: ftyp.compatible_brands.to_s,
+        )
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/binary_stsd.rb

@@ -0,0 +1,13 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      module BinaryStsd
+        module_function
+
+        def call(track_id, cache, stsd_cache)
+          cache.add_stsd_content(track_id: track_id.to_i, content: stsd_cache.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/chunks.rb

@@ -0,0 +1,46 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      module Chunks
+        module_function
+
+        def call(track_id, cache, stco, stsc)
+          each_chunk(stsc, stco) do |chunk_index, samples_per_chunk, offset, description_index, sample_counter|
+            cache.add_chunk(
+              track_id: track_id,
+              chunk_index: chunk_index,
+              samples_per_chunk: samples_per_chunk,
+              sample_counter: sample_counter,
+              description_index: description_index,
+              offset: offset,
+            )
+          end
+        end
+
+        def each_chunk(stsc, stco)
+          sample_counter = 0
+
+          stsc.chunk_count.times do |i|
+            first_chunk = stsc.table[i].first_chunk.to_i
+            samples_per_chunk =  stsc.table[i].samples_per_chunk.to_i
+            description_index =  stsc.table[i].sample_description_index.to_i
+
+            last_chunk = i.next < stsc.chunk_count ? stsc.table[i.next].first_chunk - 1 : stco.chunks_count
+
+            (first_chunk..last_chunk).each do |chunk_index|
+              sample_counter += samples_per_chunk
+
+              yield(
+                chunk_index,
+                samples_per_chunk,
+                stco.offsets[chunk_index.pred].to_i,
+                description_index,
+                sample_counter
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/codec.rb

@@ -0,0 +1,82 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      module Codec
+        module_function
+
+        def parse(stsd_cache)
+          stsd = MP4::Binary::StsdAtom.read(stsd_cache)
+
+          memoize_codecs(stsd.codecs)
+        end
+
+        def memoize_codecs(codecs)
+          codecs.map { extract_codec(_1) }
+        end
+
+        def extract_codec(codec)
+          case codec.codec_type
+          when 'avc1'
+            avc1_data = MP4::Binary::Avc1.read(codec.content)
+            avc1(avc1_data)
+          when 'mp4a'
+            mp4a_data = MP4::Binary::Mp4a.read(codec.content)
+            mp4a(mp4a_data)
+          when 'hev1'
+            hev1_data = MP4::Binary::Hev1.read(codec.content)
+            hev1(hev1_data)
+          else
+            raise NotImplementedError, "Unable to memoize `#{codec.codec_type}' codec, track #{track_id}"
+          end
+        end
+
+        def avc1(avc1_data)
+          avc_profile_indication = avc1_data.avcC.avc_profile_indication
+          profile_compatibility = avc1_data.avcC.profile_compatibility
+          avc_level_indication = avc1_data.avcC.avc_level_indication
+
+          {
+            par: calculate_aspect_ratio(avc1_data.width.to_i, avc1_data.height.to_i),
+            sar: "#{avc1_data.pasp.h_spacing}:#{avc1_data.pasp.v_spacing}",
+            codec: format("avc1.%02X%02X%02X", avc_profile_indication, profile_compatibility, avc_level_indication).downcase,
+            max_bitrate: avc1_data.bitrate.max_bitrate.to_i,
+            avg_bitrate: avc1_data.bitrate.avg_bitrate.to_i,
+          }
+        end
+
+        def mp4a(mp4a_data)
+          object_type_indication = mp4a_data.esds.es_descriptor.dec_config_desc.object_type_indication
+          audio_object_type_byte = mp4a_data.esds.es_descriptor.dec_config_desc.dec_specific_info.info.bytes[0]
+          audio_object_type = (audio_object_type_byte >> 3) & 0x1F
+
+          {
+            codec: format("mp4a.%02x.%d", object_type_indication, audio_object_type),
+            channel_count: mp4a_data.channel_count,
+            sample_rate: (mp4a_data.sample_rate >> 16).to_i,
+            max_bitrate: mp4a_data.esds.es_descriptor.dec_config_desc.max_bitrate.to_i,
+            avg_bitrate: mp4a_data.esds.es_descriptor.dec_config_desc.avg_bitrate.to_i,
+          }
+        end
+
+        def hev1(hev1_data)
+          {
+            par: calculate_aspect_ratio(hev1_data[:width].to_i, hev1_data[:height].to_i),
+            sar: "#{hev1_data[:pasp].h_spacing}:#{hev1_data[:pasp].v_spacing}",
+            codec: 'hev1',
+            max_bitrate: hev1_data[:bitrate].max_bitrate.to_i,
+            avg_bitrate: hev1_data[:bitrate].avg_bitrate.to_i,
+          }
+        end
+
+        private_class_method def calculate_aspect_ratio(width, height)
+          gcd = width.gcd(height)
+
+          aspect_ratio_width = width / gcd
+          aspect_ratio_height = height / gcd
+
+          "#{aspect_ratio_width}:#{aspect_ratio_height}"
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/composition_offset_calculator.rb

@@ -0,0 +1,31 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      class CompositionOffsetCalculator
+        def initialize(ctts_table)
+          @ctts_table = ctts_table.dup
+          @ctts_table_dup = ctts_table.dup
+          @cached_total_samples = 0
+          @cached_composition_offset = nil
+        end
+
+        def find_composition_offset(sample_number)
+          return nil if @ctts_table.nil?
+
+          return @cached_composition_offset if sample_number <= @cached_total_samples
+
+          while (entry = @ctts_table.shift)
+            @cached_total_samples += entry.sample_count
+
+            if sample_number <= @cached_total_samples
+              @cached_composition_offset = entry.fetch(:composition_offset)
+              return @cached_composition_offset
+            end
+          end
+
+          raise "Sample Composition offset not found for sample index: #{sample_number}"
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/delta_calculator.rb

@@ -0,0 +1,29 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      class DeltaCalculator
+        def initialize(stts_table)
+          @stts_table = stts_table.dup
+          @stts_table_dup = stts_table.dup
+          @samples_processed_count = 0
+          @cached_delta = nil
+        end
+
+        def find_delta(sample_number)
+          return @cached_delta if sample_number <= @samples_processed_count
+
+          while (entry = @stts_table.shift)
+            @samples_processed_count += entry.sample_count
+
+            if sample_number <= @samples_processed_count
+              @cached_delta = entry.fetch(:sample_delta)
+              return @cached_delta
+            end
+          end
+
+          raise "Delta not found for sample index: #{sample_number}"
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/sample_to_chunk_calculator.rb

@@ -0,0 +1,63 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      class SampleToChunkCalculator
+        def initialize(stsc_table, total_chunks_count)
+          @stsc_table = stsc_table.dup
+          @total_chunks_count = total_chunks_count
+
+          @current_item = nil
+          @next_item = nil
+          @prev_item = nil
+          @counter = 0
+          @chunk_samples_counter = 0
+          @buffer = []
+          @intermediary_chunks_count = 0
+        end
+
+        def count_hidden(sample_number)
+          (@total_chunks_count - @counter).times do
+            @counter += 1
+            @chunk_samples_counter += @current_item[:samples_per_chunk]
+
+            return @counter if sample_number <= @chunk_samples_counter
+          end
+
+          nil
+        end
+
+        def search_in_buffer(sample_number)
+          @buffer.each do |samples_per_chunk|
+            @chunk_samples_counter += samples_per_chunk
+            @counter += 1
+            @buffer.shift
+
+            return @counter if sample_number <= @chunk_samples_counter
+          end
+
+          nil
+        end
+
+        def find_chunk_number(sample_number)
+          return @counter if sample_number <= @chunk_samples_counter
+
+          return count_hidden(sample_number) if @stsc_table.empty?
+
+          return search_in_buffer(sample_number) unless @buffer.empty?
+
+          @current_item = @stsc_table.shift
+          @next_item = @stsc_table.first || { samples_per_chunk: @current_item[:samples_per_chunk], first_chunk: @total_chunks_count }
+
+          chunks_between = [@next_item[:first_chunk] - @current_item[:first_chunk], 1].max
+          @buffer = Array.new(chunks_between) { @current_item[:samples_per_chunk] }
+
+          value_in_buffer = search_in_buffer(sample_number)
+
+          return value_in_buffer unless value_in_buffer.nil?
+
+          raise "Chunk not found for sample #{sample_number}"
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/stbl/samples.rb

@@ -0,0 +1,80 @@
+module MP4::Metadata
+  module Memoize
+    module Stbl
+      module Samples
+        module_function
+
+        def call(track_id, cache, stsc, stco, stss, stts, ctts, stsz)
+          sample_sizes = expand_stsz(stsz)
+          track_timescale = cache.track(track_id).fetch('timescale').to_i
+          stsc_calculator = SampleToChunkCalculator.new(stsc.table, stco.offsets.size)
+          ctts_calculator = CompositionOffsetCalculator.new(ctts&.entries_list)
+          delta_calculator = DeltaCalculator.new(stts.time_to_sample)
+
+          delta_sum_counter = 0
+          sample_offset_counter = 0
+          prev_sample_size = 0
+          prev_chunk_index = 0
+
+          cache.transaction do
+            stsz.sample_count.times do |index|
+              sample_index = index.next
+              sample_delta = delta_calculator.find_delta(sample_index)
+
+              chunk_index = stsc_calculator.find_chunk_number(sample_index)
+
+              chunk_offset = stco.offsets.fetch(chunk_index - 1)
+              is_keyframe = stss&.sync_sample&.include?(sample_index) ? 'TRUE' : 'FALSE'
+
+              if prev_chunk_index.zero? || prev_chunk_index != chunk_index
+                sample_offset_counter = chunk_offset
+              else
+                sample_offset_counter += prev_sample_size
+              end
+
+              prev_sample_size = sample_sizes[index].to_i
+
+              cache.add_sample(
+                track_id: track_id.to_i,
+                chunk_index: chunk_index.to_i,
+                sample_index: sample_index.to_i,
+                sample_size: sample_sizes[index].to_i,
+                sample_offset: sample_offset_counter,
+                chunk_offset: chunk_offset,
+                original_chunk_offset: chunk_offset,
+                sample_delta: sample_delta.to_i,
+                delta_sum: delta_sum_counter,
+                absolute_delta_sum: (delta_sum_counter.to_f / track_timescale * 1000.0).ceil,
+                composition_offset: ctts_calculator.find_composition_offset(sample_index),
+                is_keyframe: is_keyframe,
+              )
+
+              delta_sum_counter += sample_delta
+              prev_chunk_index = chunk_index
+            end
+          end
+        end
+
+        def expand_stsz(stsz)
+          return Hash.new(stsz.sample_size) if stsz.sample_size.to_i.nonzero?
+
+          stsz.sample_sizes
+        end
+
+        def fetch_composition_offset_by_sample_index(ctts, sample_number)
+          return nil if ctts.nil?
+
+          total_samples = 0
+
+          ctts.entries_list.each do |entry|
+            total_samples += entry.sample_count
+
+            return entry.fetch(:composition_offset) if total_samples >= sample_number
+          end
+
+          raise "Sample Composition offset not found for sample index: #{sample_index}"
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/track.rb

@@ -0,0 +1,98 @@
+module MP4::Metadata
+  module Memoize
+    module Track
+      module_function
+
+      using ::MP4::Ext::Refinements
+
+      def call(cache, track)
+        current_track_id = get_track_id(track)
+        ::MP4.logger.debug { "track #{current_track_id}: memoize started" }
+
+        memoize_overall_track_information(current_track_id, cache, track)
+        memoize_elst(current_track_id, cache, track)
+        memoize_dinf(current_track_id, cache, track)
+        memoize_stbl(current_track_id, cache, track)
+      end
+
+      def memoize_overall_track_information(track_id, cache, track)
+        codec_data = Stbl::Codec.parse(track.dig!(:mdia, :minf, :stbl, :stsd, :content))
+        handler_type = track.dig!(:mdia, :hdlr, :handler_type).to_s
+
+        cache.add_track(
+          track_id: track_id,
+          handler_type: handler_type,
+          handler_name: track.dig!(:mdia, :hdlr, :handler_name).to_s,
+          have_composition_time: track.dig!(:mdia, :minf, :stbl).fetch(:ctts, nil) ? 1 : 0,
+          timescale: track.dig!(:mdia, :mdhd, :timescale).to_i,
+          creation_time: track.dig!(:mdia, :mdhd, :creation_time).to_i,
+          width: track.dig!(:tkhd, :width).to_i,
+          height: track.dig!(:tkhd, :height).to_i,
+          volume: track.dig!(:tkhd, :volume).to_i,
+          channel_count: codec_data.dig(0, :channel_count),
+          par: codec_data.dig(0, :par),
+          sar: codec_data.dig(0, :sar),
+          codec: codec_data.dig(0, :codec),
+          sample_rate: codec_data.dig(0, :sample_rate),
+          max_bitrate: codec_data.dig(0, :max_bitrate),
+          avg_bitrate: codec_data.dig(0, :avg_bitrate),
+          mime_type: { 'vide' => 'video/mp4', 'soun' => 'audio/mp4' }.fetch(handler_type),
+          alternate_group: track.dig!(:tkhd, :alternate_group),
+        )
+
+        ::MP4.logger.debug { "track #{track_id}: metadata memoized (#{handler_type}, #{codec_data.dig(0, :codec)})" }
+      end
+
+      def memoize_dinf(track_id, cache, track)
+        cache.add_dinf_content(
+          track_id: track_id,
+          content: track.dig!(:mdia, :minf, :dinf, :content),
+        )
+      end
+
+      def memoize_stbl(current_track_id, cache, track)
+        stbl_start = Time.now
+
+        Stbl::BinaryStsd.call(current_track_id, cache, track.dig!(:mdia, :minf, :stbl, :stsd, :content))
+
+        Stbl::Chunks.call(
+          current_track_id, cache,
+          track.dig!(:mdia, :minf, :stbl, :stco),
+          track.dig!(:mdia, :minf, :stbl, :stsc),
+        )
+
+        Stbl::Samples.call(
+          current_track_id, cache,
+          track.dig!(:mdia, :minf, :stbl).fetch(:stsc, nil),
+          track.dig!(:mdia, :minf, :stbl).fetch(:stco, nil),
+          track.dig!(:mdia, :minf, :stbl).fetch(:stss, nil),
+          track.dig!(:mdia, :minf, :stbl).fetch(:stts, nil),
+          track.dig!(:mdia, :minf, :stbl).fetch(:ctts, nil),
+          track.dig!(:mdia, :minf, :stbl).fetch(:stsz, nil),
+        )
+
+        ::MP4.logger.debug { "track #{current_track_id}: stbl memoized in #{(Time.now - stbl_start).round(2)} s" }
+      end
+
+      def memoize_elst(current_track_id, cache, track)
+        elst_matrix = track.dig(:edts, :elst, :matrix)
+
+        return if elst_matrix.nil?
+
+        elst_matrix.each do |matrix|
+          cache.add_elst_list_item(
+            track_id: current_track_id,
+            track_duration: matrix.fetch(:segment_duration),
+            media_time: matrix.fetch(:media_time),
+            media_rate: matrix.fetch(:media_rate),
+            media_rate_fraction: matrix.fetch(:media_rate_fraction),
+          )
+        end
+      end
+
+      def get_track_id(track)
+        track.fetch(:tkhd).fetch(:track_id).to_i
+      end
+    end
+  end
+end

data/lib/mp4/metadata/memoize/tracks.rb

@@ -0,0 +1,11 @@
+module MP4::Metadata
+  module Memoize
+    module Tracks
+      def self.call(cache, moov)
+        moov.tracks.each do |track|
+          Track.call(cache, track)
+        end
+      end
+    end
+  end
+end

data/lib/mp4/metadata/service.rb

@@ -0,0 +1,30 @@
+module MP4::Metadata
+  class Service
+    def self.call(cache:, parsed_mp4:)
+      new(cache).memoize!(parsed_mp4)
+    end
+
+    def initialize(cache)
+      @cache = cache
+    end
+
+    def memoize!(parsed_mp4)
+      started_at = Time.now
+      ::MP4.logger.info { 'memoize: starting' }
+
+      memoize_ftyp(parsed_mp4)
+      memoize_tracks(parsed_mp4)
+
+      ::MP4.logger.info { "memoize: done in #{(Time.now - started_at).round(2)} s" }
+      nil
+    end
+
+    def memoize_ftyp(parsed_mp4)
+      Memoize::Ftyp.call(@cache, parsed_mp4.ftyp)
+    end
+
+    def memoize_tracks(parsed_mp4)
+      Memoize::Tracks.call(@cache, parsed_mp4.moov)
+    end
+  end
+end

data/lib/mp4/metadata/summary.rb

@@ -0,0 +1,11 @@
+module MP4::Metadata
+  module Summary
+    module_function
+
+    def generate(_parsed_mp4, _cache)
+      {
+        # mdat_offset:
+      }
+    end
+  end
+end