format_parser 2.2.1 → 2.4.3

data/lib/parsers/moov_parser/decoder.rb

@@ -1,353 +0,0 @@
-# Handles decoding of MOV/MPEG4 atoms/boxes in a stream. Will recursively
-# read atoms and parse their data fields if applicable. Also contains
-# a few utility functions for finding atoms in a list etc.
-# To know more about Atoms: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html
-class FormatParser::MOOVParser::Decoder
-  include FormatParser::IOUtils
-
-  class Atom < Struct.new(:at, :atom_size, :atom_type, :path, :children, :atom_fields)
-    def to_s
-      '%s (%s): %d bytes at offset %d' % [atom_type, path.join('.'), atom_size, at]
-    end
-
-    def field_value(data_field)
-      (atom_fields || {}).fetch(data_field)
-    end
-
-    def as_json(*a)
-      members.each_with_object({}) do |member_name, o|
-        o[member_name] = public_send(member_name).as_json(*a)
-      end
-    end
-  end
-
-  # Atoms (boxes) that are known to only contain children, no data fields.
-  # Avoid including udta or udta.meta here since we do not have methods
-  # for dealing with them yet.
-  KNOWN_BRANCH_ATOM_TYPES = %w(moov mdia trak clip edts minf dinf stbl)
-
-  # Mark that udta may contain both
-  KNOWN_BRANCH_AND_LEAF_ATOM_TYPES = [] # %w(udta) # the udta.meta thing used by iTunes
-
-  # Limit how many atoms we scan in sequence, to prevent derailments
-  MAX_ATOMS_AT_LEVEL = 128
-
-  # Finds the first atom in the given Array of Atom structs that
-  # matches the type, drilling down if a list of atom names is given
-  def find_first_atom_by_path(atoms, *atom_types)
-    type_to_find = atom_types.shift
-    requisite = atoms.find { |e| e.atom_type == type_to_find }
-
-    # Return if we found our match
-    return requisite if atom_types.empty?
-
-    # Return nil if we didn't find the match at this nesting level
-    return unless requisite
-
-    # ...otherwise drill further down
-    find_first_atom_by_path(requisite.children || [], *atom_types)
-  end
-
-  def find_atoms_by_path(atoms, atom_types)
-    type_to_find = atom_types.shift
-    requisites = atoms.select { |e| e.atom_type == type_to_find }
-
-    # Return if we found our match
-    return requisites if atom_types.empty?
-
-    # Return nil if we didn't find the match at this nesting level
-    return unless requisites
-
-    # ...otherwise drill further down
-    find_atoms_by_path(requisites.flat_map(&:children).compact || [], atom_types)
-  end
-
-  # A file can have multiple tracks. To identify the type it is necessary to check
-  # the fields `component_subtype` in hdlr atom under the trak atom
-  # More details in https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-DontLinkElementID_147
-  def find_video_trak_atom(atoms)
-    trak_atoms = find_atoms_by_path(atoms, ['moov', 'trak'])
-
-    return if trak_atoms.empty?
-
-    trak_atoms.find do |trak_atom|
-      hdlr_atom = find_first_atom_by_path([trak_atom], 'trak', 'mdia', 'hdlr')
-      next if hdlr_atom.nil?
-      hdlr_atom.atom_fields[:component_type] == 'mhlr' && hdlr_atom.atom_fields[:component_subtype] == 'vide'
-    end
-  end
-
-  def parse_ftyp_atom(io, atom_size)
-    # Subtract 8 for the atom_size+atom_type,
-    # and 8 once more for the major_brand and minor_version. The remaining
-    # numbr of bytes is reserved for the compatible brands, 4 bytes per
-    # brand.
-    num_brands = (atom_size - 8 - 8) / 4
-    {
-      major_brand: read_bytes(io, 4),
-      minor_version: read_binary_coded_decimal(io),
-      compatible_brands: (1..num_brands).map { read_bytes(io, 4) },
-    }
-  end
-
-  def parse_tkhd_atom(io, _)
-    version = read_byte_value(io)
-    is_v1 = version == 1
-    {
-      version: version,
-      flags: read_chars(io, 3),
-      ctime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      mtime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      trak_id: read_32bit_uint(io),
-      reserved_1: read_chars(io, 4),
-      duration: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      reserved_2: read_chars(io, 8),
-      layer: read_16bit_uint(io),
-      alternate_group: read_16bit_uint(io),
-      volume: read_16bit_uint(io),
-      reserved_3: read_chars(io, 2),
-      matrix_structure: (1..9).map { read_32bit_fixed_point(io) },
-      track_width: read_32bit_fixed_point(io),
-      track_height: read_32bit_fixed_point(io),
-    }
-  end
-
-  def parse_stts_atom(io, _)
-    version = read_byte_value(io)
-    is_v1 = version == 1
-    stts = {
-      version: version,
-      flags: read_bytes(io, 3),
-      number_of_entries: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      entries: []
-    }
-    stts[:number_of_entries].times {
-      stts[:entries] << {
-        sample_count: read_32bit_uint(io),
-        sample_duration: read_32bit_uint(io)
-      }
-    }
-    stts
-  end
-
-  def parse_stsd_atom(io, _)
-    version = read_byte_value(io)
-    is_v1 = version == 1
-    stsd = {
-      version: version,
-      flags: read_bytes(io, 3),
-      number_of_entries: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      codecs: []
-    }
-    stsd[:number_of_entries].times {
-      codec_length = read_32bit_uint(io)
-      stsd[:codecs] << read_bytes(io, 4)
-      io.seek(io.pos + codec_length - 8) # 8 bytes is the header length containing the codec length and the codec name that we just did read
-    }
-    stsd
-  end
-
-  def parse_mdhd_atom(io, _)
-    version = read_byte_value(io)
-    is_v1 = version == 1
-    {
-      version: version,
-      flags: read_bytes(io, 3),
-      ctime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      mtime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      tscale: read_32bit_uint(io),
-      duration: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      language: read_32bit_uint(io),
-      quality: read_32bit_uint(io),
-    }
-  end
-
-  def parse_vmhd_atom(io, _)
-    {
-      version: read_byte_value(io),
-      flags: read_bytes(io, 3),
-      graphics_mode: read_bytes(io, 2),
-      opcolor_r: read_32bit_uint(io),
-      opcolor_g: read_32bit_uint(io),
-      opcolor_b: read_32bit_uint(io),
-    }
-  end
-
-  def parse_mvhd_atom(io, _)
-    version = read_byte_value(io)
-    is_v1 = version == 1
-    {
-      version: version,
-      flags: read_bytes(io, 3),
-      ctime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      mtime: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      tscale: read_32bit_uint(io),
-      duration: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-      preferred_rate: read_32bit_uint(io),
-      reserved: read_bytes(io, 10),
-      matrix_structure: (1..9).map { read_32bit_fixed_point(io) },
-      preview_time: read_32bit_uint(io),
-      preview_duration: read_32bit_uint(io),
-      poster_time: read_32bit_uint(io),
-      selection_time: read_32bit_uint(io),
-      selection_duration: read_32bit_uint(io),
-      current_time: read_32bit_uint(io),
-      next_trak_id: read_32bit_uint(io),
-    }
-  end
-
-  def parse_dref_atom(io, _)
-    dict = {
-      version: read_byte_value(io),
-      flags: read_bytes(io, 3),
-      num_entries: read_32bit_uint(io),
-    }
-    num_entries = dict[:num_entries]
-    entries = (1..num_entries).map do
-      entry = {
-        size: read_32bit_uint(io),
-        type: read_bytes(io, 4),
-        version: read_bytes(io, 1),
-        flags: read_bytes(io, 3),
-      }
-      entry[:data] = read_bytes(io, entry[:size] - 12)
-      entry
-    end
-    dict[:entries] = entries
-    dict
-  end
-
-  def parse_elst_atom(io, _)
-    dict = {
-      version: read_byte_value(io),
-      flags: read_bytes(io, 3),
-      num_entries: read_32bit_uint(io),
-    }
-    is_v1 = dict[:version] == 1 # Usual is 0, version 1 has 64bit durations
-    num_entries = dict[:num_entries]
-    entries = (1..num_entries).map do
-      {
-        track_duration: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-        media_time: is_v1 ? read_64bit_uint(io) : read_32bit_uint(io),
-        media_rate: read_32bit_uint(io),
-      }
-    end
-    dict[:entries] = entries
-    dict
-  end
-
-  def parse_hdlr_atom(io, atom_size)
-    sub_io = StringIO.new(io.read(atom_size - 8))
-    version = read_byte_value(sub_io)
-    base_fields = {
-      version: version,
-      flags: read_bytes(sub_io, 3),
-      component_type: read_bytes(sub_io, 4),
-      component_subtype: read_bytes(sub_io, 4),
-      component_manufacturer: read_bytes(sub_io, 4),
-    }
-    if version == 1
-      version1_fields = {
-        component_flags: read_bytes(sub_io, 4),
-        component_flags_mask: read_bytes(sub_io, 4),
-        component_name: sub_io.read,
-      }
-      base_fields.merge(version1_fields)
-    else
-      base_fields
-    end
-  end
-
-  def parse_meta_atom(io, atom_size)
-    return if atom_size == 0 # this atom can be empty
-
-    parse_hdlr_atom(io, atom_size)
-  end
-
-  def parse_atom_fields_per_type(io, atom_size, atom_type)
-    if respond_to?("parse_#{atom_type}_atom", true)
-      send("parse_#{atom_type}_atom", io, atom_size)
-    else
-      nil # We can't look inside this leaf atom
-    end
-  end
-
-  def parse_atom_children_and_data_fields(io, atom_size_sans_header, atom_type, current_branch)
-    parse_atom_fields_per_type(io, atom_size_sans_header, atom_type)
-    extract_atom_stream(io, atom_size_sans_header, current_branch + [atom_type])
-  end
-
-  # Recursive descent parser - will drill down to atoms which
-  # we know are permitted to have leaf/branch atoms within itself,
-  # and will attempt to recover the data fields for leaf atoms
-  def extract_atom_stream(io, max_read, current_branch = [])
-    initial_pos = io.pos
-    atoms = []
-    MAX_ATOMS_AT_LEVEL.times do
-      atom_pos = io.pos
-
-      break if atom_pos - initial_pos >= max_read
-
-      size_and_type = io.read(4 + 4)
-      break if size_and_type.to_s.bytesize < 8
-
-      atom_size, atom_type = size_and_type.unpack('Na4')
-
-      # If atom_size is specified to be 1, it is larger than what fits into the
-      # 4 bytes and we need to read it right after the atom type
-      atom_size = read_64bit_uint(io) if atom_size == 1
-      atom_header_size = io.pos - atom_pos
-      atom_size_sans_header = atom_size - atom_header_size
-
-      children, fields = if KNOWN_BRANCH_AND_LEAF_ATOM_TYPES.include?(atom_type)
-        parse_atom_children_and_data_fields(io, atom_size_sans_header, atom_type, current_branch)
-      elsif KNOWN_BRANCH_ATOM_TYPES.include?(atom_type)
-        [extract_atom_stream(io, atom_size_sans_header, current_branch + [atom_type]), nil]
-      else # Assume leaf atom
-        [nil, parse_atom_fields_per_type(io, atom_size_sans_header, atom_type)]
-      end
-
-      atoms << Atom.new(atom_pos, atom_size, atom_type, current_branch + [atom_type], children, fields)
-
-      io.seek(atom_pos + atom_size)
-    end
-    atoms
-  end
-
-  def read_16bit_fixed_point(io)
-    _whole, _fraction = safe_read(io, 2).unpack('CC')
-  end
-
-  def read_32bit_fixed_point(io)
-    _whole, _fraction = safe_read(io, 4).unpack('nn')
-  end
-
-  def read_chars(io, n)
-    safe_read(io, n)
-  end
-
-  def read_byte_value(io)
-    safe_read(io, 1).unpack('C').first
-  end
-
-  def read_bytes(io, n)
-    safe_read(io, n)
-  end
-
-  def read_16bit_uint(io)
-    safe_read(io, 2).unpack('n').first
-  end
-
-  def read_32bit_uint(io)
-    safe_read(io, 4).unpack('N').first
-  end
-
-  def read_64bit_uint(io)
-    safe_read(io, 8).unpack('Q>').first
-  end
-
-  def read_binary_coded_decimal(io)
-    bcd_string = safe_read(io, 4)
-    [bcd_string].pack('H*').unpack('C*')
-  end
-end

data/lib/parsers/moov_parser.rb

@@ -1,165 +0,0 @@
-class FormatParser::MOOVParser
-  include FormatParser::IOUtils
-  require_relative 'moov_parser/decoder'
-
-  # Maps values of the "ftyp" atom to something
-  # we can reasonably call "file type" (something
-  # usable as a filename extension)
-  FTYP_MAP = {
-    'm4a ' => :m4a,
-    'mp4 ' => :mp4,
-    'qt  ' => :mov,
-  }
-
-  # https://tools.ietf.org/html/rfc4337#section-2
-  # There is also video/quicktime which we should be able to capture
-  # here, but there is currently no detection for MOVs versus MP4s
-  MP4_AU_MIME_TYPE = 'audio/mp4'
-  MP4_MIXED_MIME_TYPE = 'video/mp4'
-
-  def likely_match?(filename)
-    filename =~ /\.(m4a|m4v|ma4|mov|mp4)$/i
-  end
-
-  def call(io)
-    return unless matches_moov_definition?(io)
-
-    # Now we know we are in a MOOV, so go back and parse out the atom structure.
-    # Parsing out the atoms does not read their contents - at least it doesn't
-    # for the atoms we consider opaque (one of which is the "mdat" atom which
-    # will be the prevalent part of the file body). We do not parse these huge
-    # atoms - we skip over them and note where they are located.
-    io.seek(0)
-
-    # We have to tell the parser how far we are willing to go within the stream.
-    # Knowing that we will bail out early anyway we will permit a large read. The
-    # branch parse calls will know the maximum size to read from the parent atom
-    # size that gets parsed just before.
-    max_read_offset = 0xFFFFFFFF
-    decoder = Decoder.new
-    atom_tree = Measurometer.instrument('format_parser.decoder.extract_atom_stream') do
-      decoder.extract_atom_stream(io, max_read_offset)
-    end
-
-    ftyp_atom = decoder.find_first_atom_by_path(atom_tree, 'ftyp')
-    file_type = ftyp_atom&.field_value(:major_brand)
-    format = format_from_moov_type(file_type)
-
-    # Try to find the width and height in the tkhd
-    width, height = parse_dimensions(decoder, atom_tree)
-
-    # Try to find the "topmost" duration (respecting edits)
-    if mvhd = decoder.find_first_atom_by_path(atom_tree, 'moov', 'mvhd')
-      timescale = mvhd.field_value(:tscale)
-      duration = mvhd.field_value(:duration)
-      media_duration_s = duration / timescale.to_f
-    end
-
-    # M4A only contains audio, while MP4 and friends can contain video.
-    if format == :m4a
-      FormatParser::Audio.new(
-        format: format,
-        media_duration_seconds: media_duration_s,
-        content_type: MP4_AU_MIME_TYPE,
-        intrinsics: atom_tree,
-      )
-    else
-      FormatParser::Video.new(
-        format: format,
-        width_px: width,
-        height_px: height,
-        frame_rate: parse_time_to_sample_atom(decoder, atom_tree)&.truncate(2),
-        media_duration_seconds: media_duration_s,
-        content_type: MP4_MIXED_MIME_TYPE,
-        codecs: parse_sample_description_atom(decoder, atom_tree),
-        intrinsics: atom_tree
-      )
-    end
-  end
-
-  private
-
-  def format_from_moov_type(file_type)
-    FTYP_MAP.fetch(file_type.downcase, :mov)
-  end
-
-  # The dimensions are located in tkhd atom, but in some files it is necessary
-  # to get it below the video track, because it can have other tracks such as
-  # audio which does not have the dimensions.
-  # More details in https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-DontLinkElementID_147
-  #
-  # Returns [width, height] if the dimension is found
-  # Returns [nil, nil] if the dimension is not found
-  def parse_dimensions(decoder, atom_tree)
-    video_trak_atom = decoder.find_video_trak_atom(atom_tree)
-
-    tkhd = if video_trak_atom
-      decoder.find_first_atom_by_path([video_trak_atom], 'trak', 'tkhd')
-    else
-      decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'tkhd')
-    end
-
-    if tkhd
-      [tkhd.field_value(:track_width).first, tkhd.field_value(:track_height).first]
-    else
-      [nil, nil]
-    end
-  end
-
-  # An MPEG4/MOV/M4A will start with the "ftyp" atom. The atom must have a length
-  # of at least 16 (to accomodate the atom size and the atom type itself) plus the major brand
-  # and minor version fields. If we cannot find it we can be certain this is not our file.
-  def matches_moov_definition?(io)
-    maybe_atom_size, maybe_ftyp_atom_signature, maybe_major_brand = safe_read(io, 12).unpack('N1a4a4')
-    minimum_ftyp_atom_size = 4 + 4 + 4 + 4
-    maybe_atom_size >= minimum_ftyp_atom_size && maybe_ftyp_atom_signature == 'ftyp' && maybe_major_brand != 'crx '
-  end
-
-  # Sample information is found in the 'time-to-sample' stts atom.
-  # The media atom mdhd is needed too in order to get the movie timescale
-  def parse_time_to_sample_atom(decoder, atom_tree)
-    video_trak_atom = decoder.find_video_trak_atom(atom_tree)
-
-    stts = if video_trak_atom
-      decoder.find_first_atom_by_path([video_trak_atom], 'trak', 'mdia', 'minf', 'stbl', 'stts')
-    else
-      decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'mdia', 'minf', 'stbl', 'stts')
-    end
-
-    mdhd = if video_trak_atom
-      decoder.find_first_atom_by_path([video_trak_atom], 'trak', 'mdia', 'mdhd')
-    else
-      decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'mdia', 'mdhd')
-    end
-
-    if stts && mdhd
-      timescale = mdhd.atom_fields[:tscale]
-      sample_duration = stts.field_value(:entries).dig(0, :sample_duration)
-      if timescale.nil? || timescale == 0 || sample_duration.nil? || sample_duration == 0
-        nil
-      else
-        timescale.to_f / sample_duration
-      end
-    else
-      nil
-    end
-  end
-
-  def parse_sample_description_atom(decoder, atom_tree)
-    video_trak_atom = decoder.find_video_trak_atom(atom_tree)
-
-    stsd = if video_trak_atom
-      decoder.find_first_atom_by_path([video_trak_atom], 'trak', 'mdia', 'minf', 'stbl', 'stsd')
-    else
-      decoder.find_first_atom_by_path(atom_tree, 'moov', 'trak', 'mdia', 'minf', 'stbl', 'stsd')
-    end
-
-    if stsd
-      stsd.field_value(:codecs)
-    else
-      nil
-    end
-  end
-
-  FormatParser.register_parser new, natures: [:audio, :video], formats: FTYP_MAP.values, priority: 3
-end

data/spec/parsers/moov_parser_spec.rb

@@ -1,144 +0,0 @@
-
-require 'spec_helper'
-
-describe FormatParser::MOOVParser do
-  def deep_print_atoms(atoms, output, swimlanes = [])
-    return unless atoms
-
-    mid = '├'
-    last = '└'
-    horz = '─'
-    vert = '│'
-    cdn = '┬'
-    n_atoms = atoms.length
-
-    atoms.each_with_index do |atom, i|
-      is_last_child = i == (n_atoms - 1)
-      has_children = atom.children && atom.children.any?
-      connector = is_last_child ? last : mid
-      connector_down = has_children ? cdn : horz
-      connector_left = is_last_child ? ' ' : vert
-
-      output << swimlanes.join << connector << connector_down << horz << atom.to_s << "\n"
-      if af = atom.atom_fields
-        af.each do |(field, value)|
-          output << swimlanes.join << connector_left << ('   %s: %s' % [field, value.inspect]) << "\n"
-        end
-      end
-      deep_print_atoms(atom.children, output, swimlanes + [connector_left])
-    end
-  end
-
-  Dir.glob(fixtures_dir + '/MOOV/**/*.m4a').sort.each do |m4a_path|
-    it "is able to parse #{File.basename(m4a_path)}" do
-      result = subject.call(File.open(m4a_path, 'rb'))
-
-      expect(result).not_to be_nil
-      expect(result.nature).to eq(:audio)
-      expect(result.media_duration_seconds).to be_kind_of(Float)
-      expect(result.media_duration_seconds).to be > 0
-      expect(result.content_type).to be_kind_of(String)
-      expect(result.intrinsics).not_to be_nil
-    end
-  end
-
-  Dir.glob(fixtures_dir + '/MOOV/**/*.mov').sort.each do |mov_path|
-    it "is able to parse #{File.basename(mov_path)}" do
-      result = subject.call(File.open(mov_path, 'rb'))
-
-      expect(result).not_to be_nil
-      expect(result.nature).to eq(:video)
-      expect(result.width_px).to be > 0
-      expect(result.height_px).to be > 0
-      expect(result.media_duration_seconds).to be_kind_of(Float)
-      expect(result.media_duration_seconds).to be > 0
-      expect(result.content_type).to eq('video/mp4')
-
-      expect(result.intrinsics).not_to be_nil
-    end
-  end
-
-  Dir.glob(fixtures_dir + '/MOOV/**/*.mp4').sort.each do |mp4_path|
-    it "is able to parse #{File.basename(mp4_path)}" do
-      result = subject.call(File.open(mp4_path, 'rb'))
-
-      expect(result).not_to be_nil
-      expect(result.nature).to eq(:video)
-      expect(result.width_px).to be > 0
-      expect(result.height_px).to be > 0
-      expect(result.media_duration_seconds).to be_kind_of(Float)
-      expect(result.media_duration_seconds).to be > 0
-      expect(result.content_type).to eq('video/mp4')
-
-      expect(result.intrinsics).not_to be_nil
-    end
-  end
-
-  it 'parses an M4A file and provides the necessary metadata' do
-    m4a_path = fixtures_dir + '/MOOV/M4A/fixture.m4a'
-
-    result = subject.call(File.open(m4a_path, 'rb'))
-    expect(result).not_to be_nil
-    expect(result.nature).to eq(:audio)
-    expect(result.format).to eq(:m4a)
-    expect(result.content_type).to eq('audio/mp4')
-  end
-
-  it 'parses a MOV file and provides the necessary metadata' do
-    mov_path = fixtures_dir + '/MOOV/MOV/Test_Circular_ProRes422.mov'
-
-    result = subject.call(File.open(mov_path, 'rb'))
-
-    expect(result).not_to be_nil
-    expect(result.nature).to eq(:video)
-    expect(result.format).to eq(:mov)
-    expect(result.width_px).to eq(1920)
-    expect(result.height_px).to eq(1080)
-    expect(result.codecs).to eq(['apcn'])
-  end
-
-  it 'parses an MP4 video file and provides the necessary metadata' do
-    mov_path = fixtures_dir + '/MOOV/MP4/bmff.mp4'
-
-    result = subject.call(File.open(mov_path, 'rb'))
-
-    expect(result).not_to be_nil
-    expect(result.nature).to eq(:video)
-    expect(result.format).to eq(:mov)
-    expect(result.width_px).to eq(160)
-    expect(result.height_px).to eq(90)
-    expect(result.frame_rate).to eq(14.98)
-    expect(result.codecs).to eq(['avc1'])
-  end
-
-  it 'provides filename hints' do
-    expect(subject).to be_likely_match('file.m4v')
-  end
-
-  it 'reads correctly the video dimensions' do
-    mov_path = fixtures_dir + '/MOOV/MOV/Test_Dimensions.mov'
-
-    result = subject.call(File.open(mov_path, 'rb'))
-
-    expect(result).not_to be_nil
-    expect(result.nature).to eq(:video)
-    expect(result.format).to eq(:mov)
-    expect(result.width_px).to eq(640)
-    expect(result.height_px).to eq(360)
-    expect(result.frame_rate).to eq(30)
-  end
-
-  it 'does not raise error when a meta atom has size 0' do
-    mov_path = fixtures_dir + '/MOOV/MOV/Test_Meta_Atom_With_Size_Zero.mov'
-
-    result = subject.call(File.open(mov_path, 'rb'))
-    expect(result).not_to be_nil
-    expect(result.format).to eq(:mov)
-  end
-
-  it 'does not parse CR3 files' do
-    cr3_path = fixtures_dir + '/CR3/Canon EOS R10 (RAW).CR3'
-    result = subject.call(File.open(cr3_path, 'rb'))
-    expect(result).to be_nil
-  end
-end