chd 0.1.1

data/ext/extconf.rb

@@ -0,0 +1,60 @@
+require 'mkmf'
+require 'set'
+
+ROOT = File.join(__dir__, '..')
+
+def with_success(&block)
+    state = [ $CFLAGS, $LDFLAGS, $libs ]
+    block.call.tap {|success|
+        $CFLAGS, $LDFLAGS, $libs = state unless success
+    }
+end
+
+
+build = Set[]
+
+cmake = find_executable('cmake')
+
+unless pkg_config('libchdr').tap {|found|
+           puts "found pkg-config for libchdr" if found
+       } ||
+       with_success do
+           find_library('chdr', 'chd_open') & find_header('libchdr/chd.h')
+       end
+
+    $CFLAGS += " -I " + File.join(ROOT, 'libchdr', 'include')
+
+    $libs += [ 'deps/zlib-1.2.11/libzlib.a',
+               'deps/lzma-19.00/liblzma.a',
+               'CMakeFiles/chdr.dir/src/libchdr_chd.c.o',
+               'CMakeFiles/chdr.dir/src/libchdr_flac.c.o',
+               'CMakeFiles/chdr.dir/src/libchdr_bitstream.c.o',
+               'CMakeFiles/chdr.dir/src/libchdr_huffman.c.o',
+               'CMakeFiles/chdr.dir/src/libchdr_cdrom.c.o',
+             ].map {|l|
+        ' ' + File.join(ROOT, 'build', l)
+    }.join
+
+#    $libs   += [ 'libchdr-static.a', 'liblzma.a', 'libzlib.a' ].map {|l|
+#        ' ' + File.join(ROOT, 'stage', 'lib', l)
+#    }.join(' ')
+
+    build.add(:libchdr)
+end
+
+create_makefile('chd/core')
+
+
+if build.include?(:libchdr)
+    puts "Building bundled libchdr"
+
+    Dir.chdir(ROOT) do
+        unless cmake                                                    &&
+               system(cmake, '-DINSTALL_STATIC_LIBS=on',
+                             '-S', 'libchdr', '-B', 'build')            &&
+               system(cmake, '--build',   'build')
+            abort "failed building libchdr"
+        end
+    end
+end
+

data/lib/chd/cd.rb

@@ -0,0 +1,272 @@
+require 'set'
+require 'digest'
+
+class CHD
+
+#
+# Access a CD-ROM / GD-ROM in Mame CHD format
+#
+class CD
+    # Maximum number of tracks in a CD-ROM
+    MAX_TRACKS             = 99
+
+    # Maximum sector size
+    MAX_SECTOR_DATASIZE    = 2352
+
+    # Maximum subcode size
+    MAX_SUBCODE_DATASIZE   = 96
+
+    # Maximum frame size
+    FRAME_SIZE             = MAX_SUBCODE_DATASIZE + MAX_SECTOR_DATASIZE
+
+    # @!visibility private
+    TRACK_PADDING          = 4
+
+    # Various sector data size according to track type
+    TRACK_TYPE_DATASIZE    = {
+         :MODE1          => 2048,
+         :MODE1_RAW      => 2352,
+         :MODE2          => 2336,
+         :MODE2_FORM1    => 2048,
+         :MODE2_FORM2    => 2324,
+         :MODE2_FORM_MIX => 2336,
+         :MODE2_RAW      => 2352,
+         :AUDIO          => 2352,
+    }.freeze
+    
+    # Various subcode data size according to track type
+    TRACK_SUBTYPE_DATASIZE = {
+        :NONE            => 0,
+        :NORMAL          => 96,
+        :RAW             => 96,
+    }.freeze
+
+    private
+    
+    SYNCBYTES              = [ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+                               0xff, 0xff, 0xff, 0xff, 0xff, 0x00
+                             ].pack('C*').freeze
+    
+    public
+
+    # Read the TOC, and returns it's information in a parsed form.
+    #
+    # @param chd [CHD] a chd opened file
+    #
+    # @return [Array<Hash{Symbol => Object}>] Table of Content
+    # @return [nil] if the CHD file is not of a CD-ROM / GD-ROM type
+    #
+    def self.read_toc(chd)
+        return nil if chd.hunk_bytes %  FRAME_SIZE != 0 ||
+                      chd.unit_bytes != FRAME_SIZE
+        
+        flags  = Set.new
+        tracks = []
+        while (idx = tracks.size) < MAX_TRACKS do
+	    if    md = chd.get_metadata(idx, Metadata::CDROM_TRACK,      )
+	    elsif md = chd.get_metadata(idx, Metadata::CDROM_TRACK_PREGAP)
+	    elsif md = chd.get_metadata(idx, Metadata::GDROM_OLD,        )
+                raise NotSupported, "upgrade your CHD to a more recent version"
+	    elsif md = chd.get_metadata(idx, Metadata::GDROM_TRACK,      )
+                flags << :GDROM
+	    else
+	        break            
+	    end
+            tracks << Metadata.parse(*md)
+        end
+        
+        if ! tracks.empty?
+            unless tracks.each_with_index.all? {|trackinfo, index|
+                       trackinfo[:track] == index + 1
+                   }
+                raise ParsingError, "unordered tracks"
+            end
+            [ tracks, flags ]
+        elsif chd.get_metadata(0, Metadata::CDROM_OLD)
+            raise NotSupported, "upgrade your CHD to a more recent version"
+        else
+            raise NotFoundError, "provided CHD is not a CD-ROM"
+        end
+    end
+            
+    
+    def initialize(chd)
+        @chd         = chd
+        @toc, @flags = CD.read_toc(chd)
+
+        # Build mapping 
+	chdofs = physofs = logofs = 0
+        @mapping = @toc.map {|trackinfo|
+            { :physframeofs => physofs,
+	      :chdframeofs  => chdofs,
+	      :logframeofs  => trackinfo[:pregap] + logofs,
+	      :logframes    => trackinfo[:frames] - trackinfo[:pregap],
+            }.tap {
+                logofs  += trackinfo[:pregap] if trackinfo[:pgdatasize].zero?
+	        logofs  += trackinfo[:frames] + trackinfo[:postgap]
+	        physofs += trackinfo[:frames]
+                chdofs  += trackinfo[:frames] + trackinfo[:extraframes]
+            }
+        }
+        @mapping <<  { :physframeofs => physofs,
+                       :logframeofs  => logofs,
+                       :chdframeofs  => chdofs,
+                       :logframes    => 0,
+                     }
+    end
+
+    
+    # Table of Content
+    #
+    # @return [Array<Hash{Symbol => Object}>]
+    #
+    attr_reader :toc 
+
+    # Get the frame number that the track starts at.
+    #
+    # @param track [Integer] track number (start at 1)
+    #
+    # @return [Integer] frame number
+    #
+    def track_start(track, phys = false)
+        frame_ofs_type = phys ? :physframeofs : :logframeofs
+        
+	# handle lead-out specially
+	if track == 0xAA
+	    @mapping.last[frame_ofs_type]
+        elsif ! (1 .. @toc.size).include?(track)
+            raise RangeError, "track must be in 1..#{@toc.size}"
+        else
+            @mappging.dig(track - 1, frame_ofs_type)
+        end
+    end
+
+    # Read one or more sectors from a CD-ROM
+    #
+    # @param lbasector [Integer] sector number
+    # @param datatype  [Symbol]  type of data 
+    #
+    # @return [String]
+    #
+    def read_sector(lbasector, datatype = nil, phys = false)
+        # Compute CHD sector and track index
+        frame_ofs_type = phys ? :physframeofs : :logframeofs
+        chdsector      = lbasector
+        trackidx       = 0
+        @mapping.each_cons(2).with_index do |(cur, nxt), idx|
+            if lbasector < nxt[frame_ofs_type]
+                chdsector = lbasector - cur[frame_ofs_type] + cur[:chdframeofs]
+                trackidx = idx
+                break
+            end
+        end
+
+
+        trackinfo = @toc[trackidx];
+	tracktype = trackinfo[:trktype]
+
+	offset, length, header =
+             # return same type or don't care
+             if (datatype == tracktype) || datatype.nil?
+                 [ 0,  trackinfo[:datasize] ]
+                 
+	     # return 2048 bytes of MODE1 data
+             #   from a 2352 byte MODE1 RAW sector
+	     elsif (datatype  == :MODE1    ) &&
+                   (tracktype == :MODE1_RAW)
+	         [ 16, 2048 ]
+                 
+	     # return 2352 byte MODE1 RAW sector
+             #  from 2048 bytes of MODE1 data
+	     elsif (datatype  == :MODE1_RAW) &&
+                   (tracktype == :MODE1    )
+	         warn "promotion of MODE1/FORM1 sector to MODE1 RAW is incomplete"
+                 m, sf = lba.divmod(60 * 75);
+                 s, f  = sf.divmod(75)
+                 hdr   = SYNCBYTES + [
+	             ((m / 10) << 4) | ((m % 10) << 0), # M
+	             ((s / 10) << 4) | ((s % 10) << 0), # S
+	             ((f / 10) << 4) | ((f % 10) << 0), # F
+                     1                                  # MODE1
+                 ].pack('C*') # MSF + MODE1
+                 
+                 [ 0, 2048, hdr ]
+                 
+	     # return 2048 bytes of MODE1 data
+             #   from a MODE2 FORM1 or RAW sector
+             elsif (datatype  == :MODE1      ) &&
+                  ((tracktype == :MODE2_FORM1) || (tracktype == :MODE2_RAW  ))
+	         [ 24, 2048 ]
+                 
+	     # return 2048 bytes of MODE1 data
+             #   from a MODE2 FORM2 or XA sector
+	     elsif (datatype  == :MODE1         ) &&
+                   (tracktype == :MODE2_FORM_MIX)
+	         [  8, 2048 ]
+                 
+             # return MODE2 2336 byte data
+             #   from a 2352 byte MODE1 or MODE2 RAW sector (skip the header)
+	     elsif (datatype  == :MODE2) &&
+                  ((tracktype == :MODE1_RAW) || (tracktype == :MODE2_RAW))
+	         [ 16, 2336 ]
+                 
+             # Not supported
+             else
+                 raise NotSupported,
+                       "conversion from type %s to type %s not supported" % [
+                           tracktype, datatype ]
+	     end
+
+        # Read data
+	unless phys 
+	    if ! trackinfo[:pgdatasize].zero?
+		# chdman (phys=true) relies on chdframeofs to point
+                # to index 0 instead of index 1 for extractcd.
+		# Actually playing CDs requires it to point
+                # to index 1 instead of index 0,
+                # so adjust the offset when phys=false.
+		chdsector += trackinfo[:pregap]
+            elsif  lbasector < trackinfo[:logframeofs]
+	        # if this is pregap info that isn't actually in the file,
+                # just return blank data
+                return '\0' * length
+	    end
+	end
+
+        data = @chd.read_bytes(chdsector * FRAME_SIZE + offset, length)
+        data = header + data if header
+        data
+    end
+ 
+
+    private
+    
+
+    def _enhance_toc(toc)
+	chd_offset = physical_offset = logical_offset = 0
+
+        toc.each do |trackinfo|
+	    trackinfo[:logframeofs] = 0
+            
+	    if trackinfo[:pgdatasize].zero?
+		logical_offset         += trackinfo[:pregap]
+	    else
+		trackinfo[:logframeofs] = trackinfo[:pregap]
+            end
+
+	    trackinfo[:physframeofs] = physical_offset
+	    trackinfo[:chdframeofs ] = chd_offset
+	    trackinfo[:logframeofs ] += logical_offset
+	    trackinfo[:logframes   ] = trackinfo[:frames] - trackinfo[:pregap]
+
+	    logical_offset  += trackinfo[:frames] + trackinfo[:postgap]
+	    physical_offset += trackinfo[:frames]
+            chd_offset      += trackinfo[:frames] + trackinfo[:extraframes]
+        end
+
+        toc
+    end
+
+end
+end
+        

data/lib/chd/metadata.rb

@@ -0,0 +1,196 @@
+require 'set'
+
+class CHD
+
+#
+# Parsing of the metadata failed.
+#
+class ParsingError < Error
+end
+
+#
+#
+# | Type | Associated scanf string                                                                |
+# |------|----------------------------------------------------------------------------------------|
+# | GDDD | "CYLS:%d,HEADS:%d,SECS:%d,BPS:%d"                                                      |
+# | CHTR | "TRACK:%d TYPE:%s SUBTYPE:%s FRAMES:%d"                                                |
+# | CHT2 | "TRACK:%d TYPE:%s SUBTYPE:%s FRAMES:%d PREGAP:%d PGTYPE:%s PGSUB:%s POSTGAP:%d"        |
+# | CHGD | "TRACK:%d TYPE:%s SUBTYPE:%s FRAMES:%d PAD:%d PREGAP:%d PGTYPE:%s PGSUB:%s POSTGAP:%d" |
+# | AVAV | "FPS:%d.%06d WIDTH:%d HEIGHT:%d INTERLACED:%d CHANNELS:%d SAMPLERATE:%d"               |
+#
+module Metadata
+    HARD_DISK                = :'GDDD'  # Hard disk
+    HARD_DISK_IDENT          = :'IDNT'  # Hard disk identity
+    HARD_DISK_KEY            = :'KEY '  # Hard disk key
+    PCMCIA_CIS               = :'CIS '  # PCMCIA CIS
+    CDROM_TRACK              = :'CHTR'  # CDROM Track
+    CDROM_TRACK_PREGAP       = :'CHT2'  # CDROM Track with pregap
+    GDROM_TRACK              = :'CHGD'  # GDROM Track (SEGA Genesis)
+    AV                       = :'AVAV'  # Audio/Video
+    AV_LD                    = :'AVLD'  # Audio/Video Laser Disk
+    CDROM_OLD                = :'CHCD'  # CDROM Track (old CHD version)
+    GDROM_OLD                = :'CHGT'  # GDROM Track (old CHD version)
+
+    private
+    
+    HARD_DISK_REGEX          = /\A CYLS:      (?<cyls>%d)        ,
+                                   HEADS:     (?<heads>%d)       ,
+                                   SECS:      (?<secs>%d)        ,
+                                   BPS:       (?<bps>)%d
+                                \z /x
+    CDROM_TRACK_REGEX        = /\A TRACK:     (?<track>\d+)      \s+
+                                   TYPE:      (?<trktype>\w+)    \s+
+                                   SUBTYPE:   (?<subtype>\w+)    \s+
+                                   FRAMES:    (?<frames>\d+)
+                                \z /x
+    CDROM_TRACK_PREGAP_REGEX = /\A TRACK:     (?<track>\d+)      \s+
+                                   TYPE:      (?<trktype>\w+)    \s+
+                                   SUBTYPE:   (?<subtype>\w+)    \s+
+                                   FRAMES:    (?<frames>\d+)     \s+
+                                   PREGAP:    (?<pregap>\d+)     \s+
+                                   PGTYPE:  V?(?<pgtype>\w+)     \s+
+                                   PGSUB:     (?<pgsub>\w+)      \s+
+                                   POSTGAP:   (?<postgap>\d+)
+                                \z /x
+    GDROM_TRACK_REGEX        = /\A TRACK:     (?<track>\d+)      \s+
+                                   TYPE:      (?<trktype>\w+)    \s+
+                                   SUBTYPE:   (?<subtype>\w+)    \s+
+                                   FRAMES:    (?<frames>\d+)     \s+
+                                   PAD:       (?<padframes>\d+)  \s+
+                                   PREGAP:    (?<pregap>\d+)     \s+
+                                   PGTYPE:  V?(?<pgtype>\w+)     \s+
+                                   PGSUB:     (?<pgsub>\w+)      \s+
+                                   POSTGAP:   (?<postgap>\d+)
+                                \z /x
+    AV_REGEX                 = /\A FPS:       (?<fps>\d+\.\d+)   \s+
+                                   WIDTH:     (?<width>\d+)      \s+
+                                   HEIGHT:    (?<height>\d+)     \s+
+                                   INTERLACED:(?<interlaced>\d+) \s+
+                                   CHANNELS:  (?<channels>\d+)   \s+
+                                   SAMPLERATE:(?<samplerate>\d+)
+                                \z /x
+
+
+    CD_TRACK_TYPES = {
+        'MODE1'          => :MODE1,
+        'MODE1/2048'     => :MODE1,
+        'MODE1_RAW'      => :MODE1_RAW,
+        'MODE1/2352'     => :MODE1_RAW,
+        'MODE2'          => :MODE2,
+        'MODE2/2336'     => :MODE2,
+        'MODE2_FORM1'    => :MODE2_FORM1,
+        'MODE2/2048'     => :MODE2_FORM1,
+        'MODE2_FORM2'    => :MODE2_FORM2,
+        'MODE2/2324'     => :MODE2_FORM2,
+        'MODE2_FORM_MIX' => :MODE2_FORM_MIX,
+        'MODE2/2336'     => :MODE2_FORM_MIX,
+        'MODE2_RAW'      => :MODE2_RAW,
+        'MODE2/2352'     => :MODE2_RAW,
+        'AUDIO'          => :AUDIO,
+    }
+
+    CD_TRACK_SUBTYPES = {
+        'NONE'           => :NONE,
+        'RW'             => :NORMAL,
+        'RW_RAW'         => :RAW, 
+    }
+
+
+
+    public
+
+    # Parse metadata returned by {CHD#get_metadata}
+    #
+    # @param data  [String]
+    # @param flags [Integer]
+    # @param type  [Symbol]
+    #
+    # @return [Hash{Symbol => Object}]
+    #
+    # @example
+    #  chd = CHD.new('file.chd')
+    #  puts CHD::Metadata.parse(*chd.get_metadata(0)).inspect
+    #
+    def self.parse(data, flags, type)
+        # Flags
+        unless (flags & ~(METADATA_FLAG_CHECKSUM)).zero?
+            raise ParsingError,
+                  "unsupported flag (0x#{flags.to_s(16)}) (fill bug report)"
+        end
+        set_flags = Set.new
+        set_flags << :checksum unless (flags & METADATA_FLAG_CHECKSUM).zero?
+
+        # Data
+        case type
+        when CDROM_TRACK        then parse_cdrom_track(data, CDROM_TRACK_REGEX)
+        when CDROM_TRACK_PREGAP then parse_cdrom_track(data, CDROM_TRACK_PREGAP_REGEX)
+        when GDROM_TRACK        then parse_cdrom_track(data, GDROM_TRACK_REGEX)
+        when HARD_DISK          then parse_hard_disk(data, HARD_DISK_REGEX)
+        else                    raise "not implemented yet"
+        end
+    end
+
+    private
+
+    def self.parse_cdrom_track(data, regex)
+        md = parse_using_regex(data, regex, :trktype => CD_TRACK_TYPES,
+                                            :subtype => CD_TRACK_SUBTYPES,
+                                            :pgtype  => CD_TRACK_TYPES,
+                                            :pgsub   => CD_TRACK_SUBTYPES)
+        dflt = { :track     => nil,
+                 :trktype   => nil,
+                 :subtype   => nil,
+                 :frames    => nil,
+                 :padframes => 0,
+                 :pregap    => 0,
+                 :pgtype    => :MODE1,
+                 :pgsub     => :NONE,
+                 :postgap   => 0,
+               }
+       
+        md = dflt.merge(md)
+        
+        if (md[:track] < 0) || (md[:track] > CD::MAX_TRACKS)
+            raise ParsingError, "track number out of range"
+        end
+        
+        md.merge(:extraframes => CD::TRACK_PADDING -
+                                   md[:frames] % CD::TRACK_PADDING,
+                 :datasize    => CD::TRACK_TYPE_DATASIZE[   md[:trktype]],
+                 :subsize     => CD::TRACK_SUBTYPE_DATASIZE[md[:subtype]],
+                 :pgdatasize  => CD::TRACK_TYPE_DATASIZE[   md[:pgtype ]],
+                 :pgsubsize   => CD::TRACK_SUBTYPE_DATASIZE[md[:pgsub  ]],
+                )
+    end
+
+    def self.parse_hard_disk(data, regex)
+        parse_using_regex(data, regex)
+    end
+
+    def self.parse_using_regex(data, regex, mapping = nil, &block)
+        unless md = regex.match(data)&.named_captures
+            raise ParsingError, "failed to parse track"
+        end
+
+        md.transform_keys!(&:to_sym)
+        md.transform_values! do |v|
+            case v
+            when /^\d+$/      then Integer(v)
+            when /^\d+\.\d+$/ then Float(v)
+            else v
+            end
+        end
+
+        (mapping || {}).each do |key, map|
+            md[key] = map.fetch(md[key]) if md.include?(key)
+        end
+
+        block&.call(md)
+
+        md
+    rescue KeyError
+        raise ParsingError, "unable to decode track description"
+    end
+    
+end
+end

data/lib/chd/version.rb

@@ -0,0 +1,4 @@
+class CHD
+    # Current version of this gem/library
+    VERSION = '0.1.1'
+end

data/lib/chd.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+require 'chd/core'
+require 'chd/metadata'
+require 'chd/cd'
+
+class CHD
+
+    # Returns a string representation of the number of frames using
+    # minutes:seconds:frames format.
+    #
+    # @param frames [Integer]
+    #
+    # @return [String]
+    #
+    def self.msf(frames)
+        "%02d:%02d:%02d" % [ frames / (75 * 60), (frames / 75) % 60, frames % 75 ]
+    end
+end
+
+
+

data/libchdr/CMakeLists.txt

@@ -0,0 +1,104 @@
+cmake_minimum_required(VERSION 3.9)
+
+project(chdr VERSION 0.1 LANGUAGES C)
+
+if(CMAKE_PROJECT_NAME STREQUAL "chdr")
+  option(BUILD_SHARED_LIBS "Build libchdr also as a shared library" ON)
+endif()
+option(INSTALL_STATIC_LIBS "Install static libraries" OFF)
+option(WITH_SYSTEM_ZLIB "Use system provided zlib library" OFF)
+
+option(BUILD_LTO "Compile libchdr with link-time optimization if supported" OFF)
+if(BUILD_LTO)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT HAVE_IPO)
+  if(HAVE_IPO)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  endif()
+endif()
+
+include(GNUInstallDirs)
+
+#--------------------------------------------------
+# dependencies
+#--------------------------------------------------
+
+
+# lzma
+add_subdirectory(deps/lzma-19.00 EXCLUDE_FROM_ALL)
+  list(APPEND CHDR_LIBS lzma)
+  list(APPEND CHDR_INCLUDES lzma)
+
+# zlib
+if (WITH_SYSTEM_ZLIB)
+  find_package(ZLIB REQUIRED)
+  list(APPEND PLATFORM_LIBS ZLIB::ZLIB)
+else()
+  add_subdirectory(deps/zlib-1.2.11 EXCLUDE_FROM_ALL)
+  list(APPEND CHDR_LIBS zlib)
+  list(APPEND CHDR_INCLUDES zlib)
+endif()
+
+#--------------------------------------------------
+# chdr
+#--------------------------------------------------
+
+set(CHDR_SOURCES
+  src/libchdr_bitstream.c
+  src/libchdr_cdrom.c
+  src/libchdr_chd.c
+  src/libchdr_flac.c
+  src/libchdr_huffman.c
+)
+
+list(APPEND CHDR_INCLUDES ${CMAKE_CURRENT_BINARY_DIR}/include)
+
+add_library(chdr-static STATIC ${CHDR_SOURCES})
+target_include_directories(chdr-static PRIVATE ${CHDR_INCLUDES} PUBLIC include)
+target_link_libraries(chdr-static PRIVATE ${CHDR_LIBS} ${PLATFORM_LIBS})
+
+if(MSVC)
+  target_compile_definitions(chdr-static PRIVATE _CRT_SECURE_NO_WARNINGS)
+endif()
+
+if (INSTALL_STATIC_LIBS)
+  install(TARGETS chdr-static ${CHDR_LIBS}
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  )
+endif()
+
+if (BUILD_SHARED_LIBS)
+  add_library(chdr SHARED ${CHDR_SOURCES})
+  target_include_directories(chdr PRIVATE ${CHDR_INCLUDES} PUBLIC include)
+  target_link_libraries(chdr PRIVATE ${CHDR_LIBS} ${PLATFORM_LIBS})
+
+  if(MSVC)
+    target_compile_definitions(chdr PUBLIC "CHD_DLL")
+    target_compile_definitions(chdr PRIVATE "CHD_DLL_EXPORTS")
+    target_compile_definitions(chdr PRIVATE _CRT_SECURE_NO_WARNINGS)
+  elseif(APPLE)
+    target_link_libraries(chdr PRIVATE -Wl,-dead_strip -Wl,-exported_symbol,_chd_*)
+  else()
+    target_link_libraries(chdr PRIVATE -Wl,--version-script ${CMAKE_CURRENT_SOURCE_DIR}/src/link.T -Wl,--no-undefined)
+  endif()
+
+  set_target_properties(chdr PROPERTIES C_VISIBILITY_PRESET hidden)
+  set_target_properties(chdr PROPERTIES VISIBILITY_INLINES_HIDDEN 1)
+  set_target_properties(chdr PROPERTIES PUBLIC_HEADER "include/libchdr/bitstream.h;include/libchdr/cdrom.h;include/libchdr/chd.h;include/libchdr/chdconfig.h;include/libchdr/coretypes.h;include/libchdr/flac.h;include/libchdr/huffman.h")
+  set_target_properties(chdr PROPERTIES VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}" SOVERSION ${PROJECT_VERSION_MAJOR})
+
+  if (CMAKE_BUILD_TYPE MATCHES Release)
+    #add_custom_command(TARGET chdr POST_BUILD COMMAND ${CMAKE_STRIP} libchdr.so)
+  endif (CMAKE_BUILD_TYPE MATCHES Release)
+
+  install(TARGETS chdr
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/libchdr"
+  )
+
+  configure_file(pkg-config.pc.in ${CMAKE_BINARY_DIR}/libchdr.pc @ONLY)
+  install(FILES ${CMAKE_BINARY_DIR}/libchdr.pc DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif()
+
+add_subdirectory(tests)

data/libchdr/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright Romain Tisserand
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/libchdr/README.md

@@ -0,0 +1,7 @@
+# libchdr
+
+libchdr is a standalone library for reading MAME's CHDv1-v5 formats.
+
+The code is based off of MAME's old C codebase which read up to CHDv4 with OS-dependent features removed, and CHDv5 support backported from MAME's current C++ codebase.
+
+libchdr is licensed under the BSD 3-Clause (see [LICENSE.txt](LICENSE.txt)) and uses third party libraries that are each distributed under their own terms (see each library's license in [deps/](deps/)).