fileshunter 0.1.0.20130725

data/lib/fileshunter/Decoders/JPEG.rb

@@ -0,0 +1,247 @@
+module FilesHunter
+
+  module Decoders
+
+    # JPEG decoder has to be among the last ones to be decoded, as a truncated JPEG followed by other files can consume all files in its truncated data.
+    # JPEG files can contain TIFF files
+
+    class JPEG < BeginPatternDecoder
+
+      MARKER_PREFIX = "\xFF".force_encoding(Encoding::ASCII_8BIT)
+      END_MARKER = "\xD9".force_encoding(Encoding::ASCII_8BIT)
+      MARKERS_WITHOUT_PAYLOAD = [
+        "\xD8".force_encoding(Encoding::ASCII_8BIT),
+        "\xD9".force_encoding(Encoding::ASCII_8BIT)
+      ]
+      MARKER_WITH_ENTROPY_DATA = "\xDA".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_APP0 = "\xE0".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_APP1 = "\xE1".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_SOF0 = "\xC0".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_SOF3 = "\xC3".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_DHT = "\xC4".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_SOS = "\xDA".force_encoding(Encoding::ASCII_8BIT)
+      MARKER_DQT = "\xDB".force_encoding(Encoding::ASCII_8BIT)
+      MARKERS_IGNORED_IN_ENTROPY_DATA = [
+        "\x00".force_encoding(Encoding::ASCII_8BIT),
+        "\xD0".force_encoding(Encoding::ASCII_8BIT),
+        "\xD1".force_encoding(Encoding::ASCII_8BIT),
+        "\xD2".force_encoding(Encoding::ASCII_8BIT),
+        "\xD3".force_encoding(Encoding::ASCII_8BIT),
+        "\xD4".force_encoding(Encoding::ASCII_8BIT),
+        "\xD5".force_encoding(Encoding::ASCII_8BIT),
+        "\xD6".force_encoding(Encoding::ASCII_8BIT),
+        "\xD7".force_encoding(Encoding::ASCII_8BIT),
+        "\xFF".force_encoding(Encoding::ASCII_8BIT)
+      ]
+      MARKERS_IGNORED_IN_ENTROPY_DATA_REGEXP = Regexp.new("#{MARKER_PREFIX}[^#{MARKERS_IGNORED_IN_ENTROPY_DATA.join}]", nil, 'n')
+
+      JFIF_HEADER = "JFIF\x00".force_encoding(Encoding::ASCII_8BIT)
+      JFXX_HEADER = "JFXX\x00".force_encoding(Encoding::ASCII_8BIT)
+      EXIF_HEADER = "Exif\x00\x00".force_encoding(Encoding::ASCII_8BIT)
+
+      VALID_EXTENSION_CODES = [ 16, 17, 19 ]
+
+      def get_begin_pattern
+        return "\xFF\xD8\xFF".force_encoding(Encoding::ASCII_8BIT)
+      end
+
+      def decode(offset)
+        ending_offset = nil
+
+        cursor = offset + 2
+        nbr_segments = 0
+        quantisation_tables_id = []
+        huffman_ac_tables_id = []
+        huffman_dc_tables_id = []
+        found_sos = false
+        found_sof = false
+        while (ending_offset == nil)
+          # Here cursor is at the beginning of the next marker
+          # Read the 2 next bytes: they should be FF ??
+          log_debug "@#{cursor} Decoding next offset: #{@data[cursor..cursor+1].inspect}"
+          invalid_data("@#{cursor} - Did not get a valid marker definition: #{@data[cursor..cursor+1].inspect}") if (@data[cursor] != MARKER_PREFIX)
+          c_1 = @data[cursor+1]
+          invalid_data("@#{cursor} - Invalid marker: #{c_1.ord}") if (c_1.ord < 192)
+          # Does this marker have a payload?
+          if (MARKERS_WITHOUT_PAYLOAD.include?(c_1))
+            # No payload
+            log_debug "=== No payload"
+            # Get to the next bytes
+            cursor += 2
+            # Check if we arrived at the end
+            ending_offset = cursor if (c_1 == END_MARKER)
+          else
+            # There is a payload
+            # Read its length
+            size = BinData::Uint16be.read(@data[cursor+2..cursor+3])
+            log_debug "=== Payload of size #{size}"
+            case c_1
+            when MARKER_APP0
+              # Application specific data
+              # Usually used for JFIF
+              case @data[cursor+4..cursor+8]
+              when JFIF_HEADER
+                invalid_data("@#{cursor} - Invalid size for JFIF marker: #{size}") if (size < 16)
+                version_major = @data[cursor+9].ord
+                version_minor = @data[cursor+10].ord
+                units = @data[cursor+11].ord
+                invalid_data("@#{cursor} - Invalid units: #{units}") if (units > 2)
+                width = BinData::Uint16be.read(@data[cursor+12..cursor+13])
+                invalid_data("@#{cursor} - Invalid width: #{width}") if (width == 0)
+                height = BinData::Uint16be.read(@data[cursor+14..cursor+15])
+                invalid_data("@#{cursor} - Invalid height: #{height}") if (height == 0)
+                jfif_metadata = {
+                  :version_major => version_major,
+                  :version_minor => version_minor,
+                  :units => units,
+                  :width => width,
+                  :height => height
+                }
+                if (size > 16)
+                  width_thumb = BinData::Uint16be.read(@data[cursor+16..cursor+17])
+                  height_thumb = BinData::Uint16be.read(@data[cursor+18..cursor+19])
+                  jfif_metadata.merge!(
+                    :width_thumb => width_thumb,
+                    :height_thumb => height_thumb
+                  )
+                end
+                metadata( :jfif_metadata => jfif_metadata )
+              when JFXX_HEADER
+                extension_code = @data[cursor+9].ord
+                invalid_data("@#{cursor} - Invalid extension code: #{extension_code}") if (!VALID_EXTENSION_CODES.include?(extension_code))
+                metadata( :jfxx_metadata => { :extension_code => extension_code } )
+              end
+            when MARKER_APP1
+              # Application specific data
+              # Usually used for Exif
+              case @data[cursor+4..cursor+9]
+              when EXIF_HEADER
+                # Read a TIFF file from cursor+10
+                require 'fileshunter/Decoders/TIFF'
+                invalid_data("@#{cursor} - Invalid TIFF header") if (@data[cursor+10..cursor+13].index(FilesHunter::Decoders::TIFF::BEGIN_PATTERN_TIFF) != 0)
+                tiff_decoder = FilesHunter::Decoders::TIFF.new
+                tiff_decoder.setup(FilesHunter::get_segments_analyzer, @data, cursor+10, cursor+2+size)
+                tiff_decoder.accept_no_image_data
+                begin
+                  tiff_decoder.find_segments
+                rescue InvalidDataError, TruncatedDataError, AccessAfterDataError
+                  # Invalid TIFF data
+                  invalid_data("@#{cursor} - Invalid TIFF data: #{$!}")
+                end
+                segments = tiff_decoder.segments_found
+                invalid_data("@#{cursor} - No valid TIFF segment found for Exif") if segments.empty?
+                invalid_data("@#{cursor} - Not a valid TIFF segment found for Exif. Found #{segments[0].extensions.inspect}.") if (!segments[0].extensions.include?(:tif))
+                invalid_data("@#{cursor} - Truncated TIFF segment found for Exif.") if (segments[0].truncated)
+                invalid_data("@#{cursor} - TIFF segment (@#{segments[0].begin_offset}) not found at the beginning of Exif (#{cursor+10}).") if (segments[0].begin_offset != cursor+10)
+                #invalid_data("@#{cursor} - TIFF segment not ending (#{segments[0].end_offset}) at the end of Exif (#{cursor+2+size}).") if (segments[0].end_offset != cursor+2+size)
+                metadata( :exif_metadata => segments[0].metadata )
+                found_relevant_data([:jpg, :thm])
+              end
+            when MARKER_SOF0..MARKER_SOF3
+              # SOF: Start of Frame
+              invalid_data("@#{cursor} - Found several SOF markers") if found_sof
+              invalid_data("@#{cursor} - Found a SOF marker after the SOS marker") if found_sos
+              found_sof = true
+              sample_precision = @data[cursor+4].ord
+              invalid_data("@#{cursor} - Invalid sample precision: #{sample_precision}") if ((sample_precision != 8) and (sample_precision != 12))
+              image_height = BinData::Uint16be.read(@data[cursor+5..cursor+6])
+              image_width = BinData::Uint16be.read(@data[cursor+7..cursor+8])
+              metadata(
+                :image_height => image_height,
+                :image_width => image_width
+              )
+              nbr_components = @data[cursor+9].ord
+              invalid_data("@#{cursor} - Invalid number of components: #{nbr_components}") if (nbr_components == 0)
+              # Check that quantisation tables have been defined
+              nbr_components.times do |idx_component|
+                sampling = @data[cursor+11+idx_component*3].ord
+                horizontal_sampling = ((sampling & 0b11110000) >> 4)
+                vertical_sampling = (sampling & 0b00001111)
+                invalid_data("@#{cursor} - Invalid horizontal sampling: #{horizontal_sampling}") if (horizontal_sampling == 0)
+                invalid_data("@#{cursor} - Invalid vertical sampling: #{vertical_sampling}") if (vertical_sampling == 0)
+                dqt_id = @data[cursor+12+idx_component*3].ord
+                invalid_data("@#{cursor} - Missing quantisation table ID #{dqt_id}") if (!quantisation_tables_id.include?(dqt_id))
+              end
+            when MARKER_DHT
+              # DHT: Define Huffman tables
+              end_cursor = cursor + 2 + size
+              dht_cursor = cursor + 4
+              while (dht_cursor < end_cursor)
+                header_byte = @data[dht_cursor].ord
+                huffman_type = ((header_byte & 0b11110000) >> 4)
+                invalid_data("@#{cursor} - Unknown Huffman table type: #{huffman_type}") if (huffman_type > 1)
+                if (huffman_type == 0)
+                  huffman_dc_table_id = (header_byte & 0b00001111)
+                  invalid_data("@#{cursor} - Huffman DC table id #{huffman_dc_table_id} already defined.") if (huffman_dc_tables_id.include?(huffman_dc_table_id))
+                  huffman_dc_tables_id << huffman_dc_table_id
+                  log_debug "@#{cursor} - Found Huffman DC table: #{huffman_dc_table_id}"
+                else
+                  huffman_ac_table_id = (header_byte & 0b00001111)
+                  invalid_data("@#{cursor} - Huffman AC table id #{huffman_ac_table_id} already defined.") if (huffman_ac_tables_id.include?(huffman_ac_table_id))
+                  huffman_ac_tables_id << huffman_ac_table_id
+                  log_debug "@#{cursor} - Found Huffman AC table: #{huffman_ac_table_id}"
+                end
+                nbr_elements = 0
+                @data[dht_cursor+1..dht_cursor+16].bytes.each do |nbr_element_for_depth|
+                  nbr_elements += nbr_element_for_depth
+                end
+                dht_cursor += 17 + nbr_elements
+                invalid_data("@#{dqt_cursor} - End of Huffman table was supposed to be @#{end_cursor}.") if (dht_cursor > end_cursor)
+              end
+            when MARKER_SOS
+              # SOS: Start of Scan
+              invalid_data("@#{cursor} - SOS marker begins whereas no Huffman DC table has been defined.") if (huffman_dc_tables_id.empty?)
+              invalid_data("@#{cursor} - SOS marker begins whereas no Huffman AC table has been defined.") if (huffman_ac_tables_id.empty?)
+              invalid_data("@#{cursor} - SOS marker begins whereas no quantisation table has been defined.") if (quantisation_tables_id.empty?)
+              invalid_data("@#{cursor} - SOS marker begins whereas no SOF marker has been encountered.") if (!found_sof)
+              found_sos = true
+              nbr_components = @data[cursor+4].ord
+              invalid_data("@#{cursor} - Invalid number of components: #{nbr_components}") if (nbr_components == 0)
+              nbr_components.times do |idx_component|
+                huffman_table_ids = @data[cursor+6+2*idx_component].ord
+                huffman_dc_table_id = ((huffman_table_ids & 0b11110000) >> 4)
+                huffman_ac_table_id = (huffman_table_ids & 0b00001111)
+                invalid_data("@#{cursor} - Unknown DC Huffman table: #{huffman_dc_table_id}") if (!huffman_dc_tables_id.include?(huffman_dc_table_id))
+                invalid_data("@#{cursor} - Unknown AC Huffman table: #{huffman_ac_table_id}") if (!huffman_ac_tables_id.include?(huffman_ac_table_id))
+              end
+            when MARKER_DQT
+              # DQT: Define quantisation tables
+              end_cursor = cursor + 2 + size
+              dqt_cursor = cursor + 4
+              while (dqt_cursor < end_cursor)
+                header_byte = @data[dqt_cursor].ord
+                precision = ((header_byte & 0b11110000) >> 4)
+                quantisation_table_id = (header_byte & 0b00001111)
+                invalid_data("@#{cursor} - Quantisation table id #{quantisation_table_id} already defined.") if (quantisation_tables_id.include?(quantisation_table_id))
+                quantisation_tables_id << quantisation_table_id
+                log_debug "@#{cursor} - Found quantisation table: #{quantisation_table_id}"
+                dqt_cursor += 1 + 64*((precision == 0) ? 1 : 2)
+                invalid_data("@#{dqt_cursor} - End of quantisation table was supposed to be @#{end_cursor}.") if (dqt_cursor > end_cursor)
+              end
+            end
+            # Does it have entropy data?
+            if (c_1 == MARKER_WITH_ENTROPY_DATA)
+              # There is entropy data
+              found_relevant_data([:jpg, :thm])
+              # Find the next marker that is FF xx, with xx being different than 00, D0..D7 and FF
+              cursor = @data.index(MARKERS_IGNORED_IN_ENTROPY_DATA_REGEXP, cursor + 2 + size, 2)
+              log_debug "=== Entropy data gets to cursor #{cursor.inspect}"
+              truncated_data("@#{cursor} - Truncated entropy data segment", @end_offset) if (cursor == nil)
+            else
+              # No entropy data: just get to the next segment
+              cursor += 2 + size
+            end
+          end
+          nbr_segments += 1
+          progress(cursor)
+        end
+        metadata( :nbr_segments => nbr_segments )
+
+        return ending_offset
+      end
+
+    end
+
+  end
+
+end

data/lib/fileshunter/Decoders/M2V.rb

@@ -0,0 +1,30 @@
+module FilesHunter
+
+  module Decoders
+
+    class M2V < BeginPatternDecoder
+
+      BEGIN_PATTERN_M2V = "\x00\x00\x01\xBA\x44\x00\x04\x00\x14\x01".force_encoding(Encoding::ASCII_8BIT)
+      END_PATTERN_M2V = "\x00\x00\x01\xB9".force_encoding(Encoding::ASCII_8BIT)
+
+      def get_begin_pattern
+        return BEGIN_PATTERN_M2V, { :offset_inc => 10 }
+      end
+
+      def decode(offset)
+        ending_offset = nil
+
+        found_relevant_data(:m2v)
+        end_pattern_offset = @data.index(END_PATTERN_M2V, offset + 10)
+        log_debug "=== @#{offset} - Found ending offset: #{end_pattern_offset.inspect}"
+        truncated_data if ((end_pattern_offset == nil) or (end_pattern_offset + 4 > @end_offset))
+        ending_offset = end_pattern_offset + 4
+
+        return ending_offset
+      end
+
+    end
+
+  end
+
+end

data/lib/fileshunter/Decoders/MP3.rb

@@ -0,0 +1,341 @@
+module FilesHunter
+
+  module Decoders
+
+    # MP3 files can contain JPEG files
+
+    class MP3 < BeginPatternDecoder
+
+      BEGIN_PATTERN_ID3V1 = 'TAG'.force_encoding(Encoding::ASCII_8BIT)
+      BEGIN_PATTERN_ID3V1E = 'TAG+'.force_encoding(Encoding::ASCII_8BIT)
+      BEGIN_PATTERN_ID3V2 = 'ID3'.force_encoding(Encoding::ASCII_8BIT)
+      BEGIN_PATTERN_APEV2 = 'APETAGEX'.force_encoding(Encoding::ASCII_8BIT)
+      BEGIN_PATTERN_MP3 = Regexp.new("(\xFF[\xE2-\xFF][\x00-\xEF]|#{BEGIN_PATTERN_ID3V2}|#{BEGIN_PATTERN_APEV2})", nil, 'n')
+
+      BITRATE_INDEX = [
+        [ 32,  32,  32,  32,  8 ],
+        [ 64,  48,  40,  48,  16 ],
+        [ 96,  56,  48,  56,  24 ],
+        [ 128, 64,  56,  64,  32 ],
+        [ 160, 80,  64,  80,  40 ],
+        [ 192, 96,  80,  96,  48 ],
+        [ 224, 112, 96,  112, 56 ],
+        [ 256, 128, 112, 128, 64 ],
+        [ 288, 160, 128, 144, 80 ],
+        [ 320, 192, 160, 160, 96 ],
+        [ 352, 224, 192, 176, 112 ],
+        [ 384, 256, 224, 192, 128 ],
+        [ 416, 320, 256, 224, 144 ],
+        [ 448, 384, 320, 256, 160 ]
+      ]
+      SAMPLE_RATE_INDEX = [
+        [ 44100, 22050, 11025 ],
+        [ 48000, 24000, 12000 ],
+        [ 32000, 16000, 8000 ]
+      ]
+
+      MIN_ACCEPTABLE_TIME_MS = 1000
+
+      MAX_ID3V2_FRAME_SIZE = 256
+
+      APE_ITEM_KEY_TERMINATOR = "\x00".force_encoding(Encoding::ASCII_8BIT)
+
+      ID3V2_PADDING_CHAR = "\x00".force_encoding(Encoding::ASCII_8BIT)
+
+      TRAILING_00_REGEXP = Regexp.new("\x00*$".force_encoding(Encoding::ASCII_8BIT), nil, 'n')
+
+      def get_begin_pattern
+        return BEGIN_PATTERN_MP3, { :max_regexp_size => 8 }
+      end
+
+      def check_begin_pattern(begin_pattern_offset, pattern_index)
+        if (@data[begin_pattern_offset] == "\xFF")
+          header_bytes = @data[begin_pattern_offset+1..begin_pattern_offset+3].bytes.to_a
+          return (((header_bytes[0] & 24) != 16) and
+                  ((header_bytes[0] & 6) != 0) and
+                  ((header_bytes[1] & 12) != 12) and
+                  ((header_bytes[2] & 3) != 2))
+        else
+          return true
+        end
+      end
+
+      def decode(offset)
+        ending_offset = nil
+
+        cursor = offset
+        nbr_ms = 0
+        valid = false
+        while (ending_offset == nil)
+          #log_debug "=== @#{cursor} - Reading what's here"
+          c_0_2 = @data[cursor..cursor+2]
+          if (c_0_2 == BEGIN_PATTERN_ID3V1)
+            if (@data[cursor..cursor+3] == BEGIN_PATTERN_ID3V1E)
+              log_debug "=== @#{cursor} - Found ID3v1 extended tag"
+              metadata( :id3v1e_metadata => {
+                :title => read_ascii(cursor+4, cursor+63),
+                :artist => read_ascii(cursor+64, cursor+123),
+                :album => read_ascii(cursor+124, cursor+183),
+                :speed => @data[cursor+184].ord,
+                :genre => read_ascii(cursor+185, cursor+214),
+                :start_time => read_ascii(cursor+215, cursor+220),
+                :end_time => read_ascii(cursor+221, cursor+226)
+              } )
+              cursor += 227
+            else
+              # Just met an ID3v1 tag: skip 128 bytes
+              log_debug "=== @#{cursor} - Found ID3v1 tag"
+              metadata( :id3v1_metadata => {
+                :title => read_ascii(cursor+3, cursor+32),
+                :artist => read_ascii(cursor+33, cursor+62),
+                :album => read_ascii(cursor+63, cursor+92),
+                :year => read_ascii(cursor+93, cursor+96),
+                :comments => read_ascii(cursor+97, cursor+126),
+                :genre => @data[cursor+127].ord
+              } )
+              cursor += 128
+              # Current MP3 is finished: id3v1 is forcefully at the end
+              ending_offset = cursor
+            end
+          elsif (c_0_2 == BEGIN_PATTERN_ID3V2)
+            # Just met an ID3v2 tag
+            log_debug "=== @#{cursor} - Found ID3v2 tag"
+            invalid_data("@#{cursor} - Invalid ID3v2 header") if ((@data[cursor+3].ord == 255) or (@data[cursor+4].ord == 255))
+            # Compute the tag's size
+            size = 10 # Header
+            @data[cursor+6..cursor+9].bytes.each_with_index do |byte, idx|
+              invalid_data("@#{cursor} - Invalid ID3v2 header in size specification (#{idx})") if (byte >= 128)
+              size += (byte << ((8*(3-idx))-3+idx))
+            end
+            # Is there a footer?
+            size += 10 if ((@data[cursor+5].ord & 16) == 16)
+            cursor_end = cursor + size
+            cursor += 10
+            # Check if following is an extended header
+            padding_size = 0
+            extended_header_size = BinData::Uint32be.read(@data[cursor..cursor+3])
+            if ((extended_header_size == 6) or
+                (extended_header_size == 10))
+              # There is an extended header
+              extended_header_flags = BinData::Uint16be.read(@data[cursor+4..cursor+5])
+              invalid_data("@#{cursor} - Invalid extended header flags.") if ((extended_header_flags & 0b01111111_11111111) != 0)
+              has_crc = ((extended_header_flags & 0b10000000_00000000) != 0)
+              invalid_data("@#{cursor} - Extended header declared size and CRC flag do not match.") if (((extended_header_size == 10) and (!has_crc)) or ((extended_header_size == 6) and (has_crc)))
+              padding_size = BinData::Uint32be.read(@data[cursor+6..cursor+9])
+              cursor += 10
+              cursor += 4 if has_crc
+            end
+            # Read all frames
+            id3v2_metadata = {}
+            while ((cursor < cursor_end) and
+                   (@data[cursor] != ID3V2_PADDING_CHAR))
+              # We are on a frame
+              frame_id = @data[cursor..cursor+3]
+              frame_size = BinData::Uint32be.read(@data[cursor+4..cursor+7])
+              frame_flags = BinData::Uint16be.read(@data[cursor+8..cursor+9])
+              invalid_data("@#{cursor} - Invalid ID3v2 frame flags: #{frame_flags}.") if ((frame_flags & 0b00011111_00011111) != 0)
+              cursor += 10
+              id3v2_metadata[frame_id] = read_ascii(cursor, cursor+((frame_size > MAX_ID3V2_FRAME_SIZE) ? MAX_ID3V2_FRAME_SIZE : frame_size)-1)
+              cursor += frame_size
+            end
+            metadata( :id3v2_metadata => id3v2_metadata )
+            # Get directly to the previously computed cursor to skip padding
+            log_debug("@#{cursor} - Padding size (#{padding_size}) is different from what is being read (#{cursor_end-cursor}).") if (padding_size != cursor_end-cursor)
+            cursor = cursor_end
+          elsif (@data[cursor..cursor+7] == BEGIN_PATTERN_APEV2)
+            log_debug "=== @#{cursor} - Found APEv2 tag"
+            info = decode_ape_tag_header(cursor)
+            invalid_data("@#{cursor} - APE tag header indicates no header whereas we have one.") if (!info[:has_header])
+            invalid_data("@#{cursor} - APE tag header indicates it is a footer whereas we are on the header.") if (info[:on_footer])
+            cursor += 32
+            cursor_end_tag = cursor + info[:tag_size]
+            ape_metadata = {}
+            info[:nbr_items].times do |idx_item|
+              item_key, item_value, cursor = decode_ape_tag_item(cursor)
+              ape_metadata[item_key] = item_value
+            end
+            invalid_data("@#{cursor} - APE tag header is inconsistent. We should be at cursor #{cursor_end_tag-(info[:has_footer] ? 32 : 0)}") if (cursor != cursor_end_tag-(info[:has_footer] ? 32 : 0))
+            metadata( :apev2_metadata => ape_metadata )
+            if (info[:has_footer])
+              # There is a footer
+              invalid_data("@#{cursor} - Invalid APE tag footer magic.") if (@data[cursor..cursor+7] != BEGIN_PATTERN_APEV2)
+              footer_info = decode_ape_tag_header(cursor)
+              invalid_data("@#{cursor} - APEv2 tag footer indicates no footer whereas we have one.") if (!footer_info[:has_footer])
+              invalid_data("@#{cursor} - APEv2 tag footer indicates it is a header whereas we are on the footer.") if (!footer_info[:on_footer])
+              cursor += 32
+            end
+          else
+            # We might be on a APEv1 tag, or real MP3 data, or at the end of our file.
+            # APEv1 tag occurs only after the last MP3 frame, and before any ID3v1 tag.
+            # APEv1 tag has no header, but a footer.
+            ape_tag_decoded = false
+            if (nbr_ms != 0)
+              # Might be good to check for APEv1 tag
+              cursor_begin = cursor
+              begin
+                ape_metadata = {}
+                nbr_items = 0
+                while (@data[cursor..cursor+7] != BEGIN_PATTERN_APEV2)
+                  item_key, item_value, cursor = decode_ape_tag_item(cursor)
+                  ape_metadata[item_key] = item_value
+                  nbr_items += 1
+                  log_debug "=== @#{cursor} - Decoded APEv1 tag item: #{item_key.inspect} => #{item_value[0..31].inspect}"
+                end
+                # Here we are on an APE Tag footer
+                footer_info = decode_ape_tag_header(cursor)
+                invalid_data("@#{cursor} - APEv1 tag footer indicates no footer whereas we have one.") if (!footer_info[:has_footer])
+                invalid_data("@#{cursor} - APEv1 tag footer indicates it is a header whereas we are on the footer.") if (!footer_info[:on_footer])
+                invalid_data("@#{cursor} - APEv1 tag footer indicates #{footer_info[:nbr_items]} tag items, whereas we read #{nbr_items}") if (footer_info[:nbr_items] != nbr_items)
+                log_debug "=== @#{cursor} - Found APEv1 tag"
+                cursor += 32
+                ape_tag_decoded = true
+                metadata( :apev1_metadata => ape_metadata )
+              rescue InvalidDataError, TruncatedDataError, AccessAfterDataError
+                # Maybe it is not an APEv1 tag.
+                # Scratch it and consider a normal MP3 frame.
+                #log_debug("=== @#{cursor_begin} - Failed to decode as APEv1 tag: #{$!}")
+                cursor = cursor_begin
+                ape_tag_decoded = false
+              end
+            end
+            if (!ape_tag_decoded)
+              # Real MP3 data or end of file
+              info = nil
+              begin
+                info = decode_mp3_frame_header(cursor)
+              rescue InvalidDataError
+                if (nbr_ms >= MIN_ACCEPTABLE_TIME_MS)
+                  # Consider the file was finished
+                  #log_debug "=== @#{cursor} - Garbage data found. Should be end of file."
+                  ending_offset = cursor
+                else
+                  # Problem
+                  raise
+                end
+              end
+              if (ending_offset == nil)
+                #log_debug "=== @#{cursor} - Found MP3 data"
+                # Go see after
+                cursor += info[:size]
+                # Consider we have valid data only if we have enough milliseconds
+                nbr_ms += info[:nbr_ms]
+                if ((!valid) and (nbr_ms >= MIN_ACCEPTABLE_TIME_MS))
+                  valid = true
+                  found_relevant_data(:mp3)
+                end
+                metadata( :nbr_ms => nbr_ms )
+              end
+            end
+          end
+          if ((nbr_ms >= MIN_ACCEPTABLE_TIME_MS) and
+              (cursor == @end_offset))
+            ending_offset = cursor
+          end
+          progress(cursor)
+        end
+
+        return ending_offset
+      end
+
+      private
+
+      # Decode an MP3 frame header
+      #
+      # Parameters::
+      # * *cursor* (_Fixnum_): The cursor
+      # Result::
+      # * <em>map<Symbol,Object></em>: Corresponding header info
+      def decode_mp3_frame_header(cursor)
+        info = {}
+        # Check the header's values
+        header_bytes = @data[cursor..cursor+3].bytes.to_a
+        invalid_data("@#{cursor} - Invalid MP3 header") if ((header_bytes[0] != 255) or
+                                                            ((header_bytes[1] & 224) != 224) or
+                                                            ((header_bytes[1] & 24) == 16) or
+                                                            ((header_bytes[1] & 6) == 0) or
+                                                            ((header_bytes[2] & 240) == 240) or
+                                                            ((header_bytes[2] & 12) == 12) or
+                                                            ((header_bytes[3] & 3) == 2))
+        invalid_data("@#{cursor} - Invalid MP3 header: can't compute size of free bitrates") if ((header_bytes[2] & 240) == 0)
+        # Read header values to compute the size
+        version = nil
+        case ((header_bytes[1] & 24) >> 3)
+        when 0
+          version = 3
+        when 2
+          version = 2
+        when 3
+          version = 1
+        else
+          invalid_data("@#{cursor} - Unknown version in header: #{((header_bytes[1] & 24) >> 3)}")
+        end
+        layer = 4 - ((header_bytes[1] & 6) >> 1)
+        bit_rate = BITRATE_INDEX[((header_bytes[2] & 240) >> 4)-1][(version == 1) ? layer - 1 : ((layer == 1) ? 3 : 4)] * 1000
+        sample_rate = SAMPLE_RATE_INDEX[(header_bytes[2] & 12) >> 2][version - 1]
+        padding = ((header_bytes[2] & 2) >> 1)
+        # Compute the size
+        info[:size] = (layer == 1) ? ((12 * bit_rate) / sample_rate + padding) * 4 : (144 * bit_rate) / sample_rate + padding
+        info[:nbr_ms] = ((layer == 1) ? 384000 : 1152000) / sample_rate
+        #log_debug "=== @#{cursor} - Read MP3 frame: Version=#{version} Layer=#{layer} BitRate=#{bit_rate} SampleRate=#{sample_rate} Padding=#{padding} FrameLength=#{info[:size]} Milliseconds=#{info[:nbr_ms]}"
+        return info
+      end
+
+      # Decode an APE tag header
+      #
+      # Parameters::
+      # * *cursor* (_Fixnum_): Current cursor
+      # Result::
+      # * <em>map<Symbol,Object></em>: The APE tag info
+      def decode_ape_tag_header(cursor)
+        info = {}
+        #ape_version = BinData::Uint32le.read(@data[cursor+8..cursor+11])
+        info[:tag_size] = BinData::Uint32le.read(@data[cursor+12..cursor+15])
+        info[:nbr_items] = BinData::Uint32le.read(@data[cursor+16..cursor+19])
+        flags = BinData::Uint32le.read(@data[cursor+20..cursor+23])
+        info[:has_header] = ((flags & 0b10000000_00000000_00000000_00000000) != 0)
+        info[:has_footer] = ((flags & 0b01000000_00000000_00000000_00000000) == 0)
+        info[:on_footer] = ((flags & 0b00100000_00000000_00000000_00000000) == 0)
+        invalid_data("@#{cursor} - Invalid APE tag flags: #{flags}") if ((flags & 0b00011111_11111111_11111111_11111000) != 0)
+        reserved = BinData::Uint64le.read(@data[cursor+24..cursor+31])
+        invalid_data("@#{cursor} - Invalid reserved bytes in APE Tag header: #{reserved} should be 0.") if (reserved != 0)
+        return info
+      end
+
+      # Decode an APE tag item
+      #
+      # Parameters::
+      # * *cursor* (_Fixnum_): The cursor
+      # Result::
+      # * _String_: Item key
+      # * _String_: Item value
+      # * _Fixnum_: New cursor
+      def decode_ape_tag_item(cursor)
+        value_size = BinData::Uint32le.read(@data[cursor..cursor+3])
+        flags = BinData::Uint32le.read(@data[cursor+4..cursor+7])
+        invalid_data("@#{cursor} - Invalid APE tag flags: #{flags}") if ((flags & 0b00011111_11111111_11111111_11111000) != 0)
+        cursor_terminator = @data.index(APE_ITEM_KEY_TERMINATOR, cursor+8)
+        invalid_data("@#{cursor} - Could not find the end of APE tag item key.") if (cursor_terminator == nil)
+        invalid_data("@#{cursor} - Empty APE tag item key.") if (cursor_terminator == cursor+8)
+        item_key = @data[cursor+8..cursor_terminator-1]
+        cursor = cursor_terminator + 1
+        item_value = @data[cursor..cursor+value_size-1]
+        cursor += value_size
+        return item_key, item_value, cursor
+      end
+
+      # Read an ASCII value
+      #
+      # Parameters::
+      # * *cursor_begin* (_Fixnum_): The cursor to read from
+      # * *cursor_end* (_Fixnum_): The end of the cursor
+      # Result::
+      # * _String_ or <em>list<String></em>: Resulting string or list of strings if several.
+      def read_ascii(cursor_begin, cursor_end)
+        return @data[cursor_begin..cursor_end].gsub(TRAILING_00_REGEXP, '').strip
+      end
+
+    end
+
+  end
+
+end