mp4-rb 0.1.0

data/lib/mp4/cache/memory.rb

@@ -0,0 +1,328 @@
+module MP4::Cache
+  # Drop-in metadata cache backed by Ruby data structures.
+  #
+  # Implements the **method-style** API (add_track, tracks, chunks, segments,
+  # add_sample, each_sample, add_ftyp/ftyp, add_dinf_content/dinf_content,
+  # add_stsd_content/stsd_content, add_elst_list_item/elst_entries,
+  # add_segment_sample, segment_samples).
+  #
+  # Deliberately does NOT emulate raw SQL: {#query} and {#execute} raise —
+  # see docs/CACHE_MIGRATION.md for the list of call sites (layout writers,
+  # Nolan segmentation, DASH manifest) that still speak SQL against
+  # MP4::Cache::SQLite and need method-API replacements before this backend
+  # can drive the full pipeline.
+  class Memory
+    def initialize(_location = nil)
+      @ftyp            = nil
+      @tracks          = {}
+      @chunks          = Hash.new { |h, k| h[k] = [] }
+      @samples         = Hash.new { |h, k| h[k] = [] }
+      @segment_samples = Hash.new { |h, k| h[k] = [] }
+      @elst            = Hash.new { |h, k| h[k] = [] }
+      @dinf            = {}
+      @stsd            = {}
+    end
+
+    def transaction
+      yield
+    end
+
+    def query(*_args)
+      raise NotImplementedError,
+            'MP4::Cache::Memory does not support raw SQL queries. ' \
+            'Use the method-style API instead (see docs/CACHE_MIGRATION.md).'
+    end
+    alias execute query
+
+    def add_ftyp(major_brand:, minor_version:, compatible_brands:)
+      @ftyp = {
+        'major_brand'       => major_brand.to_s,
+        'minor_version'     => minor_version.to_i,
+        'compatible_brands' => compatible_brands.to_s,
+      }
+    end
+
+    attr_reader :ftyp
+
+    def add_track(**opts)
+      row = {
+        'track_id'              => opts.fetch(:track_id),
+        'handler_type'          => opts.fetch(:handler_type),
+        'handler_name'          => opts.fetch(:handler_name),
+        'have_composition_time' => opts.fetch(:have_composition_time),
+        'timescale'             => opts.fetch(:timescale),
+        'creation_time'         => opts.fetch(:creation_time),
+        'width'                 => opts.fetch(:width),
+        'height'                => opts.fetch(:height),
+        'volume'                => opts.fetch(:volume),
+        'channel_count'         => opts.fetch(:channel_count),
+        'par'                   => opts.fetch(:par),
+        'sar'                   => opts.fetch(:sar),
+        'codec'                 => opts.fetch(:codec),
+        'max_bitrate'           => opts.fetch(:max_bitrate),
+        'avg_bitrate'           => opts.fetch(:avg_bitrate),
+        'sample_rate'           => opts.fetch(:sample_rate),
+        'mime_type'             => opts.fetch(:mime_type),
+        'alternate_group'       => opts.fetch(:alternate_group),
+      }
+      @tracks[row['track_id']] = row
+    end
+
+    def tracks
+      @tracks.values.sort_by { |t| t['handler_type'].to_s }.reverse
+    end
+
+    def tracks_asc
+      @tracks.values.sort_by { |t| t['track_id'] }
+    end
+
+    def track(track_id)
+      @tracks.fetch(track_id)
+    end
+
+    def add_chunk(track_id:, chunk_index:, samples_per_chunk:, sample_counter:, description_index:, offset:)
+      @chunks[track_id] << {
+        '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
+
+    def chunks(track_id)
+      @chunks[track_id]
+    end
+
+    def each_track(&block)
+      @chunks.keys.uniq.each(&block)
+    end
+
+    def add_sample(track_id:, chunk_index:, sample_index:, chunk_offset:, sample_delta:, delta_sum:, absolute_delta_sum:, composition_offset:, sample_size:, sample_offset: 0, original_chunk_offset: 0, is_keyframe: 'FALSE')
+      @samples[track_id] << sample_row(
+        track_id: track_id, chunk_index: chunk_index, sample_index: sample_index,
+        sample_size: sample_size, sample_offset: sample_offset,
+        chunk_offset: chunk_offset, original_chunk_offset: original_chunk_offset,
+        sample_delta: sample_delta, delta_sum: delta_sum,
+        absolute_delta_sum: absolute_delta_sum,
+        composition_offset: composition_offset, is_keyframe: is_keyframe,
+      )
+    end
+
+    def each_sample(track_id, &block)
+      @samples[track_id].each(&block)
+    end
+
+    def samples(track_id)
+      @samples[track_id]
+    end
+
+    def add_segment_sample(track_id:, segment_index:, chunk_index:, sample_index:, chunk_offset:, sample_delta:, delta_sum:, absolute_delta_sum:, composition_offset:, sample_size:, sample_offset: 0, original_chunk_offset: 0, is_keyframe: 'FALSE')
+      row = sample_row(
+        track_id: track_id, chunk_index: chunk_index, sample_index: sample_index,
+        sample_size: sample_size, sample_offset: sample_offset,
+        chunk_offset: chunk_offset, original_chunk_offset: original_chunk_offset,
+        sample_delta: sample_delta, delta_sum: delta_sum,
+        absolute_delta_sum: absolute_delta_sum,
+        composition_offset: composition_offset, is_keyframe: is_keyframe,
+      )
+      row['segment_index'] = segment_index
+      @segment_samples[track_id] << row
+    end
+
+    def segments(track_id)
+      @segment_samples[track_id]
+        .map { |s| s['segment_index'] }
+        .uniq
+        .sort
+        .map { |i| { 'segment_index' => i } }
+    end
+
+    def segment_samples(track_id, segment_index)
+      @segment_samples[track_id]
+        .select { |s| s['segment_index'] == segment_index }
+        .sort_by { |s| s['sample_index'] }
+    end
+
+    def add_elst_list_item(track_id:, track_duration:, media_time:, media_rate:, media_rate_fraction:)
+      @elst[track_id] << {
+        'track_id'            => track_id,
+        'track_duration'      => track_duration,
+        'media_time'          => media_time,
+        'media_rate'          => media_rate,
+        'media_rate_fraction' => media_rate_fraction,
+      }
+    end
+
+    def elst_entries(track_id)
+      @elst[track_id]
+    end
+
+    def add_dinf_content(track_id:, content:)
+      @dinf[track_id.to_i] = content
+    end
+
+    def dinf_content(track_id)
+      @dinf[track_id.to_i]
+    end
+
+    def add_stsd_content(track_id:, content:)
+      @stsd[track_id.to_i] = content
+    end
+
+    def stsd_content(track_id)
+      @stsd[track_id.to_i]
+    end
+
+    def first_video_track_id
+      @tracks.values.select { |t| t['handler_type'] == 'vide' }.map { |t| t['track_id'] }.min
+    end
+
+    def next_track_id
+      max = @tracks.keys.max
+      max && max + 1
+    end
+
+    def sample_count(track_id)
+      @samples[track_id].size
+    end
+
+    def first_sample(track_id)
+      @samples[track_id].min_by { |s| s['sample_index'] }
+    end
+
+    def last_sample(track_id)
+      @samples[track_id].max_by { |s| s['sample_index'] }
+    end
+
+    def sample_at(track_id, sample_index)
+      @samples[track_id].find { |s| s['sample_index'] == sample_index }
+    end
+
+    def sample_delta_sum_ms(track_id, sample_index)
+      row = sample_at(track_id, sample_index)
+      row && row['delta_sum_millisec']
+    end
+
+    def sum_delta_between(track_id, from_sample_index, to_sample_index)
+      @samples[track_id]
+        .select { |s| s['sample_index'] >= from_sample_index && s['sample_index'] <= to_sample_index }
+        .sum { |s| s['delta'].to_i }
+    end
+
+    def track_sample_delta_sum(track_id)
+      @samples[track_id].sum { |s| s['delta'].to_i }
+    end
+
+    def sync_sample_indices(track_id)
+      @samples[track_id].select { |s| s['keyframe'] == 'TRUE' }.map { |s| s['sample_index'] }.sort
+    end
+
+    def keyframes_grouped_by_second(track_id)
+      buckets = {}
+      @samples[track_id].each do |s|
+        next unless s['keyframe'] == 'TRUE'
+
+        bucket = s['delta_sum_millisec'].to_i / 1000
+        buckets[bucket] ||= { 'sample_index' => s['sample_index'], 'delta_sum' => s['delta_sum'] }
+      end
+      buckets.values
+    end
+
+    def samples_between_ms(track_id, from_ms, to_ms)
+      @samples[track_id]
+        .select { |s| s['delta_sum_millisec'] >= from_ms && s['delta_sum_millisec'] <= to_ms }
+        .sort_by { |s| s['sample_index'] }
+    end
+
+    def sample_size_list(track_id)
+      @samples[track_id].sort_by { |s| s['sample_index'] }.map { |s| s['size'] }
+    end
+
+    def uniform_sample_size?(track_id)
+      @samples[track_id].map { |s| s['size'] }.uniq.size == 1
+    end
+
+    def first_sample_size(track_id)
+      first = first_sample(track_id)
+      first && first['size']
+    end
+
+    def sample_delta_pairs(track_id)
+      @samples[track_id].sort_by { |s| s['sample_index'] }.map { |s| { 'sample_index' => s['sample_index'], 'delta' => s['delta'] } }
+    end
+
+    def sample_c_delta_pairs(track_id)
+      @samples[track_id].sort_by { |s| s['sample_index'] }.map { |s| { 'sample_index' => s['sample_index'], 'c_delta' => s['c_delta'] } }
+    end
+
+    def sample_chunk_indices(track_id)
+      @samples[track_id].sort_by { |s| s['sample_index'] }.map { |s| s['chunk_index'] }
+    end
+
+    def each_sample_ordered_across_tracks
+      rows = @samples.values.flatten.sort_by { |s| [s['sample_index'], s['track_id']] }
+      rows.each { |s| yield({ 'track_id' => s['track_id'], 'size' => s['size'], 'offset' => s['offset'] }) }
+    end
+
+    def min_sample_offset
+      @samples.values.flatten.map { |s| s['offset'] }.min
+    end
+
+    def segment_duration_ticks(track_id, segment_index)
+      @segment_samples[track_id]
+        .select { |s| s['segment_index'] == segment_index }
+        .sum { |s| s['delta'].to_i }
+    end
+
+    def segment_earliest_presentation_ticks(track_id, segment_index)
+      @segment_samples[track_id]
+        .select { |s| s['segment_index'] == segment_index }
+        .map { |s| s['delta_sum'] }
+        .min
+    end
+
+    def segment_size_bytes(track_id, segment_index)
+      @segment_samples[track_id]
+        .select { |s| s['segment_index'] == segment_index }
+        .sum { |s| s['size'].to_i }
+    end
+
+    def segment_duration_ticks_by_index(track_id)
+      grouped = @segment_samples[track_id].group_by { |s| s['segment_index'] }
+      grouped.map { |i, ss| { 'segment_index' => i, 'duration' => ss.sum { |s| s['delta'].to_i } } }.sort_by { |r| r['segment_index'] }
+    end
+
+    def max_segment_duration_ticks(track_id)
+      by_seg = segment_duration_ticks_by_index(track_id)
+      by_seg.map { |r| r['duration'] }.max
+    end
+
+    def segment_bytes_sizes_offsets(track_id, segment_index)
+      @segment_samples[track_id]
+        .select { |s| s['segment_index'] == segment_index }
+        .sort_by { |s| s['sample_index'] }
+        .map { |s| { 'size' => s['size'], 'offset' => s['offset'] } }
+    end
+
+    private
+
+    def sample_row(track_id:, chunk_index:, sample_index:, sample_size:, sample_offset:, chunk_offset:, original_chunk_offset:, sample_delta:, delta_sum:, absolute_delta_sum:, composition_offset:, is_keyframe:)
+      {
+        'track_id'              => track_id,
+        'chunk_index'           => chunk_index,
+        'sample_index'          => sample_index,
+        'size'                  => sample_size,
+        'offset'                => sample_offset,
+        'chunk_offset'          => chunk_offset,
+        'original_chunk_offset' => original_chunk_offset,
+        'delta'                 => sample_delta,
+        'delta_sum'             => delta_sum,
+        'delta_sum_millisec'    => absolute_delta_sum,
+        'c_delta'               => composition_offset,
+        'keyframe'              => is_keyframe,
+      }
+    end
+  end
+end

data/lib/mp4/cache/sqlite.rb

@@ -0,0 +1,348 @@
+module MP4::Cache
+  class SQLite
+    def initialize(location = nil)
+      require 'sqlite3'
+      @cache_db = ::SQLite3::Database.new(location || ':memory:')
+      @cache_db.results_as_hash = true
+
+      load_cache_tables
+    end
+
+    def query(*query)
+      query_result = @cache_db.query(*query)
+
+      if block_given?
+        until (row = query_result.next).nil?
+          yield(row)
+        end
+
+        return
+      end
+
+      query_result.to_a
+    end
+
+    def execute(*query)
+      @cache_db.execute(*query)
+    end
+
+    def transaction(&block)
+      @cache_db.transaction(&block)
+    end
+
+    def add_ftyp(major_brand:, minor_version:, compatible_brands:)
+      execute(
+        'INSERT INTO ftyp_cache VALUES(?, ?, ?)',
+        major_brand.to_s, minor_version.to_i, compatible_brands.to_s,
+      )
+    end
+
+    def ftyp
+      row = query('SELECT * FROM ftyp_cache').first
+      row && {
+        'major_brand'       => row['major_brand'],
+        'minor_version'     => row['minor_version'],
+        'compatible_brands' => row['compatible_brands'],
+      }
+    end
+
+    def add_chunk(track_id:, chunk_index:, samples_per_chunk:, sample_counter:, description_index:, offset:)
+      execute(
+        'INSERT INTO chunk_cache VALUES(?, ?, ?, ?, ?, ?)',
+        track_id, chunk_index, samples_per_chunk, sample_counter, description_index, offset,
+      )
+    end
+
+    def add_dinf_content(track_id:, content:)
+      execute('INSERT INTO dinf_cache VALUES(?, ?)', track_id.to_i, content)
+    end
+
+    def dinf_content(track_id)
+      query('SELECT content FROM dinf_cache WHERE track_id = ?', track_id).dig(0, 'content')
+    end
+
+    def add_stsd_content(track_id:, content:)
+      execute('INSERT INTO stsd_cache VALUES(?, ?)', track_id.to_i, content)
+    end
+
+    def stsd_content(track_id)
+      query('SELECT content FROM stsd_cache WHERE track_id = ?', track_id).dig(0, 'content')
+    end
+
+    def elst_entries(track_id)
+      query('SELECT * FROM elst_cache WHERE track_id = ?', track_id)
+    end
+
+    def add_track(**opts)
+      insert_sql = <<-SQL
+        INSERT INTO tracks_cache VALUES
+          (
+          :track_id,
+          :handler_type,
+          :handler_name,
+          :have_composition_time,
+          :timescale,
+          :creation_time,
+          :width,
+          :height,
+          :volume,
+          :channel_count,
+          :par,
+          :sar,
+          :codec,
+          :max_bitrate,
+          :avg_bitrate,
+          :sample_rate,
+          :mime_type,
+          :alternate_group
+        );
+      SQL
+
+      self.execute(insert_sql, opts)
+    end
+
+    def add_segment_sample(track_id:, segment_index:, chunk_index:, sample_index:, **opts)
+      insert_sql = <<-SQL
+        INSERT INTO segments_cache VALUES(
+          ?, -- track_id
+          ?, -- segment_index
+          ?, -- chunk_index
+          ?, -- sample_index
+          ?, -- sample_size
+          ?, -- sample_offset
+          ?, -- chunk_offset
+          ?, -- original_chunk_offset
+          ?, -- sample_delta
+          ?, -- delta_sum
+          ?, -- delta_sum_millsec
+          ?, -- c_delta
+          ? -- is_keyframe
+        );
+      SQL
+
+      self.execute(
+        insert_sql,
+        track_id,
+        segment_index,
+        chunk_index,
+        sample_index,
+        opts.fetch(:sample_size),
+        opts.fetch(:sample_offset, 0),
+        opts.fetch(:chunk_offset),
+        opts.fetch(:original_chunk_offset, 0),
+        opts.fetch(:sample_delta),
+        opts.fetch(:delta_sum),
+        opts.fetch(:absolute_delta_sum),
+        opts.fetch(:composition_offset),
+        opts.fetch(:is_keyframe, 'FALSE'),
+      )
+    end
+
+    def add_elst_list_item(**opts)
+      insert_sql = <<-SQL
+        INSERT INTO elst_cache VALUES(
+          :track_id,
+          :track_duration,
+          :media_time,
+          :media_rate,
+          :media_rate_fraction
+        );
+      SQL
+
+      self.execute(
+        insert_sql,
+        opts.fetch(:track_id),
+        opts.fetch(:track_duration),
+        opts.fetch(:media_time),
+        opts.fetch(:media_rate),
+        opts.fetch(:media_rate_fraction),
+      )
+    end
+
+    def add_sample(track_id:, chunk_index:, sample_index:, **opts)
+      insert_sql = <<-SQL
+        INSERT INTO samples_cache VALUES(
+          ?, -- track_id
+          ?, -- chunk_index
+          ?, -- sample_index
+          ?, -- sample_size
+          ?, -- sample_offset
+          ?, -- chunk_offset
+          ?, -- original_chunk_offset
+          ?, -- sample_delta
+          ?, -- delta_sum
+          ?, -- delta_sum_millsec
+          ?, -- c_delta
+          ? -- is_keyframe
+        );
+      SQL
+
+      self.execute(
+        insert_sql,
+        track_id,
+        chunk_index,
+        sample_index,
+        opts.fetch(:sample_size),
+        opts.fetch(:sample_offset, 0),
+        opts.fetch(:chunk_offset),
+        opts.fetch(:original_chunk_offset, 0),
+        opts.fetch(:sample_delta),
+        opts.fetch(:delta_sum),
+        opts.fetch(:absolute_delta_sum),
+        opts.fetch(:composition_offset),
+        opts.fetch(:is_keyframe, 'FALSE'),
+      )
+    end
+
+    def tracks_asc
+      query('SELECT * FROM tracks_cache ORDER BY track_id ASC')
+    end
+
+    def tracks
+      query('SELECT * FROM tracks_cache ORDER BY handler_type DESC')
+    end
+
+    def track(track_id)
+      query('SELECT * FROM tracks_cache WHERE track_id = ?', track_id).fetch(0)
+    end
+
+    def segments(track_id)
+      query('SELECT segment_index FROM segments_cache WHERE track_id = ? GROUP BY segment_index ORDER BY segment_index ASC', track_id)
+    end
+
+    def segment_samples(track_id, segment_index)
+      query('SELECT * FROM segments_cache WHERE track_id = ? AND segment_index = ? ORDER BY sample_index ASC', track_id, segment_index)
+    end
+
+    def chunks(track_id)
+      query('select * from chunk_cache where track_id = ?', track_id)
+    end
+
+    def each_track
+      query('select DISTINCT track_id from chunk_cache') do |row|
+        yield(row.fetch('track_id'))
+      end
+    end
+
+    def each_sample(track_id, &block)
+      query('select * from samples_cache where track_id = ?', track_id, &block)
+    end
+
+    def first_video_track_id
+      query('SELECT track_id FROM tracks_cache WHERE handler_type = ? ORDER BY track_id ASC LIMIT 1', 'vide').dig(0, 'track_id')
+    end
+
+    def next_track_id
+      query('SELECT MAX(track_id) + 1 AS n FROM tracks_cache').dig(0, 'n')
+    end
+
+    def sample_count(track_id)
+      query('SELECT COUNT(1) AS c FROM samples_cache WHERE track_id = ?', track_id).dig(0, 'c')
+    end
+
+    def first_sample(track_id)
+      query('SELECT * FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC LIMIT 1', track_id).first
+    end
+
+    def last_sample(track_id)
+      query('SELECT * FROM samples_cache WHERE track_id = ? ORDER BY sample_index DESC LIMIT 1', track_id).first
+    end
+
+    def sample_at(track_id, sample_index)
+      query('SELECT * FROM samples_cache WHERE track_id = ? AND sample_index = ? LIMIT 1', track_id, sample_index).first
+    end
+
+    def sample_delta_sum_ms(track_id, sample_index)
+      query('SELECT delta_sum_millisec FROM samples_cache WHERE track_id = ? AND sample_index = ? LIMIT 1', track_id, sample_index).dig(0, 'delta_sum_millisec')
+    end
+
+    def sum_delta_between(track_id, from_sample_index, to_sample_index)
+      query('SELECT SUM(delta) AS s FROM samples_cache WHERE track_id = ? AND sample_index >= ? AND sample_index <= ?', track_id, from_sample_index, to_sample_index).dig(0, 's')
+    end
+
+    def track_sample_delta_sum(track_id)
+      query('SELECT SUM(delta) AS s FROM samples_cache WHERE track_id = ?', track_id).dig(0, 's').to_i
+    end
+
+    def sync_sample_indices(track_id)
+      query("SELECT sample_index FROM samples_cache WHERE track_id = ? AND keyframe = 'TRUE' ORDER BY sample_index ASC", track_id).map { |r| r.fetch('sample_index') }
+    end
+
+    def keyframes_grouped_by_second(track_id)
+      query("SELECT sample_index, delta_sum FROM samples_cache WHERE track_id = ? AND keyframe = 'TRUE' GROUP BY (delta_sum_millisec / 1000)", track_id)
+    end
+
+    def samples_between_ms(track_id, from_ms, to_ms)
+      query('SELECT * FROM samples_cache WHERE track_id = ? AND delta_sum_millisec >= ? AND delta_sum_millisec <= ? ORDER BY sample_index ASC', track_id, from_ms, to_ms)
+    end
+
+    def sample_size_list(track_id)
+      query('SELECT size FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC', track_id).map { |r| r.fetch('size') }
+    end
+
+    def uniform_sample_size?(track_id)
+      query('SELECT COUNT(1) AS c FROM samples_cache WHERE track_id = ? GROUP BY size LIMIT 2', track_id).size == 1
+    end
+
+    def first_sample_size(track_id)
+      query('SELECT size FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC LIMIT 1', track_id).dig(0, 'size')
+    end
+
+    def sample_delta_pairs(track_id)
+      query('SELECT sample_index, delta FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC', track_id)
+    end
+
+    def sample_c_delta_pairs(track_id)
+      query('SELECT sample_index, c_delta FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC', track_id)
+    end
+
+    def sample_chunk_indices(track_id)
+      query('SELECT chunk_index FROM samples_cache WHERE track_id = ? ORDER BY sample_index ASC', track_id).map { |r| r.fetch('chunk_index') }
+    end
+
+    def each_sample_ordered_across_tracks(&block)
+      query('SELECT track_id, size, offset FROM samples_cache ORDER BY sample_index ASC, track_id ASC', &block)
+    end
+
+    def min_sample_offset
+      query('SELECT MIN(offset) AS o FROM samples_cache').dig(0, 'o')
+    end
+
+    def segment_duration_ticks(track_id, segment_index)
+      query('SELECT SUM(delta) AS d FROM segments_cache WHERE track_id = ? AND segment_index = ?', track_id, segment_index).dig(0, 'd')
+    end
+
+    def segment_earliest_presentation_ticks(track_id, segment_index)
+      query('SELECT MIN(delta_sum) AS d FROM segments_cache WHERE track_id = ? AND segment_index = ?', track_id, segment_index).dig(0, 'd')
+    end
+
+    def segment_size_bytes(track_id, segment_index)
+      query('SELECT SUM(size) AS s FROM segments_cache WHERE track_id = ? AND segment_index = ?', track_id, segment_index).dig(0, 's')
+    end
+
+    def segment_duration_ticks_by_index(track_id)
+      query('SELECT segment_index, SUM(delta) AS duration FROM segments_cache WHERE track_id = ? GROUP BY segment_index ORDER BY segment_index ASC', track_id)
+    end
+
+    def max_segment_duration_ticks(track_id)
+      query('SELECT SUM(delta) AS d FROM segments_cache WHERE track_id = ? GROUP BY segment_index ORDER BY d DESC LIMIT 1', track_id).dig(0, 'd')
+    end
+
+    def segment_bytes_sizes_offsets(track_id, segment_index)
+      query('SELECT size, offset FROM segments_cache WHERE track_id = ? AND segment_index = ? ORDER BY sample_index ASC', track_id, segment_index)
+    end
+
+    private
+
+    def load_cache_tables
+      migration_files.each do |migration_file|
+        execute migration_file.read
+      end
+    end
+
+    def migration_files
+      migration_dir = ::MP4.root.join('migrations')
+      Dir.entries(migration_dir).select { |path| path.end_with?('.sql') }.map { |path| Pathname.new(migration_dir.join(path)) }
+    end
+  end
+end

data/lib/mp4/cache.rb

@@ -0,0 +1,13 @@
+module MP4::Cache
+  BACKENDS = {
+    sqlite: 'MP4::Cache::SQLite',
+    memory: 'MP4::Cache::Memory',
+  }.freeze
+
+  def self.build(backend, location = nil)
+    klass_name = BACKENDS.fetch(backend) do
+      raise ArgumentError, "unknown cache backend: #{backend.inspect} (known: #{BACKENDS.keys.inspect})"
+    end
+    Object.const_get(klass_name).new(location)
+  end
+end