format_parser 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3f9d1c51523af6efea2ed6f8cf63f0f573e2b0b140c1af0435e6bb26961953c
-  data.tar.gz: 84b73895b8924a0cffa286a4adaa3c270951e4074ec09db718f1a8d482b8e14b
+  metadata.gz: 8b3cef665ae16efd68e8da952fd4656e2d9403f3899bd58839da3d8026db91f4
+  data.tar.gz: 7b0ec88efc2ea62f526699a4041cb3f1b3062994d2a6e0b24c2cfdf247aaf532
 SHA512:
-  metadata.gz: cfa0a69fd35d8d3c05fff79cca1b550af8b8c6876fece5443fc41f7967fed15fe20d494ce5678e16cb2a1cdd1b0918b8ce61ef4b731f3e47b18c736ca21cdf0c
-  data.tar.gz: 0f7747775606681981367432322bb7b63e2e3c862fcd506d0b843bfc2280ae3d8dcdf334f49a9150f27a181329cf993f9cf79036d8124e75d41ca01f26edebd6
+  metadata.gz: 24c6379ef4fd3b5a9f061c6fc40fd8c0498ad33213684d08dd27a8b8994ba40a98bf1fa18a6d6b3b8189aa71436ec9bb394e3b8d41a8dd3ca90a5b93d0f1718a
+  data.tar.gz: a2d3df2c17d2559aa99f52f04624032a9243915f2a1b28a6f3626bd3b9112eb8c325b0c9a286864d25c2b4e92a44a8939448a85d1004ac5d48c2f81f747749c1

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.7.0
+* Add support for `ARW` files.
+
+## 1.6.0
+* Add support for `AAC` files.
+
 ## 1.5.0
 * Add support for `NEF` files.
 

data/README.md

@@ -149,6 +149,14 @@ Unless specified otherwise in this section the fixture files are MIT licensed an
 ### MP3
 - Cassy.mp3 has been produced by WeTransfer and may be used with the library for the purposes of testing
 
+### AAC
+- Originals music files: “Furious Freak” and “Galway”, Kevin MacLeod (incompetech.com), Licensed under Creative Commons: By Attribution 3.0, http://creativecommons.org/licenses/by/3.0/
+- The AAC samples were converted from 'wav' format and made available [here](https://espressif-docs.readthedocs-hosted.com/projects/esp-adf/en/latest/design-guide/audio-samples.html) by Espressif Systems, as part of their audio development framework (under the ESPRESSIF MIT License).
+- Files:
+  - ff-16b-2c-44100hz.aac
+  - ff-16b-1c-44100hz.aac
+  - gs-16b-2c-44100hz.aac
+  - gs-16b-1c-44100hz.aac
 ### FDX
 - fixture.fdx was created by one of the project maintainers and is MIT licensed
 
@@ -186,7 +194,7 @@ Unless specified otherwise in this section the fixture files are MIT licensed an
 - `IMG_9266_*.tif` and all it's variations were created by the project maintainers
 
 ### ARW
-- ARW example is downloaded from http://www.rawsamples.ch/ and is Creative Common Licensed.
+- ARW examples are downloaded from http://www.rawsamples.ch/ and are Creative Common Licensed.
 
 ### ZIP
 - The .zip fixture files have been created by the project maintainers

data/lib/format_parser/version.rb

@@ -1,3 +1,3 @@
 module FormatParser
-  VERSION = '1.5.0'
+  VERSION = '1.7.0'
 end

data/lib/parsers/aac_parser/adts_header_info.rb

@@ -0,0 +1,138 @@
+# This is a representation of the relevant information found in an Audio Data Transport Stream (ADTS) file header.
+class FormatParser::AdtsHeaderInfo
+  attr_accessor :mpeg_version, :layer, :protection_absence, :profile, :mpeg4_sampling_frequency_index,
+                :mpeg4_channel_config, :originality, :home_usage, :frame_length, :buffer_fullness,
+                :aac_frames_per_adts_frame
+
+  # An ADTS header has the following format, when represented in bits:
+  # AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM MMMMMMMM MMMOOOOO OOOOOOPP (QQQQQQQQ QQQQQQQQ)
+  # The chunks represented by these letters have specific meanings, as described here:
+  # https://wiki.multimedia.cx/index.php/ADTS
+
+  AAC_ADTS_HEADER_BITS_CHUNK_SIZES = [
+    ['A', 12], ['B', 1], ['C', 2], ['D', 1],
+    ['E', 2], ['F', 4], ['G', 1], ['H', 3],
+    ['I', 1], ['J', 1], ['K', 1], ['L', 1],
+    ['M', 13], ['O', 11], ['P', 2], ['Q', 16]
+  ]
+  MPEG4_AUDIO_OBJECT_TYPE_RANGE = 0..45
+  MPEG4_AUDIO_SAMPLING_FREQUENCY_RANGE = 0..14
+  MPEG4_AUDIO_SAMPLING_FREQUENCY_HASH = {
+    0 => 96000, 1 => 88200, 2 => 64000,
+    3 => 48000, 4 => 44100, 5 => 32000,
+    6 => 24000, 7 => 22050, 8 => 16000,
+    9 => 12000, 10 => 11025, 11 => 8000,
+    12 => 7350, 13 => 'Reserved', 14 => 'Reserved'
+  }
+  AAC_PROFILE_DESCRIPTION_HASH = {
+    0 => 'AAC_MAIN',
+    1 => 'AAC_LC (Low Complexity)',
+    2 => 'AAC_SSR (Scaleable Sampling Rate)',
+    3 => 'AAC_LTP (Long Term Prediction)'
+  }
+  MPEG_VERSION_HASH = { 0 => 'MPEG-4', 1 => 'MPEG-2'}
+
+  def mpeg4_sampling_frequency
+    if !@mpeg4_sampling_frequency_index.nil? && MPEG4_AUDIO_SAMPLING_FREQUENCY_HASH.key?(@mpeg4_sampling_frequency_index)
+      return MPEG4_AUDIO_SAMPLING_FREQUENCY_HASH[@mpeg4_sampling_frequency_index]
+    end
+    nil
+  end
+
+  def profile_description
+    if !@profile.nil? && AAC_PROFILE_DESCRIPTION_HASH.key?(@profile)
+      return AAC_PROFILE_DESCRIPTION_HASH[@profile]
+    end
+    nil
+  end
+
+  def mpeg_version_description
+    if !@mpeg_version.nil? && MPEG_VERSION_HASH.key?(@mpeg_version)
+      return MPEG_VERSION_HASH[@mpeg_version]
+    end
+    nil
+  end
+
+  def number_of_audio_channels
+    case @mpeg4_channel_config
+    when 1..6
+      @mpeg4_channel_config
+    when 7
+      8
+    else
+      nil
+    end
+  end
+
+  def fixed_bitrate?
+    # A buffer fullness value of 0x7FF (decimal: 2047) denotes a variable bitrate, for which buffer fullness isn't applicable
+    @buffer_fullness != 2047
+  end
+
+  # The frame rate - i.e. frames per second
+  def frame_rate
+    # An AAC sample uncompresses to 1024 PCM samples
+    mpeg4_sampling_frequency.to_f / 1024
+  end
+
+  # If the given bit array is a valid ADTS header, this method will parse it and return an instance of AdtsHeaderInfo.
+  # Will return nil if the header does not match the ADTS specifications.
+  def self.parse_adts_header(header_bits)
+    result = FormatParser::AdtsHeaderInfo.new
+
+    AAC_ADTS_HEADER_BITS_CHUNK_SIZES.each do |letter_size|
+      letter = letter_size[0]
+      chunk_size = letter_size[1]
+      chunk = header_bits.shift(chunk_size)
+      decimal_number = chunk.join.to_i(2)
+
+      # Skipping data represented by the letters G, K, L, Q, as we are not interested in those values.
+      case letter
+      when 'A'
+        # Syncword, all bits must be set to 1
+        return nil unless chunk.all? { |bit| bit == '1' }
+      when 'B'
+        # MPEG Version, set to 0 for MPEG-4 and 1 for MPEG-2
+        result.mpeg_version = decimal_number
+      when 'C'
+        # Layer, always set to 0
+        return nil unless decimal_number == 0
+      when 'D'
+        # Protection absence, set to 1 if there is no CRC and 0 if there is CRC
+        result.protection_absence = decimal_number == 1
+      when 'E'
+        # AAC Profile
+        return nil unless MPEG4_AUDIO_OBJECT_TYPE_RANGE.include?(decimal_number + 1)
+        result.profile = decimal_number
+      when 'F'
+        # MPEG-4 Sampling Frequency Index (15 is forbidden)
+        return nil unless MPEG4_AUDIO_SAMPLING_FREQUENCY_RANGE.include?(decimal_number)
+        result.mpeg4_sampling_frequency_index = decimal_number
+      when 'H'
+        # MPEG-4 Channel Configuration (in the case of 0, the channel configuration is sent via an in-band PCE (Program Config Element))
+        result.mpeg4_channel_config = decimal_number
+      when 'I'
+        # Originality, set to 1 to signal originality of the audio and 0 otherwise
+        result.originality = decimal_number == 1
+      when 'J'
+        # Home, set to 1 to signal home usage of the audio and 0 otherwise
+        result.home_usage = decimal_number == 1
+      when 'M'
+        # Frame length, length of the ADTS frame including headers and CRC check (protectionabsent == 1? 7: 9)
+        # We expect this to be higher than the header length, but we won't impose any other restrictions
+        header_length = result.protection_absence ? 7 : 9
+        return nil unless decimal_number > header_length
+        result.frame_length = decimal_number
+      when 'O'
+        # Buffer fullness, states the bit-reservoir per frame.
+        # It is merely an informative field with no clear use case defined in the specification.
+        result.buffer_fullness = decimal_number
+      when 'P'
+        # Number of AAC frames (RDBs (Raw Data Blocks)) in ADTS frame minus 1. For maximum compatibility always use one AAC frame per ADTS frame.
+        result.aac_frames_per_adts_frame = decimal_number + 1
+      end
+    end
+
+    result
+  end
+end

data/lib/parsers/aac_parser.rb

@@ -0,0 +1,35 @@
+require_relative 'aac_parser/adts_header_info'
+
+class FormatParser::AACParser
+  include FormatParser::IOUtils
+
+  AAC_MIME_TYPE = 'audio/aac'
+
+  def likely_match?(filename)
+    filename =~ /\.aac$/i
+  end
+
+  def call(raw_io)
+    io = FormatParser::IOConstraint.new(raw_io)
+    header = safe_read(io, 9)
+    header_bits = header.unpack('B*').first.split('')
+
+    header_info = FormatParser::AdtsHeaderInfo.parse_adts_header(header_bits)
+    return if header_info.nil?
+
+    FormatParser::Audio.new(
+      title: nil,
+      album: nil,
+      artist: nil,
+      format: :aac,
+      num_audio_channels: header_info.number_of_audio_channels,
+      audio_sample_rate_hz: header_info.mpeg4_sampling_frequency,
+      media_duration_seconds: nil,
+      media_duration_frames: nil,
+      intrinsics: nil,
+      content_type: AAC_MIME_TYPE
+    )
+  end
+
+  FormatParser.register_parser new, natures: :audio, formats: :aac
+end

data/lib/parsers/arw_parser.rb

@@ -0,0 +1,50 @@
+require_relative 'exif_parser'
+
+class FormatParser::ARWParser
+  include FormatParser::IOUtils
+  include FormatParser::EXIFParser
+
+  # Standard TIFF headers
+  MAGIC_LE = [0x49, 0x49, 0x2A, 0x0].pack('C4')
+  MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
+  HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
+  ARW_MIME_TYPE = 'image/x-sony-arw'
+
+  def likely_match?(filename)
+    filename =~ /\.arw$/i
+  end
+
+  def call(io)
+    io = FormatParser::IOConstraint.new(io)
+
+    return unless HEADER_BYTES.include?(safe_read(io, 4))
+    exif_data = exif_from_tiff_io(io)
+
+    return unless valid?(exif_data)
+
+    w = exif_data.width || exif_data.pixel_x_dimension
+    h = exif_data.height || exif_data.pixel_y_dimension
+
+    FormatParser::Image.new(
+      format: :arw,
+      width_px: w,
+      height_px: h,
+      display_width_px: exif_data.rotated? ? h : w,
+      display_height_px: exif_data.rotated? ? w : h,
+      orientation: exif_data.orientation_sym,
+      intrinsics: { exif: exif_data },
+      content_type: ARW_MIME_TYPE,
+    )
+  rescue EXIFR::MalformedTIFF
+    nil
+  end
+
+  def valid?(exif_data)
+    # taken directly from tiff_parser.rb
+    # Similar to how exiftool determines the image type as ARW, we are implementing a check here
+    # https://github.com/exiftool/exiftool/blob/e969456372fbaf4b980fea8bb094d71033ac8bf7/lib/Image/ExifTool/Exif.pm#L929
+    exif_data.compression == 6 && exif_data.new_subfile_type == 1 && exif_data.make&.start_with?('SONY')
+  end
+
+  FormatParser.register_parser new, natures: :image, formats: :arw
+end

data/lib/parsers/tiff_parser.rb

@@ -6,7 +6,6 @@ class FormatParser::TIFFParser
   MAGIC_BE = [0x4D, 0x4D, 0x0, 0x2A].pack('C4')
   HEADER_BYTES = [MAGIC_LE, MAGIC_BE]
   TIFF_MIME_TYPE = 'image/tiff'
-  ARW_MIME_TYPE = 'image/x-sony-arw'
 
   def likely_match?(filename)
     filename =~ /\.tiff?$/i
@@ -28,20 +27,20 @@ class FormatParser::TIFFParser
     exif_data = exif_from_tiff_io(io)
     return unless exif_data
 
+    return if arw?(exif_data)
+
     w = exif_data.width || exif_data.pixel_x_dimension
     h = exif_data.height || exif_data.pixel_y_dimension
 
-    format = arw?(exif_data) ? :arw : :tif
-    mime_type = arw?(exif_data) ? ARW_MIME_TYPE : TIFF_MIME_TYPE
     FormatParser::Image.new(
-      format: format,
+      format: :tif,
       width_px: w,
       height_px: h,
       display_width_px: exif_data.rotated? ? h : w,
       display_height_px: exif_data.rotated? ? w : h,
       orientation: exif_data.orientation_sym,
       intrinsics: {exif: exif_data},
-      content_type: mime_type,
+      content_type: TIFF_MIME_TYPE,
     )
   rescue EXIFR::MalformedTIFF
     nil
@@ -55,7 +54,7 @@ class FormatParser::TIFFParser
   # Similar to how exiftool determines the image type as ARW, we are implementing a check here
   # https://github.com/exiftool/exiftool/blob/e969456372fbaf4b980fea8bb094d71033ac8bf7/lib/Image/ExifTool/Exif.pm#L929
   def arw?(exif_data)
-    exif_data.compression == 6 && exif_data.new_subfile_type == 1 && exif_data.make == 'SONY'
+    exif_data.compression == 6 && exif_data.new_subfile_type == 1 && exif_data.make&.start_with?('SONY')
   end
 
   FormatParser.register_parser new, natures: :image, formats: :tif

data/spec/parsers/aac_parser_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe FormatParser::AACParser do
+  it 'should match filenames with valid AAC extensions' do
+    filenames = ['audiofile', 'audio_file', 'audio-file', 'audio file', 'audio.file']
+    extensions = ['.aac', '.AAC', '.Aac', '.AAc', '.aAc', '.aAC', '.aaC']
+    filenames.each do |filename|
+      extensions.each do |extension|
+        expect(subject.likely_match?(filename + extension)).to be_truthy
+      end
+    end
+  end
+
+  it 'should not match filenames with invalid AAC extensions' do
+    extensions = ['.aa', '.ac', '.acc', '.mp3', '.ogg', '.wav', '.flac', '.m4a', '.m4b', '.m4p', '.m4r', '.3gp']
+    extensions.each do |extension|
+      expect(subject.likely_match?('audiofile' + extension)).to be_falsey
+    end
+  end
+
+  it 'should parse a short sample, single channel audio, 16 kb/s, 44100 HZ' do
+    file_path = fixtures_dir + '/AAC/gs-16b-1c-44100hz.aac'
+    parsed = subject.call(File.open(file_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:aac)
+    expect(parsed.num_audio_channels).to eq(1)
+    expect(parsed.audio_sample_rate_hz).to eq(44100)
+    expect(parsed.content_type).to eq('audio/aac')
+  end
+
+  it 'should parse a short sample, two channel audio, 16 kb/s, 44100 HZ' do
+    file_path = fixtures_dir + '/AAC/gs-16b-2c-44100hz.aac'
+    parsed = subject.call(File.open(file_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:aac)
+    expect(parsed.num_audio_channels).to eq(2)
+    expect(parsed.audio_sample_rate_hz).to eq(44100)
+    expect(parsed.content_type).to eq('audio/aac')
+  end
+
+  it 'should parse a long sample, single channel audio, 16 kb/s, 44100 HZ' do
+    file_path = fixtures_dir + '/AAC/ff-16b-1c-44100hz.aac'
+    parsed = subject.call(File.open(file_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:aac)
+    expect(parsed.num_audio_channels).to eq(1)
+    expect(parsed.audio_sample_rate_hz).to eq(44100)
+    expect(parsed.content_type).to eq('audio/aac')
+  end
+
+  it 'should parse a long sample, two channel audio, 16 kb/s, 44100 HZ' do
+    file_path = fixtures_dir + '/AAC/ff-16b-2c-44100hz.aac'
+    parsed = subject.call(File.open(file_path, 'rb'))
+
+    expect(parsed).not_to be_nil
+
+    expect(parsed.nature).to eq(:audio)
+    expect(parsed.format).to eq(:aac)
+    expect(parsed.num_audio_channels).to eq(2)
+    expect(parsed.audio_sample_rate_hz).to eq(44100)
+    expect(parsed.content_type).to eq('audio/aac')
+  end
+
+  shared_examples 'invalid filetype' do |filetype, fixture_path|
+    it "should fail to parse #{filetype}" do
+      file_path = fixtures_dir + fixture_path
+      parsed = subject.call(File.open(file_path, 'rb'))
+      expect(parsed).to be_nil
+    end
+  end
+
+  include_examples 'invalid filetype', 'AIFF', '/AIFF/fixture.aiff'
+  include_examples 'invalid filetype', 'FLAC', '/FLAC/atc_fixture_vbr.flac'
+  include_examples 'invalid filetype', 'MP3', '/MP3/Cassy.mp3'
+  include_examples 'invalid filetype', 'MPG', '/MPG/video1.mpg'
+  include_examples 'invalid filetype', 'OGG', '/Ogg/hi.ogg'
+  include_examples 'invalid filetype', 'WAV', '/WAV/c_8kmp316.wav'
+end

data/spec/parsers/adts_header_info_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe FormatParser::AdtsHeaderInfo do
+  shared_examples 'parsed header' do |header_bits, expected_mpeg_version_description, expected_protection_absence, expected_profile_description, expected_mpeg4_sampling_frequency, expected_mpeg4_channel_config, expected_number_of_audio_channels, expected_originality, expected_home_usage, expected_frame_length, expected_aac_frames_per_adts_frame, expected_has_fixed_bitrate|
+    it "extracts correct values for header #{header_bits}" do
+      result = FormatParser::AdtsHeaderInfo.parse_adts_header(header_bits.split(''))
+      expect(result).not_to be_nil
+      expect(result.mpeg_version_description).to eq(expected_mpeg_version_description)
+      expect(result.protection_absence).to eq(expected_protection_absence)
+      expect(result.profile_description).to eq(expected_profile_description)
+      expect(result.mpeg4_sampling_frequency).to eq(expected_mpeg4_sampling_frequency)
+      expect(result.mpeg4_channel_config).to eq(expected_mpeg4_channel_config)
+      expect(result.number_of_audio_channels).to eq(expected_number_of_audio_channels)
+      expect(result.originality).to eq(expected_originality)
+      expect(result.home_usage).to eq(expected_home_usage)
+      expect(result.frame_length).to eq(expected_frame_length)
+      expect(result.aac_frames_per_adts_frame).to eq(expected_aac_frames_per_adts_frame)
+      expect(result.fixed_bitrate?).to eq(expected_has_fixed_bitrate)
+    end
+  end
+
+  shared_examples 'invalid header' do |failure_reason, header_bits|
+    it "fails on #{failure_reason} for header #{header_bits}" do
+      result = FormatParser::AdtsHeaderInfo.parse_adts_header(header_bits.split(''))
+      expect(result).to be_nil
+    end
+  end
+
+  # These headers have been validated here: https://www.p23.nl/projects/aac-header/
+  include_examples 'parsed header', '1111111111110001010111001000000000101110011111111111110000100001', 'MPEG-4', true, 'AAC_LC (Low Complexity)', 22050, 2, 2, false, false, 371, 1, false
+  include_examples 'parsed header', '111111111111000101010000010000000000011110011111111111001101111000000010', 'MPEG-4', true, 'AAC_LC (Low Complexity)', 44100, 1, 1, false, false, 60, 1, false
+
+  include_examples 'invalid header', 'invalid syncword', '1111110111110001010111001000000000101110011111111111110000100001'
+  include_examples 'invalid header', 'invalid layer value', '1111111111110011010111001000000000101110011111111111110000100001'
+  include_examples 'invalid header', 'invalid sampling frequency index 15', '1111111111110001011111001000000000101110011111111111110000100001'
+  include_examples 'invalid header', 'zero frame length', '1111111111110001010111001000000000000000011111111111110000100001'
+  include_examples 'invalid header', 'random header', '101000101011010101010101111010101010101011001010101010101111000000011101'
+end

data/spec/parsers/arw_parser_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe FormatParser::ARWParser do
+  shared_examples 'likely_match for file' do |filename_with_extension|
+    it "matches '#{filename_with_extension}'" do
+      expect(subject.likely_match?(filename_with_extension)).to be_truthy
+    end
+  end
+
+  shared_examples 'no likely_match for file' do |filename_with_extension|
+    it "does not match '#{filename_with_extension}'" do
+      expect(subject.likely_match?(filename_with_extension)).to be_falsey
+    end
+  end
+
+  describe 'likely_match' do
+    filenames = ['raw_file', 'another raw file', 'and.another', 'one-more']
+    valid_extensions = ['.arw', '.Arw', '.aRw', '.arW', '.ARw', '.ArW', '.aRW', '.ARW']
+    invalid_extensions = ['.tiff', '.cr2', '.new', '.jpeg']
+    filenames.each do |filename|
+      valid_extensions.each do |extension|
+        include_examples 'likely_match for file', filename + extension
+      end
+      invalid_extensions.each do |extension|
+        include_examples 'no likely_match for file', filename + extension
+      end
+    end
+  end
+
+  describe 'parses Sony ARW fixtures as arw format file' do
+    expected_parsed_dimensions = {
+      'RAW_SONY_A100.ARW' => {
+        width_px: 3872,
+        height_px: 2592,
+        display_width_px: 3872,
+        display_height_px: 2592,
+        orientation: :top_left
+      },
+      'RAW_SONY_A700.ARW' => {
+        width_px: 4288,
+        height_px: 2856,
+        display_width_px: 4288,
+        display_height_px: 2856,
+        orientation: :top_left
+      },
+      'RAW_SONY_A900.ARW' => {
+        width_px: 6080,
+        height_px: 4048,
+        display_width_px: 6080,
+        display_height_px: 4048,
+        orientation: :top_left
+      },
+      # rotated 90 degree image
+      'RAW_SONY_DSC-RX100M2.ARW' => {
+        width_px: 5472,
+        height_px: 3648,
+        display_width_px: 3648,
+        display_height_px: 5472,
+        orientation: :right_top,
+      },
+      'RAW_SONY_ILCE-7RM2.ARW' => {
+        width_px: 7952,
+        height_px: 5304,
+        display_width_px: 7952,
+        display_height_px: 5304,
+        orientation: :top_left,
+      },
+      'RAW_SONY_NEX7.ARW' => {
+        width_px: 6000,
+        height_px: 4000,
+        display_width_px: 6000,
+        display_height_px: 4000,
+        orientation: :top_left,
+      },
+      'RAW_SONY_SLTA55V.ARW' => {
+        width_px: 4928,
+        height_px: 3280,
+        display_width_px: 4928,
+        display_height_px: 3280,
+        orientation: :top_left,
+      },
+    }
+
+    Dir.glob(fixtures_dir + '/ARW/*.ARW').each do |arw_path|
+      it "is able to parse #{File.basename(arw_path)}" do
+        expected_dimension = expected_parsed_dimensions[File.basename(arw_path)]
+        # error if a new .arw test file is added without specifying the expected dimensions
+        expect(expected_dimension).not_to be_nil
+
+        parsed = subject.call(File.open(arw_path, 'rb'))
+        expect(parsed).not_to be_nil
+        expect(parsed.nature).to eq(:image)
+        expect(parsed.format).to eq(:arw)
+        expect(parsed.intrinsics[:exif]).not_to be_nil
+        expect(parsed.content_type).to eq('image/x-sony-arw')
+
+        expect(parsed.width_px).to eq(expected_dimension[:width_px])
+        expect(parsed.height_px).to eq(expected_dimension[:height_px])
+        expect(parsed.display_width_px).to eq(expected_dimension[:display_width_px])
+        expect(parsed.display_height_px).to eq(expected_dimension[:display_height_px])
+        expect(parsed.orientation).to eq(expected_dimension[:orientation])
+      end
+    end
+
+    shared_examples 'invalid filetype' do |filetype, fixture_path|
+      it "should fail to parse #{filetype}" do
+        file_path = fixtures_dir + fixture_path
+        parsed = subject.call(File.open(file_path, 'rb'))
+        expect(parsed).to be_nil
+      end
+    end
+
+    include_examples 'invalid filetype', 'NEF', '/NEF/RAW_NIKON_1S2.NEF'
+    include_examples 'invalid filetype', 'TIFF', '/TIFF/Shinbutsureijoushuincho.tiff'
+    include_examples 'invalid filetype', 'JPG', '/JPEG/orient_6.jpg'
+    include_examples 'invalid filetype', 'PNG', '/PNG/cat.png'
+    include_examples 'invalid filetype', 'CR2', '/CR2/RAW_CANON_1DM2.CR2'
+  end
+end

data/spec/parsers/tiff_parser_spec.rb

@@ -47,21 +47,6 @@ describe FormatParser::TIFFParser do
     expect(parsed.intrinsics[:exif]).not_to be_nil
   end
 
-  it 'parses Sony ARW fixture as arw format file' do
-    arw_path = fixtures_dir + '/ARW/RAW_SONY_ILCE-7RM2.ARW'
-
-    parsed = subject.call(File.open(arw_path, 'rb'))
-
-    expect(parsed).not_to be_nil
-    expect(parsed.nature).to eq(:image)
-    expect(parsed.format).to eq(:arw)
-
-    expect(parsed.width_px).to eq(7952)
-    expect(parsed.height_px).to eq(5304)
-    expect(parsed.intrinsics[:exif]).not_to be_nil
-    expect(parsed.content_type).to eq('image/x-sony-arw')
-  end
-
   describe 'correctly extracts dimensions from various TIFF flavors of the same file' do
     Dir.glob(fixtures_dir + '/TIFF/IMG_9266*.tif').each do |tiff_path|
       it "is able to parse #{File.basename(tiff_path)}" do
@@ -100,4 +85,13 @@ describe FormatParser::TIFFParser do
       end
     end
   end
+
+  describe 'bails out on ARW files, such as' do
+    Dir.glob(fixtures_dir + '/ARW/*.ARW').each do |arw_path|
+      it "skips #{File.basename(arw_path)}" do
+        parsed = subject.call(File.open(arw_path, 'rb'))
+        expect(parsed).to be_nil
+      end
+    end
+  end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: format_parser
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Noah Berman
 - Julik Tarkhanov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-23 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ks
@@ -229,7 +229,10 @@ files:
 - lib/image.rb
 - lib/io_constraint.rb
 - lib/io_utils.rb
+- lib/parsers/aac_parser.rb
+- lib/parsers/aac_parser/adts_header_info.rb
 - lib/parsers/aiff_parser.rb
+- lib/parsers/arw_parser.rb
 - lib/parsers/bmp_parser.rb
 - lib/parsers/cr2_parser.rb
 - lib/parsers/dpx_parser.rb
@@ -273,7 +276,10 @@ files:
 - spec/hash_utils_spec.rb
 - spec/integration/active_storage/rails_app.rb
 - spec/io_utils_spec.rb
+- spec/parsers/aac_parser_spec.rb
+- spec/parsers/adts_header_info_spec.rb
 - spec/parsers/aiff_parser_spec.rb
+- spec/parsers/arw_parser_spec.rb
 - spec/parsers/bmp_parser_spec.rb
 - spec/parsers/cr2_parser_spec.rb
 - spec/parsers/dpx_parser_spec.rb
@@ -306,7 +312,7 @@ licenses:
 - MIT (Hippocratic)
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -321,8 +327,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: A library for efficient parsing of file metadata
 test_files: []