Top | ![]() |
![]() |
![]() |
![]() |
enum | MirageSubChannel |
extern guint16 * | crc16_1021_lut |
extern guint32 * | crc32_d8018001_lut |
extern guint8 * | ecma_130_scrambler_lut |
These functions cover various functionality. They are exported because, while primarily designed to be used within libMirage, they could also prove useful to other applications.
#define MIRAGE_CAST_DATA(buf,off,type) (*((type *)(buf+off)))
A macro for easy retrieval of data from (unsigned integer) buffer. Mostly to be used in binary image parsers, for example, to retrieve guint32 or guint16 value from buffer.
#define MIRAGE_CAST_PTR(buf,off,type) ((type)(buf+off))
A macro for easy placing of pointers within (unsigned integer) buffer. Mostly to be used in binary image parsers, for example, to retrieve a string or a structure from buffer.
guint8
mirage_helper_ascii2isrc (gchar c
);
Converts ASCII character c
into ISRC character.
gint
mirage_helper_bcd2hex (gint bcd
);
Converts bcd-encoded integer into hex-encoded integer.
guint16 mirage_helper_calculate_crc16 (const guint8 *data
,guint length
,const guint16 *crctab
,gboolean reflected
,gboolean invert
);
Calculates the CRC-16 checksum of the data stored in data
.
guint32 mirage_helper_calculate_crc32_fast (const guint8 *data
,guint length
,const guint32 *crctab
,gboolean reflected
,gboolean invert
);
Calculates the CRC-32 checksum of the data stored in data
. This is
fast slice-by-8 implementation that processes 8 bytes at a time, and
requires crctab
to be allocating using mirage_helper_init_crc32_lut()
with slice parameter set to 8.
guint32 mirage_helper_calculate_crc32_standard (const guint8 *data
,guint length
,const guint32 *crctab
,gboolean reflected
,gboolean invert
);
Calculates the CRC-32 checksum of the data stored in data
. This is
standard inplementation that processes 1 byte at a time, and requires
crctab
to be allocated using mirage_helper_init_crc32_lut()
with slice
parameter set to 1.
MirageSectorType
mirage_helper_determine_sector_type (const guint8 *buf
);
Determines sector type from its data, based on first 16 bytes, which correspond to sync pattern and header.
This function is intened to be used in image parsers, for determining track mode in cases when full (2352-byte) sector data is available.
const gchar *
mirage_helper_encoding_from_bom (const guint8 *buffer
);
Tries to decode BOM provided in buffer
, and based on the result
returns the following encodings: UTF-32BE, UTF32-LE, UTF-16LE, UTF-16BE
or UTF-8 (if BOM is not valid).
gchar * mirage_helper_find_data_file (const gchar *filename
,const gchar *path
);
Attempts to find a file with filename filename
and path path
. filename
can
be file's basename or an absolute path. path
can be either directory path (in
this case, it must end with '/') or a filename (i.e. of file descriptor).
If filename
is an absolute path, its existence is first checked. If it
does not exist, search (see below) is performed in filename
's dirname. If
still no match is found and path
is not NULL
, path
's dirname is combined
with filename
's basename, and the combination's existence is checked. If
that fails as well, search (see below) is performed in path
's dirname.
Searching in the directory is performed as follows. Directory is opened
and its content is case-insensitively compared to filename
's basename.
All filenames whose beginning match filename
are considered, and the
shortest one is returned. This way, all possible case variations
(i.e. file.iso, FILE.ISO, FiLe.IsO, etc.) are taken into account.
This function can return a filename with additional suffices, but only if
a file without those extra suffices does not exist. E.g., if search is
done for 'data.img', and only 'data.img.gz' exists, it will be returned.
However, if both 'data.img' and 'data.img.gz' exist, the former will be
returned.
The returned string should be freed when no longer needed.
const gchar *
mirage_helper_get_suffix (const gchar *filename
);
Retrieves suffix from filename
.
gboolean mirage_helper_has_suffix (const gchar *filename
,const gchar *suffix
);
Checks whether file name filename
ends with suffix suffix
.
gint
mirage_helper_hex2bcd (gint hex
);
Converts hex-encoded integer into bcd-encoded integer.
guint16 *
mirage_helper_init_crc16_lut (guint16 genpoly
);
Calculates a look-up table for CRC16 based on the generator polynomial.
guint32 * mirage_helper_init_crc32_lut (guint32 genpoly
,guint slices
);
Calculates a look-up table for CRC32 based on the generator polynomial.
The size of the lookup table depends on slices
. The standard algorithm
processes 1 byte at a time and has a look-up table size of 1KiB, whereas
The slice-by-4 and slice-by-8 algorithms use 4 and 8 KiB look-up tables that
are derived from the initial look-up table.
guint8 *
mirage_helper_init_ecma_130b_scrambler_lut
(void
);
Calculates a look-up table for sector data scrambler from ECMA-130, Annex B. The look-up table consists of 2340 entries, each being a scramble byte for corresponding byte in sector data.
gchar
mirage_helper_isrc2ascii (guint8 c
);
Converts ISRC character c
into ASCII character.
void mirage_helper_lba2msf (gint lba
,gboolean diff
,guint8 *m
,guint8 *s
,guint8 *f
);
Converts LBA sector address stored in lba
into MSF address, storing each field
into m
, s
and f
, respectively.
If diff
is TRUE
, 150 frames difference is accounted for; this should be
used when converting absolute addresses. When converting relative addresses
(or lengths), diff
should be set to FALSE
.
gchar * mirage_helper_lba2msf_str (gint lba
,gboolean diff
);
Converts LBA sector address stored in lba
into MSF address.
If diff
is TRUE
, 150 frames difference is accounted for; this should be
used when converting absolute addresses. When converting relative addresses
(or lengths), diff
should be set to FALSE
.
gint mirage_helper_msf2lba (guint8 m
,guint8 s
,guint8 f
,gboolean diff
);
Converts MSF sector address stored in m
, s
and f
into LBA address.
If diff
is TRUE
, 150 frames difference is accounted for; this should be
used when converting absolute addresses. When converting relative addresses
(or lengths), diff
should be set to FALSE
.
gint mirage_helper_msf2lba_str (const gchar *msf
,gboolean diff
);
Converts MSF sector address stored in msf
string into LBA address.
If diff
is TRUE
, 150 frames difference is accounted for; this should be
used when converting absolute addresses. When converting relative addresses
(or lengths), diff
should be set to FALSE
.
void mirage_helper_sector_edc_ecc_compute_ecc_block (const guint8 *src
,guint32 major_count
,guint32 minor_count
,guint32 major_mult
,guint32 minor_inc
,guint8 *dest
);
Calculates ECC (error correction code) for data in src
and writes the result
into dest
. The code assumes 2352 byte sectors. It can calculate both P and Q
layer of ECC data, depending on major_count
, minor_count
, major_mult
and
minor_inc.
To calculate ECC (first P, then Q layer) for different types of sectors and store it into sector data, use:
mirage_helper_sector_edc_ecc_compute_ecc_block(sector_buffer+0xC, 86, 24, 2, 86, sector_buffer+0x81C); mirage_helper_sector_edc_ecc_compute_ecc_block(sector_buffer+0xC, 52, 43, 86, 88, sector_buffer+0x8C8);
mirage_helper_sector_edc_ecc_compute_ecc_block(sector_buffer+0xC, 86, 24, 2, 86, sector_buffer+0x81C); \n mirage_helper_sector_edc_ecc_compute_ecc_block(sector_buffer+0xC, 52, 43, 86, 88, sector_buffer+0x8C8);
(This is assuming all other sector data, including EDC, is already stored in sector_buffer and that sector_buffer is 2532 bytes long)
void mirage_helper_sector_edc_ecc_compute_edc_block (const guint8 *src
,guint16 size
,guint8 *dest
);
Calculates EDC (error detection code) for data in src
of length size
and
writes the result into dest
.
To calculate EDC for different types of sectors and store it into sector data, use:
mirage_helper_sector_edc_ecc_compute_edc_block(sector_buffer+0x00, 0x810, sector_buffer+0x810);
mirage_helper_sector_edc_ecc_compute_edc_block(sector_buffer+0x10, 0x808, sector_buffer+0x818);
mirage_helper_sector_edc_ecc_compute_edc_block(sector_buffer+0x10, 0x91C, sector_buffer+0x92C);
(This is assuming all other sector data is already stored in sector_buffer and that sector_buffer is 2532 bytes long)
gint mirage_helper_strcasecmp (const gchar *str1
,const gchar *str2
);
Replacement function for g_strcasecmp/strcasecmp, which can properly handle UTF-8. Glib docs state this is only an approximation, albeit it should be a fairly good one.
It compares the two strings str1
and str2
, ignoring the case of the characters.
It returns an integer less than, equal to, or greater than zero if str1
is found,
respectively, to be less than, to match, or be greater than str2
.
gint mirage_helper_strncasecmp (const gchar *str1
,const gchar *str2
,gint len
);
Replacement function for g_strncasecmp/strncasecmp, which can properly handle UTF-8. Glib docs state this is only an approximation, albeit it should be a fairly good one.
It compares first len
characters of string str1
and str2
, ignoring the case of
the characters. It returns an integer less than, equal to, or greater than zero if
first len
characters of str1
is found, respectively, to be less than, to match,
or be greater than first len
characters of str2
.
gchar * mirage_helper_format_string (const gchar *format
,...
);
General-purpose string formatter with token replacement. Similarly to sprintf, the tokens begin with percent character, but instead of denoting format type, the tokens denote placeholders for user-defined replacements. Sprintf-like field width and precision modifiers are supported for formatting the replacements. If replacement is not specified for a replacement token found in format, then the token is removed in the output string.
If replacement does not exist and the token to be replaced is preceded by other word-caracters (see GRegex documentation for details), in addition to the replacement token, all those word characters are removed together with the leading non-word character.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Example: formatting a filename output = mirage_helper_format_string("%b-%02s-track%t.%e", "b", g_variant_new_string("some_image"), "s", g_variant_new_int16(1), "t", g_variant_new_int16(3), "e", g_variant_new_string("iso"), NULL); // output = "some_image-01-track3.iso" // Example: removal of preceding characters when replacement does not exist output = mirage_helper_format_string("%b-%02s-track%t.%e", "b", g_variant_new_string("some_image"), "s", g_variant_new_int16(1), "e", g_variant_new_string("iso"), NULL); // output = "some_image-01.iso" |
Varargs
is a NULL
-terminated list of replacement token/value pairs,
where a replacement token/value pair is a pair of string and a GVariant.
gchar * mirage_helper_format_stringd (const gchar *format
,GHashTable *dictionary
);
Dictionary-version of mirage_helper_format_string()
.
dictionary
is a GHashTable where keys are replacement token strings
and each value is a GVariant containing corresponding token replacement
value.
gchar * mirage_helper_format_stringv (const gchar *format
,va_list args
);
Variable-argument-list-version of mirage_helper_format_string()
.
args
is a NULL
-terminated list of replacement token/value pairs,
where a replacement token/value pair is a pair of string and a GVariant.
void mirage_helper_subchannel_deinterleave (gint subchan
,const guint8 *channel96
,guint8 *channel12
);
Deinterleaves subchannel data of type subchan
from subchannel data stored in
channel96
and writes the resulting subhcannel data into subchannel12
.
void mirage_helper_subchannel_interleave (gint subchan
,const guint8 *channel12
,guint8 *channel96
);
Interleaves subchannel data of type subchan
stored in channel12
into
subchannel data stored in subchannel96
.
guint16
mirage_helper_subchannel_q_calculate_crc
(const guint8 *data
);
Calculates the CRC-16 checksum of the Q subchannel data stored in data
.
void mirage_helper_subchannel_q_decode_isrc (const guint8 *buf
,gchar *isrc
);
Decodes ISRC stored in buf
into string isrc
.
void mirage_helper_subchannel_q_decode_mcn (const guint8 *buf
,gchar *mcn
);
Decodes MCN stored in buf
into string mcn
.
void mirage_helper_subchannel_q_encode_isrc (guint8 *buf
,const gchar *isrc
);
Encodes ISRC string isrc
into buffer buf
.
void mirage_helper_subchannel_q_encode_mcn (guint8 *buf
,const gchar *mcn
);
Encodes MCN string mcn
into buffer buf
.
extern guint16 *crc16_1021_lut;
Global look-up table for computing CRC16 with generator polygon value
0x1021, used for computing CRC in Q sub-channel in
mirage_helper_subchannel_q_calculate_crc()
.
The look-up table buffer is allocated and initialized by
mirage_initialize()
, using mirage_helper_init_crc16_lut()
. It is
freed and cleared by mirage_shutdown()
.
The lookup table is generated from the polynomial given as: P(x) = x^16 + x^12 + x^5 + x^0 = x^16 + x^12 + x^5 + 1 Where only the 16 lowest bits are used: 0x11021 & 0xFFFF = 0x1021
extern guint32 *crc32_d8018001_lut;
Global look-up table for computing CRC32 with generator polygon value
0xD8018001, used for computing CRC (EDC) over sector data in
mirage_helper_sector_edc_ecc_compute_edc_block()
.
The look-up table buffer is allocated and initialized by
mirage_initialize()
, using mirage_helper_init_crc32_lut()
. It is
freed and cleared by mirage_shutdown()
.
The lookup table is generated from the polynomial given as: P(x) = (x^16 + x^15 + x^2 + x^0) * (x^16 + x^2 + x^1 + x^0) = x^32 + x^31 + x^16 + x^15 + x^4 + x^3 + x + 1 Where only the 32 lowest bits are used: 0x18001801B & 0xFFFFFFFF = 0x8001801B This value is then reflected (reversed bitwise): 0x8001801B -> 0xD8018001
extern guint8 *ecma_130_scrambler_lut;
Global look-up table for scrambling/de-scrambling sector data as
per ECMA-130, Annex B. Used by mirage_sector_scramble()
.
The look-up table buffer is allocated and initialized by
mirage_initialize()
, using mirage_helper_init_ecma_130b_scrambler_lut()
.
It is freed and cleared by mirage_shutdown()
.