claunia/libcdio-osx
Archived
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

1) cdtext objects are no longer associated with a track but with the disc.

Browse Source 
2) - cdio_get_cdtext no longer takes track as an argument
- cdtext_get, cdtext_get_const, cdtext_set require track argument
3) Language, Genre, Genre Code and Encoding Fields are now properly parsed and stored in the cdtext object
4) Added public function cdio_get_cdtext_raw to extract the binary CD-Text
5) Added CDTEXTFILE keyword logic in cue sheet parser. Parses binary/raw CD-Text files
6) Added cdtext_genre2str to convert genre code
7) altered the example programs, test drivers, cdda-player and cd-info to work with these changes
8) Added test case
9) A few smaller changes
A disc either holds CD-Text for all the tracks or does not hold any. Therefore a CD-Text object for the whole disc seems more natural to me. It also enables us to store global fields, like genre, encoding, language.

Patch was tested on GNU/Linux 32 bit running Gentoo.
This commit is contained in:
R. Bernstein
2011-11-24 20:54:40 -05:00
parent e0b2ee826d
commit dbf6d24765
43 changed files with 639 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/driver/FreeBSD/freebsd.c
View File

@@ -1111,6 +1111,7 @@ cdio_open_am_freebsd (const char *psz_orig_source_name,
.get_arg = get_arg_freebsd,
.get_blocksize = get_blocksize_mmc,
.get_cdtext = get_cdtext_generic,
.get_cdtext_raw = read_cdtext_generic,
.get_default_device = cdio_get_default_device_freebsd,
.get_devices = cdio_get_devices_freebsd,
.get_disc_last_lsn = get_disc_last_lsn_freebsd,
@@ -1145,7 +1146,6 @@ cdio_open_am_freebsd (const char *psz_orig_source_name,
_data->gen.init = false;
_data->gen.fd = -1;
_data->gen.toc_init = false;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source_name) {

2
lib/driver/MSWindows/win32.c
View File

@@ -306,7 +306,6 @@ init_win32 (void *p_user_data)
p_env->gen.init = true;
p_env->gen.toc_init = false;
p_env->gen.b_cdtext_init = false;
p_env->gen.b_cdtext_error = false;
p_env->gen.fd = open (p_env->gen.source_name, O_RDONLY, 0);
@@ -962,6 +961,7 @@ cdio_open_am_win32 (const char *psz_orig_source, const char *psz_access_mode)
_funcs.free = free_win32;
_funcs.get_arg = get_arg_win32;
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext_raw = read_cdtext_generic;
_funcs.get_default_device = cdio_get_default_device_win32;
_funcs.get_devices = cdio_get_devices_win32;
_funcs.get_disc_last_lsn = get_disc_last_lsn_win32;

73
lib/driver/_cdio_generic.c
View File

@@ -88,15 +88,14 @@ void
cdio_generic_free (void *p_user_data)
{
generic_img_private_t *p_env = p_user_data;
track_t i_track;
if (NULL == p_env) return;
if (p_env->source_name) free (p_env->source_name);
if (p_env->b_cdtext_init) {
for (i_track=0; i_track < p_env->i_tracks; i_track++) {
cdtext_destroy(&(p_env->cdtext_track[i_track]));
}
if (NULL != p_env->cdtext) {
cdtext_destroy(p_env->cdtext);
free(p_env->cdtext);
p_env->cdtext = NULL;
}
if (p_env->fd >= 0)
@@ -130,7 +129,7 @@ cdio_generic_init (void *user_data, int open_flags)
p_env->init = true;
p_env->toc_init = false;
p_env->b_cdtext_init = false;
p_env->cdtext = NULL;
p_env->b_cdtext_error = false;
p_env->i_joliet_level = 0; /* Assume no Joliet extensions initally */
return true;
@@ -262,27 +261,31 @@ cdio_add_device_list(char **device_list[], const char *drive,
not exist, or we don't know how to get this implemented.
*/
cdtext_t *
get_cdtext_generic (void *p_user_data, track_t i_track)
get_cdtext_generic (void *p_user_data)
{
generic_img_private_t *p_env = p_user_data;
uint8_t *p_cdtext_data = NULL;
if (!p_env) return NULL;
if (!p_env->toc_init)
p_env->cdio->op.read_toc (p_user_data);
if ( (0 != i_track
&& i_track >= p_env->i_tracks+p_env->i_first_track ) )
return NULL;
if (NULL == p_env->cdtext) {
p_cdtext_data = read_cdtext_generic (p_env);
if (NULL != p_cdtext_data) {
p_env->cdtext = malloc (sizeof(cdtext_t));
cdtext_init(p_env->cdtext);
if (!p_env->b_cdtext_init)
init_cdtext_generic(p_env);
if (!p_env->b_cdtext_init) return NULL;
if(!cdtext_data_init (p_env->cdtext, p_cdtext_data)) {
p_env->b_cdtext_error = true;
cdtext_destroy (p_env->cdtext);
free(p_env->cdtext);
p_env->cdtext = NULL;
}
if (0 == i_track)
return &(p_env->cdtext);
else
return &(p_env->cdtext_track[i_track-p_env->i_first_track]);
free(p_cdtext_data);
}
}
return p_env->cdtext;
}
/*!
@@ -422,36 +425,20 @@ get_num_tracks_generic(void *p_user_data)
return p_env->toc_init ? p_env->i_tracks : CDIO_INVALID_TRACK;
}
void
set_cdtext_field_generic(void *p_user_data, track_t i_track,
track_t i_first_track,
cdtext_field_t e_field, const char *psz_value)
{
char **pp_field;
generic_img_private_t *p_env = p_user_data;
if( i_track == 0 )
pp_field = &(p_env->cdtext.field[e_field]);
else
pp_field = &(p_env->cdtext_track[i_track-i_first_track].field[e_field]);
if (*pp_field) free(*pp_field);
*pp_field = (psz_value) ? strdup(psz_value) : NULL;
}
/*!
Read CD-Text information for a CdIo_t object .
return true on success, false on error or CD-Text information does
not exist.
return pointer to raw cdtext on success,
NULL on failure
free when done and not NULL
*/
bool
init_cdtext_generic (generic_img_private_t *p_env)
uint8_t *
read_cdtext_generic(void *p_env)
{
return mmc_init_cdtext_private( p_env,
p_env->cdio->op.run_mmc_cmd,
set_cdtext_field_generic
generic_img_private_t *p_user_data = p_env;
return mmc_read_cdtext_private (p_user_data,
p_user_data->cdio->op.run_mmc_cmd
);
}

7
lib/driver/aix.c
View File

@@ -110,7 +110,6 @@ typedef struct {
lsn_t start_lsn;
uchar Control : 4;
uchar Format;
cdtext_t cdtext; /* CD-TEXT */
} track_info_t;
typedef struct {
@@ -172,8 +171,6 @@ init_aix (_img_private_t *p_env)
p_env->gen.init = true;
p_env->gen.toc_init = false;
p_env->gen.b_cdtext_init = false;
p_env->gen.b_cdtext_error = false;
p_env->gen.i_joliet_level = 0; /* Assume no Joliet extensions initally */
p_env->access_mode = _AM_CTRL_SCSI;
@@ -946,6 +943,7 @@ cdio_open_am_aix (const char *psz_orig_source, const char *access_mode)
_funcs.free = cdio_generic_free;
_funcs.get_arg = get_arg_aix;
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext_raw = read_cdtext_generic;
_funcs.get_default_device = cdio_get_default_device_aix;
_funcs.get_devices = cdio_get_devices_aix;
_funcs.get_disc_last_lsn = get_disc_last_lsn_aix;
@@ -973,11 +971,10 @@ cdio_open_am_aix (const char *psz_orig_source, const char *access_mode)
_data = calloc (1, sizeof (_img_private_t));
_data->access_mode = _AM_CTRL_SCSI;
_data->gen.b_cdtext_error = false;
_data->gen.init = false;
_data->gen.fd = -1;
_data->gen.toc_init = false;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source) {
psz_source = cdio_get_default_device_aix();

4
lib/driver/bsdi.c
View File

@@ -995,6 +995,7 @@ cdio_open_bsdi (const char *psz_orig_source)
.free = cdio_generic_free,
.get_arg = _get_arg_bsdi,
.get_cdtext = get_cdtext_generic,
.get_cdtext_raw = read_cdtext_generic,
.get_default_device = cdio_get_default_device_bsdi,
.get_devices = cdio_get_devices_bsdi,
.get_drive_cap = get_drive_cap_mmc,
@@ -1027,11 +1028,10 @@ cdio_open_bsdi (const char *psz_orig_source)
_data = calloc (1, sizeof (_img_private_t));
_data->access_mode = _AM_IOCTL;
_data->gen.b_cdtext_error = false;
_data->gen.init = false;
_data->gen.fd = -1;
_data->gen.toc_init = false;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source) {
psz_source=cdio_get_default_device_bsdi();

19
lib/driver/cdio.c
View File

@@ -53,25 +53,6 @@ cdio_get_arg (const CdIo *obj, const char key[])
}
}
/*!
Get cdtext information for a CdIo object .
@param obj the CD object that may contain CD-TEXT information.
@return the CD-TEXT object or NULL if obj is NULL
or CD-TEXT information does not exist.
*/
cdtext_t *
cdio_get_cdtext (CdIo *obj, track_t i_track)
{
if (obj == NULL) return NULL;
if (obj->op.get_cdtext) {
return obj->op.get_cdtext (obj->env, i_track);
} else {
return NULL;
}
}
CdIo_t *
cdio_new (generic_img_private_t *p_env, cdio_funcs_t *p_funcs)
{

16
lib/driver/cdio_private.h
View File

@@ -150,11 +150,19 @@ extern "C" {
@param obj the CD object that may contain CD-TEXT information.
@return the CD-TEXT object or NULL if obj is NULL
or CD-TEXT information does not exist.
If i_track is 0 or CDIO_CDROM_LEADOUT_TRACK the track returned
is the information assocated with the CD.
*/
cdtext_t * (*get_cdtext) ( void *p_env, track_t i_track );
cdtext_t * (*get_cdtext) ( void *p_env );
/*!
Get raw cdtext information as on the disc for a CdIo object
@param obj the CD object that may contain CD-TEXT information.
@return pointer to the raw CD-TEXT data or NULL if obj is NULL
or no CD-TEXT information present on the disc.
free when done and not NULL.
*/
uint8_t * (*get_cdtext_raw) ( void *p_env );
/*!
Return an array of device names. if CdIo is NULL (we haven't

294
lib/driver/cdtext.c
View File

@@ -37,26 +37,26 @@
#include <strings.h>
#endif
#include <stdio.h>
#define _CDTEXT_DBCC
/*! Note: the order and number items (except CDTEXT_INVALID) should
match the cdtext_field_t enumeration. */
static const char cdtext_keywords[][16] =
{
"ARRANGER",
"COMPOSER",
"DISC_ID",
"GENRE",
"MESSAGE",
"ISRC",
"PERFORMER",
"SIZE_INFO",
"SONGWRITER",
"TITLE",
"TOC_INFO",
"TOC_INFO2",
"UPC_EAN",
};
{
"ARRANGER",
"COMPOSER",
"DISC_ID",
"GENRE",
"MESSAGE",
"ISRC",
"PERFORMER",
"SIZE_INFO",
"SONGWRITER",
"TITLE",
"TOC_INFO",
"TOC_INFO2",
"UPC_EAN",
};
static const char cdtext_genre[][30] =
{
@@ -88,7 +88,7 @@ static const char cdtext_genre[][30] =
"Sound Effects",
"Spoken Word",
"World Music"
} ;
};
/*! Return string representation of the enum values above */
const char *
@@ -100,19 +100,31 @@ cdtext_field2str (cdtext_field_t i)
return cdtext_keywords[i];
}
/*! Return string representation of the given genre oode */
const char *
cdtext_genre2str (cdtext_genre_t i)
{
if (i >= MAX_CDTEXT_GENRE_CODE)
return "Invalid genre code";
else
return cdtext_genre[i];
}
/*! Free memory assocated with cdtext*/
void
cdtext_destroy (cdtext_t *p_cdtext)
{
cdtext_field_t i;
track_t i2;
if (!p_cdtext) return;
for (i=0; i < MAX_CDTEXT_FIELDS; i++) {
if (p_cdtext->field[i]) {
free(p_cdtext->field[i]);
p_cdtext->field[i] = NULL;
for (i2=0; i2<=99; i2++) {
for (i=0; i < MAX_CDTEXT_FIELDS; i++) {
if (p_cdtext->track[i2].field[i]) {
free(p_cdtext->track[i2].field[i]);
p_cdtext->track[i2].field[i] = NULL;
}
}
}
}
@@ -121,18 +133,25 @@ cdtext_destroy (cdtext_t *p_cdtext)
if key is CDTEXT_INVALID or the field is not set.
*/
char *
cdtext_get (cdtext_field_t key, const cdtext_t *p_cdtext)
cdtext_get (cdtext_field_t key, track_t track, const cdtext_t *p_cdtext)
{
if ((key == CDTEXT_INVALID) || !p_cdtext
|| (!p_cdtext->field[key])) return NULL;
return strdup(p_cdtext->field[key]);
const char *ret = cdtext_get_const(key, track, p_cdtext);
if (NULL == ret)
return NULL;
else
return strdup(ret);
}
const char *
cdtext_get_const (cdtext_field_t key, const cdtext_t *p_cdtext)
cdtext_get_const (cdtext_field_t key, track_t track, const cdtext_t *p_cdtext)
{
if (key == CDTEXT_INVALID) return NULL;
return p_cdtext->field[key];
if (CDTEXT_INVALID == key
|| NULL == p_cdtext
|| 0 > track
|| 99 < track)
return NULL;
return p_cdtext->track[track].field[key];
}
@@ -144,28 +163,26 @@ void
cdtext_init (cdtext_t *p_cdtext)
{
cdtext_field_t i;
track_t i2;
for (i=0; i < MAX_CDTEXT_FIELDS; i++) {
p_cdtext->field[i] = NULL;
for (i2=0; i2<=99; i2++) {
for (i=0; i < MAX_CDTEXT_FIELDS; i++) {
p_cdtext->track[i2].field[i] = NULL;
}
}
p_cdtext->genre_code = CDIO_CDTEXT_GENRE_UNUSED;
p_cdtext->language[0] = '\0';
p_cdtext->encoding[0] = '\0';
p_cdtext->block = 0;
}
/*!
returns 0 if field is a CD-TEXT keyword, returns non-zero otherwise
returns associated cdtext_field_t if field is a CD-TEXT keyword, returns non-zero otherwise
*/
cdtext_field_t
cdtext_is_keyword (const char *key)
{
#if 0
char *item;
item = bsearch(key,
cdtext_keywords, 12,
sizeof (char *),
(int (*)(const void *, const void *))
strcmp);
return (NULL != item) ? 0 : 1;
#else
unsigned int i;
for (i = 0; i < 13 ; i++)
@@ -173,31 +190,29 @@ cdtext_is_keyword (const char *key)
return i;
}
return CDTEXT_INVALID;
#endif
}
/*! sets cdtext's keyword entry to field.
*/
void
cdtext_set (cdtext_field_t key, const char *p_value, cdtext_t *p_cdtext)
cdtext_set (cdtext_field_t key, track_t track, const char *p_value, cdtext_t *p_cdtext)
{
if (NULL == p_value || key == CDTEXT_INVALID) return;
if (p_cdtext->field[key]) free (p_cdtext->field[key]);
p_cdtext->field[key] = strdup (p_value);
if (NULL == p_value || key == CDTEXT_INVALID || 0 > track || 99 < track) return;
if (p_cdtext->track[track].field[key])
free (p_cdtext->track[track].field[key]);
p_cdtext->track[track].field[key] = strdup (p_value);
}
#define SET_CDTEXT_FIELD(FIELD) \
(*set_cdtext_field_fn)(p_user_data, i_track, i_first_track, FIELD, buffer);
cdtext_set(FIELD, i_track, buffer, p_cdtext);
/*
parse all CD-TEXT data retrieved.
*/
bool
cdtext_data_init(void *p_user_data, track_t i_first_track,
unsigned char *wdata, int i_data,
set_cdtext_field_fn_t set_cdtext_field_fn)
cdtext_data_init(cdtext_t *p_cdtext, uint8_t *wdata)
{
CDText_data_t *p_data;
int i = -1;
@@ -206,14 +221,13 @@ cdtext_data_init(void *p_user_data, track_t i_first_track,
int idx;
int i_track;
bool b_ret = false;
char block = 0;
char encoding[16];
int block = 0;
uint16_t i_data = CDTEXT_GET_LEN16(wdata) - 2;
CDText_blocksize_t p_blocksize;
memset( buffer, 0x00, sizeof(buffer) );
idx = 0;
bzero(encoding,16);
bzero(&p_blocksize, sizeof(CDText_blocksize_t));
p_data = (CDText_data_t *) (&wdata[4]);
@@ -221,26 +235,40 @@ cdtext_data_init(void *p_user_data, track_t i_first_track,
for( ; i_data > 0;
i_data -= sizeof(CDText_data_t), p_data++ ) {
#if TESTED
#ifndef _CDTEXT_DBCC
if ( p_data->bDBC ) {
cdio_warn("Double-byte characters not supported");
return false;
}
#endif
if ( p_data->seq != ++i || p_data->block != block ) break;
/* only handle character packs */
if ( ((p_data->type >= 0x80) && (p_data->type <= 0x86)) ||
(p_data->type == 0x8E)) {
if ( ((p_data->type >= 0x80) && (p_data->type <= 0x87)) ||
(p_data->type == 0x8E))
{
i_track = p_data->i_track;
for( j=0; j < CDIO_CDTEXT_MAX_TEXT_DATA; (p_data->bDBC ? j+=2 : j++) ) {
j = 0;
if (CDIO_CDTEXT_GENRE == p_data->type) {
j = 2;
if (CDIO_CDTEXT_GENRE_UNUSED == p_cdtext->genre_code) {
p_cdtext->genre_code = CDTEXT_GET_LEN16(p_data->text);
}
}
#ifdef _CDTEXT_DBCC
for( ; j < CDIO_CDTEXT_MAX_TEXT_DATA; (p_data->bDBC ? j+=2 : j++) ) {
if( p_data->text[j] == 0x00 && (!p_data->bDBC || p_data->text[j+1] == 0x00)) {
if((buffer[0] != 0x00) && (!p_data->bDBC || buffer[1] != 0x00)) {
#else
for( ; j < CDIO_CDTEXT_MAX_TEXT_DATA; j++) {
if( p_data->text[j] == 0x00) {
if(buffer[0] != 0x00) {
#endif
/* omit empty strings */
if((buffer[0] != 0x00) && (!p_data->bDBC || buffer[1] != 0x00)) {
switch( p_data->type) {
case CDIO_CDTEXT_TITLE:
SET_CDTEXT_FIELD(CDTEXT_TITLE);
@@ -273,6 +301,9 @@ cdtext_data_init(void *p_user_data, track_t i_first_track,
SET_CDTEXT_FIELD(CDTEXT_ISRC);
}
break;
case CDIO_CDTEXT_GENRE:
SET_CDTEXT_FIELD(CDTEXT_GENRE);
break;
}
b_ret = true;
@@ -281,82 +312,125 @@ cdtext_data_init(void *p_user_data, track_t i_first_track,
}
} else {
buffer[idx++] = p_data->text[j];
#ifdef _CDTEXT_DBCC
if(p_data->bDBC)
buffer[idx++] = p_data->text[j+1];
#endif
}
buffer[idx] = 0x00;
#ifdef _CDTEXT_DBCC
if(p_data->bDBC)
buffer[idx+1] = 0x00;
#endif
}
} else {
/* not a character pack */
if (p_data->type == CDIO_CDTEXT_GENRE) {
i_track = p_data->i_track;
/* seems like it is a uint_16 in the first 2 bytes */
if((p_data->text[0] << 8) + p_data->text[1] != CDIO_CDTEXT_GENRE_UNUSED) {
sprintf(buffer,"%s",cdtext_genre[(p_data->text[0] << 8) + p_data->text[1]]);
SET_CDTEXT_FIELD(CDTEXT_GENRE);
}
#ifdef _DEBUG_CDTEXT
printf("GENRE information present: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
p_data->text[0],p_data->text[1],p_data->text[2],p_data->text[3],
p_data->text[4],p_data->text[5],p_data->text[6],p_data->text[7],
p_data->text[8],p_data->text[9],p_data->text[10],p_data->text[11]);
#endif
}
if(p_data->type == CDIO_CDTEXT_TOC) {
#ifdef _DEBUG_CDTEXT
printf("TOC information present: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
p_data->text[0],p_data->text[1],p_data->text[2],p_data->text[3],
p_data->text[4],p_data->text[5],p_data->text[6],p_data->text[7],
p_data->text[8],p_data->text[9],p_data->text[10],p_data->text[11]);
#endif
/* no idea what this is */
}
if (p_data->type == CDIO_CDTEXT_TOC2) {
#ifdef _DEBUG_CDTEXT
printf("TOC2 information present: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
p_data->text[0],p_data->text[1],p_data->text[2],p_data->text[3],
p_data->text[4],p_data->text[5],p_data->text[6],p_data->text[7],
p_data->text[8],p_data->text[9],p_data->text[10],p_data->text[11]);
#endif
/* no idea what this is */
}
/* i got this info from cdrtools' cdda2wav; all the tests i ran so far were successful */
if (p_data->type == CDIO_CDTEXT_BLOCKSIZE) {
/* i_track is the pack element number in this case */
/* i_track is the pack element number in this case */
switch(p_data->i_track){
case 0:
memcpy((char*)&p_blocksize,p_data->text,0x0c);
break;
case 1:
memcpy(((char*)&p_blocksize)+0x0c,p_data->text,0x0c);
break;
case 2:
memcpy(((char*)&p_blocksize)+0x18,p_data->text,0x0c);
break;
case 0:
memcpy((char*)&p_blocksize,p_data->text,0x0c);
break;
case 1:
memcpy(((char*)&p_blocksize)+0x0c,p_data->text,0x0c);
break;
case 2:
memcpy(((char*)&p_blocksize)+0x18,p_data->text,0x0c);
break;
}
}
}
}
if (p_blocksize.packcount[15] >= 3) {
/* BLOCKSIZE packs present */
if (p_blocksize.i_packs[15] >= 3) {
/* if there were more than 3 BLOCKSIZE packs */
switch (p_blocksize.charcode){
case CDIO_CDTEXT_CHARCODE_ISO_8859_1:
sprintf(encoding,"ISO-8859-1");
break;
case CDIO_CDTEXT_CHARCODE_ASCII:
sprintf(encoding,"ASCII");
break;
case CDIO_CDTEXT_CHARCODE_KANJI:
sprintf(encoding,"Shift-JIS");
break;
case CDIO_CDTEXT_CHARCODE_ISO_8859_1:
strcpy(p_cdtext->encoding, "ISO-8859-1");
break;
case CDIO_CDTEXT_CHARCODE_ASCII:
strcpy(p_cdtext->encoding, "ASCII");
break;
case CDIO_CDTEXT_CHARCODE_KANJI:
strcpy(p_cdtext->encoding, "Shift-JIS");
break;
}
/* set ISO 639-1 code */
switch (p_blocksize.langcode[block]) {
case CDIO_CDTEXT_LANG_CZECH :
strcpy(p_cdtext->language, "cs");
break;
case CDIO_CDTEXT_LANG_DANISH :
strcpy(p_cdtext->language, "da");
break;
case CDIO_CDTEXT_LANG_GERMAN :
strcpy(p_cdtext->language, "de");
break;
case CDIO_CDTEXT_LANG_ENGLISH :
strcpy(p_cdtext->language, "en");
break;
case CDIO_CDTEXT_LANG_SPANISH :
strcpy(p_cdtext->language, "es");
break;
case CDIO_CDTEXT_LANG_FRENCH :
strcpy(p_cdtext->language, "fr");
break;
case CDIO_CDTEXT_LANG_ITALIAN :
strcpy(p_cdtext->language, "it");
break;
case CDIO_CDTEXT_LANG_HUNGARIAN :
strcpy(p_cdtext->language, "hu");
break;
case CDIO_CDTEXT_LANG_DUTCH :
strcpy(p_cdtext->language, "nl");
break;
case CDIO_CDTEXT_LANG_NORWEGIAN :
strcpy(p_cdtext->language, "no");
break;
case CDIO_CDTEXT_LANG_POLISH :
strcpy(p_cdtext->language, "pl");
break;
case CDIO_CDTEXT_LANG_PORTUGUESE :
strcpy(p_cdtext->language, "pt");
break;
case CDIO_CDTEXT_LANG_SLOVENE :
strcpy(p_cdtext->language, "sl");
break;
case CDIO_CDTEXT_LANG_FINNISH :
strcpy(p_cdtext->language, "fi");
break;
case CDIO_CDTEXT_LANG_SWEDISH :
strcpy(p_cdtext->language, "sv");
break;
case CDIO_CDTEXT_LANG_RUSSIAN :
strcpy(p_cdtext->language, "ru");
break;
case CDIO_CDTEXT_LANG_KOREAN :
strcpy(p_cdtext->language, "ko");
break;
case CDIO_CDTEXT_LANG_JAPANESE :
strcpy(p_cdtext->language, "ja");
break;
case CDIO_CDTEXT_LANG_GREEK :
strcpy(p_cdtext->language, "el");
break;
case CDIO_CDTEXT_LANG_CHINESE :
strcpy(p_cdtext->language, "zh");
break;
}
}
return b_ret;
}

65
lib/driver/cdtext_private.h
View File

@@ -21,6 +21,8 @@
#include <cdio/cdio.h>
#include <cdio/cdtext.h>
#define CDTEXT_GET_LEN16(p) (p[0]<<8) + p[1]
/*! An enumeration for some of the CDIO_CDTEXT_* #defines below. This isn't
really an enumeration one would really use in a program it is here
to be helpful in debuggers where wants just to refer to the
@@ -44,41 +46,6 @@ extern const enum cdtext_enum1_s {
} cdtext_enums1;
/*!
* CD-Text Genre Codes
*/
extern const enum cdtext_genre_enum_s {
CDIO_CDTEXT_GENRE_UNUSED = 0, /**< not used */
CDIO_CDTEXT_GENRE_UNDEFINED = 1, /**< not defined */
CDIO_CDTEXT_GENRE_ADULT_CONTEMP = 2, /**< Adult Contemporary */
CDIO_CDTEXT_GENRE_ALT_ROCK = 3, /**< Alternative Rock */
CDIO_CDTEXT_GENRE_CHILDRENS = 4, /**< Childrens Music */
CDIO_CDTEXT_GENRE_CLASSIC = 5, /**< Classical */
CDIO_CDTEXT_GENRE_CHRIST_CONTEMP = 6, /**< Contemporary Christian */
CDIO_CDTEXT_GENRE_COUNTRY = 7, /**< Country */
CDIO_CDTEXT_GENRE_DANCE = 8, /**< Dance */
CDIO_CDTEXT_GENRE_EASY_LISTENING = 9, /**< Easy Listening */
CDIO_CDTEXT_GENRE_EROTIC = 10, /**< Erotic */
CDIO_CDTEXT_GENRE_FOLK = 11, /**< Folk */
CDIO_CDTEXT_GENRE_GOSPEL = 12, /**< Gospel */
CDIO_CDTEXT_GENRE_HIPHOP = 13, /**< Hip Hop */
CDIO_CDTEXT_GENRE_JAZZ = 14, /**< Jazz */
CDIO_CDTEXT_GENRE_LATIN = 15, /**< Latin */
CDIO_CDTEXT_GENRE_MUSICAL = 16, /**< Musical */
CDIO_CDTEXT_GENRE_NEWAGE = 17, /**< New Age */
CDIO_CDTEXT_GENRE_OPERA = 18, /**< Opera */
CDIO_CDTEXT_GENRE_OPERETTA = 19, /**< Operetta */
CDIO_CDTEXT_GENRE_POP = 20, /**< Pop Music */
CDIO_CDTEXT_GENRE_RAP = 21, /**< RAP */
CDIO_CDTEXT_GENRE_REGGAE = 22, /**< Reggae */
CDIO_CDTEXT_GENRE_ROCK = 23, /**< Rock Music */
CDIO_CDTEXT_GENRE_RYTHMANDBLUES = 24, /**< Rhythm & Blues */
CDIO_CDTEXT_GENRE_SOUNDEFFECTS = 25, /**< Sound Effects */
CDIO_CDTEXT_GENRE_SOUNDTRACK = 26, /**< Soundtrack */
CDIO_CDTEXT_GENRE_SPOKEN_WORD = 27, /**< Spoken Word */
CDIO_CDTEXT_GENRE_WORLD_MUSIC = 28 /**< World Music */
} cdtext_genre_enum;
/*!
* CD-Text character codes
*/
@@ -192,36 +159,30 @@ PRAGMA_END_PACKED
/*
* content of BLOCKSIZE packs
*/
typedef struct CDText_blocksize
PRAGMA_BEGIN_PACKED
struct CDText_blocksize
{
uint8_t charcode; /* character code */
uint8_t i_firstTrack; /* first track number */
uint8_t i_lastTrack; /* last track number */
uint8_t i_first_track; /* first track number */
uint8_t i_last_track; /* last track number */
uint8_t copyright; /* cd-text information copyright byte */
uint8_t packcount[16];/* number of packs of each type
uint8_t i_packs[16];/* number of packs of each type
* 0 TITLE; 1 PERFORMER; 2 SONGWRITER; 3 COMPOSER;
* 4 ARRANGER; 5 MESSAGE; 6 DISCID; 7 GENRE;
* 8 TOC; 9 TOC2; 10-12 RESERVED; 13 CLOSED;
* 14 UPC_ISRC; 15 BLOCKSIZE */
uint8_t lastseq[8]; /* last sequence for block 0..7 */
uint8_t langcode[8]; /* language code for block 0..7 */
} CDText_blocksize_t;
} GNUC_PACKED;
PRAGMA_END_PACKED;
typedef struct CDText_blocksize CDText_blocksize_t;
typedef struct CDText_data CDText_data_t;
typedef void (*set_cdtext_field_fn_t) (void *user_data, track_t i_track,
track_t i_first_track,
cdtext_field_t field,
const char *buffer);
/*
Internal routine to parse all CD-TEXT data retrieved.
*/
bool cdtext_data_init(void *user_data, track_t i_first_track,
unsigned char *wdata, int i_data,
set_cdtext_field_fn_t set_cdtext_field_fn);
#endif /* __CDIO_CDTEXT_PRIVATE_H__ */

39
lib/driver/disc.c
View File

@@ -49,6 +49,45 @@ const char *discmode2str[] = {
"CD-i"
};
/*!
Get cdtext information for a CdIo object .
@param obj the CD object that may contain CD-TEXT information.
@return the CD-TEXT object or NULL if obj is NULL
or CD-TEXT information does not exist.
*/
cdtext_t *
cdio_get_cdtext (CdIo *obj)
{
if (obj == NULL) return NULL;
if (NULL != obj->op.get_cdtext) {
return obj->op.get_cdtext (obj->env);
} else {
return NULL;
}
}
/*!
Get binary cdtext information for a CdIo object .
@param obj the CD object that may contain CD-TEXT information.
@return pointer to allocated memory area holding the raw CD-TEXT
or NULL if obj is NULL or CD-TEXT does not exist.
free() when done.
*/
uint8_t *
cdio_get_cdtext_raw (CdIo *obj)
{
if (obj == NULL) return NULL;
if (NULL != obj->op.get_cdtext_raw) {
return obj->op.get_cdtext_raw (obj->env);
} else {
return NULL;
}
}
/*!
Get the size of the CD in logical block address (LBA) units.

11
lib/driver/generic.h
View File

@@ -43,7 +43,6 @@ extern "C" {
char *source_name; /**< Name used in open. */
bool init; /**< True if structure has been initialized */
bool toc_init; /**< True if TOC read in */
bool b_cdtext_init; /**< True if CD-Text read in */
bool b_cdtext_error; /**< True if trouble reading CD-Text */
int ioctls_debugged; /**< for debugging */
@@ -62,8 +61,7 @@ extern "C" {
iso9660_pvd_t pvd;
iso9660_svd_t svd;
CdIo_t *cdio; /**< a way to call general cdio routines. */
cdtext_t cdtext; /**< CD-Text for disc. */
cdtext_t cdtext_track[CDIO_CD_MAX_TRACKS+1]; /**< CD-TEXT for each track*/
cdtext_t *cdtext; /**< CD-Text for disc. */
track_flags_t track_flags[CDIO_CD_MAX_TRACKS+1];
/* Memorized sense reply of the most recent SCSI command.
@@ -177,7 +175,7 @@ extern "C" {
@return the CD-TEXT object or NULL if obj is NULL
or CD-TEXT information does not exist.
*/
cdtext_t *get_cdtext_generic (void *p_user_data, track_t i_track);
cdtext_t *get_cdtext_generic (void *p_user_data);
/*!
Return the number of of the first track.
@@ -220,16 +218,13 @@ extern "C" {
track_flag_t get_track_preemphasis_generic(const void *p_user_data,
track_t i_track);
void set_cdtext_field_generic(void *user_data, track_t i_track,
track_t i_first_track,
cdtext_field_t e_field, const char *psz_value);
/*!
Read cdtext information for a CdIo object .
return true on success, false on error or CD-Text information does
not exist.
*/
bool init_cdtext_generic (generic_img_private_t *p_env);
uint8_t * read_cdtext_generic (void *p_env);
void set_track_flags(track_flags_t *p_track_flag, uint8_t flag);

2
lib/driver/gnu_linux.c
View File

@@ -1685,6 +1685,7 @@ cdio_open_am_linux (const char *psz_orig_source, const char *access_mode)
.get_arg = get_arg_linux,
.get_blocksize = get_blocksize_mmc,
.get_cdtext = get_cdtext_generic,
.get_cdtext_raw = read_cdtext_generic,
.get_default_device = cdio_get_default_device_linux,
.get_devices = cdio_get_devices_linux,
.get_disc_last_lsn = get_disc_last_lsn_linux,
@@ -1736,7 +1737,6 @@ cdio_open_am_linux (const char *psz_orig_source, const char *access_mode)
_data->gen.init = false;
_data->gen.toc_init = false;
_data->gen.fd = -1;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source) {

1
lib/driver/image.h
View File

@@ -63,7 +63,6 @@ typedef struct {
*/
track_format_t track_format;
bool track_green;
cdtext_t cdtext; /**< CD-TEXT */
trackmode_t mode;
uint16_t datasize; /**< How much is in the portion we return

1
lib/driver/image/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/*~

75
lib/driver/image/bincue.c
View File

@@ -87,8 +87,6 @@ _init_bincue (_img_private_t *p_env)
p_env->psz_mcn = NULL;
p_env->disc_mode = CDIO_DISC_MODE_NO_INFO;
cdtext_init (&(p_env->gen.cdtext));
lead_lsn = get_disc_last_lsn_bincue( (_img_private_t *) p_env);
if (-1 == lead_lsn) return false;
@@ -268,8 +266,6 @@ parse_cuefile (_img_private_t *cd, const char *psz_cue_name)
if (cd) {
cd->gen.i_tracks=0;
cd->gen.i_first_track=1;
cd->gen.b_cdtext_init = true;
cd->gen.b_cdtext_error = false;
cd->psz_mcn=NULL;
}
@@ -326,6 +322,52 @@ parse_cuefile (_img_private_t *cd, const char *psz_cue_name)
} else {
goto not_in_global_section;
}
/* CDTEXTFILE "<filename>" */
} else if (0 == strcmp ("CDTEXTFILE", psz_keyword)) {
if(NULL != (psz_field = strtok (NULL, "\"\t\n\r"))) {
if (cd) {
uint8_t cdt_data[MAX_CDTEXT_DATA_LENGTH+4];
int size;
int i;
CdioDataSource_t *source;
if(NULL == (source = cdio_stdio_new(psz_field))) {
cdio_log (log_level, "%s line %d: can't open file `%s' for reading", psz_cue_name, i_line, psz_field);
goto err_exit;
}
size = cdio_stream_read(source, cdt_data, MAX_CDTEXT_DATA_LENGTH, 1);
if (size < 4) {
cdio_log (log_level, "%s line %d: file `%s' is too small to contain CD-TEXT", psz_cue_name, i_line, psz_field);
goto err_exit;
}
/* prepend data length if not yet present */
if (cdt_data[0] >= 0x80) {
for(i=size-1; i >=0; i--)
cdt_data[i+4] = cdt_data[i];
cdt_data[0] = (size+2) << 8;
cdt_data[1] = (size+2) & 0xff;
cdt_data[2] = 0x00;
cdt_data[3] = 0x00;
}
/* init cdtext */
if (NULL == cd->gen.cdtext) {
cd->gen.cdtext = malloc(sizeof(cdtext_t));
cdtext_init (cd->gen.cdtext);
}
if(!cdtext_data_init(cd->gen.cdtext, cdt_data))
cdio_log (log_level, "%s line %d: failed to parse CD-TEXT file `%s'", psz_cue_name, i_line, psz_field);
cdio_stdio_destroy (source);
}
} else {
goto format_error;
}
/* FILE "<filename>" <BINARY|WAVE|other?> */
} else if (0 == strcmp ("FILE", psz_keyword)) {
@@ -357,7 +399,6 @@ parse_cuefile (_img_private_t *cd, const char *psz_cue_name)
this_track->track_num = cd->gen.i_tracks;
this_track->num_indices = 0;
b_first_index_for_track = false;
cdtext_init (&(cd->gen.cdtext_track[cd->gen.i_tracks]));
cd->gen.i_tracks++;
}
i++;
@@ -728,18 +769,15 @@ parse_cuefile (_img_private_t *cd, const char *psz_cue_name)
/* CD-Text */
} else if ( CDTEXT_INVALID !=
(cdtext_key = cdtext_is_keyword (psz_keyword)) ) {
if (-1 == i) {
if (cd) {
cdtext_set (cdtext_key,
strtok (NULL, "\"\t\n\r"),
&(cd->gen.cdtext));
}
} else {
if (cd) {
cdtext_set (cdtext_key, strtok (NULL, "\"\t\n\r"),
&(cd->gen.cdtext_track[i]));
}
}
if (cd) {
if (NULL == cd->gen.cdtext) {
cd->gen.cdtext = malloc(sizeof(cdtext_t));
cdtext_init (cd->gen.cdtext);
}
cdtext_set (cdtext_key,
(-1 == i ? 0 : cd->gen.i_first_track + i + 1),
strtok (NULL, "\"\t\n\r"), cd->gen.cdtext);
}
/* unrecognized line */
} else {
@@ -1138,7 +1176,8 @@ cdio_open_cue (const char *psz_cue_name)
_funcs.eject_media = _eject_media_image;
_funcs.free = _free_image;
_funcs.get_arg = _get_arg_image;
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext = _get_cdtext_image;
_funcs.get_cdtext_raw = NULL;
_funcs.get_devices = cdio_get_devices_bincue;
_funcs.get_default_device = cdio_get_default_device_bincue;
_funcs.get_disc_last_lsn = get_disc_last_lsn_bincue;

30
lib/driver/image/cdrdao.c
View File

@@ -108,8 +108,6 @@ _init_cdrdao (_img_private_t *env)
env->psz_mcn = NULL;
env->disc_mode = CDIO_DISC_MODE_NO_INFO;
cdtext_init (&(env->gen.cdtext));
/* Read in TOC sheet. */
if ( !parse_tocfile(env, env->psz_cue_name) ) return false;
@@ -292,7 +290,6 @@ parse_tocfile (_img_private_t *cd, const char *psz_cue_name)
}
if (cd) {
cd->gen.b_cdtext_init = true;
cd->gen.b_cdtext_error = false;
}
@@ -375,7 +372,6 @@ parse_tocfile (_img_private_t *cd, const char *psz_cue_name)
/* TRACK <track-mode> [<sub-channel-mode>] */
} else if (0 == strcmp ("TRACK", psz_keyword)) {
i++;
if (NULL != cd) cdtext_init (&(cd->gen.cdtext_track[i]));
if (NULL != (psz_field = strtok (NULL, " \t\n\r"))) {
if (0 == strcmp ("AUDIO", psz_field)) {
if (NULL != cd) {
@@ -911,19 +907,16 @@ parse_tocfile (_img_private_t *cd, const char *psz_cue_name)
if (i_cdtext_nest > 0) i_cdtext_nest--;
} else if ( CDTEXT_INVALID !=
(cdtext_key = cdtext_is_keyword (psz_keyword)) ) {
if (-1 == i) {
if (NULL != cd) {
cdtext_set (cdtext_key,
strtok (NULL, "\"\t\n\r"),
&(cd->gen.cdtext));
}
} else {
if (NULL != cd) {
cdtext_set (cdtext_key,
strtok (NULL, "\"\t\n\r"),
&(cd->gen.cdtext_track[i]));
}
}
if (NULL != cd) {
if (NULL == cd->gen.cdtext) {
cd->gen.cdtext = malloc(sizeof(cdtext_t));
cdtext_init (cd->gen.cdtext);
}
cdtext_set (cdtext_key,
(-1 == i ? 0 : cd->gen.i_first_track + i + 1),
strtok (NULL, "\"\t\n\r"),
cd->gen.cdtext);
}
/* unrecognized line */
} else {
@@ -1261,7 +1254,8 @@ cdio_open_cdrdao (const char *psz_cue_name)
_funcs.eject_media = _eject_media_image;
_funcs.free = _free_image;
_funcs.get_arg = _get_arg_image;
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext = _get_cdtext_image;
_funcs.get_cdtext_raw = NULL;
_funcs.get_devices = cdio_get_devices_cdrdao;
_funcs.get_default_device = cdio_get_default_device_cdrdao;
_funcs.get_disc_last_lsn = get_disc_last_lsn_cdrdao;

19
lib/driver/image/nrg.c
View File

@@ -43,6 +43,7 @@
#include "cdio_assert.h"
#include "_cdio_stdio.h"
#include "nrg.h"
#include "cdtext_private.h"
static const char _rcsid[] = "$Id: nrg.c,v 1.31 2008/04/21 18:30:22 karl Exp $";
@@ -431,7 +432,6 @@ parse_nrg (_img_private_t *p_env, const char *psz_nrg_name,
}
if (0 == disc_mode) {
for (i=0; i<p_env->gen.i_tracks; i++) {
cdtext_init (&(p_env->gen.cdtext_track[i]));
p_env->tocent[i].track_format= track_format;
p_env->tocent[i].datastart = 0;
p_env->tocent[i].track_green = false;
@@ -446,7 +446,6 @@ parse_nrg (_img_private_t *p_env, const char *psz_nrg_name,
}
} else if (2 == disc_mode) {
for (i=0; i<p_env->gen.i_tracks; i++) {
cdtext_init (&(p_env->gen.cdtext_track[i]));
p_env->tocent[i].track_green = true;
p_env->tocent[i].track_format= track_format;
p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE;
@@ -749,7 +748,15 @@ parse_nrg (_img_private_t *p_env, const char *psz_nrg_name,
uint8_t *wdata = (uint8_t *) chunk->data;
int len = UINT32_FROM_BE (chunk->len);
cdio_assert (len % sizeof (CDText_data_t) == 0);
cdtext_data_init (&p_env->gen, p_env->gen.i_first_track, &wdata[-4], len, set_cdtext_field_generic);
p_env->gen.cdtext = malloc(sizeof(cdtext_t));
cdtext_init (p_env->gen.cdtext);
if(!cdtext_data_init (p_env->gen.cdtext, &wdata[-4]))
{
cdtext_destroy(p_env->gen.cdtext);
free(p_env->gen.cdtext);
p_env->gen.cdtext = NULL;
}
break;
}
@@ -777,7 +784,6 @@ parse_nrg (_img_private_t *p_env, const char *psz_nrg_name,
p_env->tocent[p_env->gen.i_tracks-1].sec_count =
cdio_lsn_to_lba(p_env->size - p_env->tocent[p_env->gen.i_tracks-1].start_lba);
p_env->gen.b_cdtext_init = true;
p_env->gen.b_cdtext_error = false;
p_env->gen.toc_init = true;
free(footer_buf);
@@ -804,8 +810,6 @@ _init_nrg (_img_private_t *p_env)
p_env->psz_mcn = NULL;
p_env->disc_mode = CDIO_DISC_MODE_NO_INFO;
cdtext_init (&(p_env->gen.cdtext));
if ( !parse_nrg (p_env, p_env->gen.source_name, CDIO_LOG_WARN) ) {
cdio_warn ("image file %s is not a Nero image",
p_env->gen.source_name);
@@ -1276,7 +1280,8 @@ cdio_open_nrg (const char *psz_source)
_funcs.eject_media = _eject_media_nrg;
_funcs.free = _free_nrg;
_funcs.get_arg = _get_arg_image;
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext = _get_cdtext_image;
_funcs.get_cdtext_raw = NULL;
_funcs.get_devices = cdio_get_devices_nrg;
_funcs.get_default_device = cdio_get_default_device_nrg;
_funcs.get_disc_last_lsn = get_disc_last_lsn_nrg;

17
lib/driver/image_common.c
View File

@@ -63,14 +63,13 @@ _free_image (void *p_user_data)
track_info_t *p_tocent = &(p_env->tocent[i_track]);
free_if_notnull(p_tocent->filename);
free_if_notnull(p_tocent->isrc);
cdtext_destroy(&(p_tocent->cdtext));
if (p_tocent->data_source) cdio_stdio_destroy(p_tocent->data_source);
}
free_if_notnull(p_env->psz_mcn);
free_if_notnull(p_env->psz_cue_name);
free_if_notnull(p_env->psz_access_mode);
cdtext_destroy(&(p_env->gen.cdtext));
cdtext_destroy(p_env->gen.cdtext);
cdio_generic_stdio_free(p_env);
free(p_env);
}
@@ -95,6 +94,20 @@ _get_arg_image (void *user_data, const char key[])
return NULL;
}
/*!
Return CD-Text object
*/
cdtext_t *
_get_cdtext_image (void *user_data)
{
generic_img_private_t *p_env = user_data;
if(!p_env)
return NULL;
return p_env->cdtext;
}
/*!
Get disc type associated with cd_obj.
*/

5
lib/driver/image_common.h
View File

@@ -78,6 +78,11 @@ int _eject_media_image(void *p_user_data);
*/
const char * _get_arg_image (void *user_data, const char key[]);
/*!
Return CD-Text object or NULL
*/
cdtext_t * _get_cdtext_image(void *p_user_data);
/*!
Get disc type associated with cd_obj.
*/

2
lib/driver/libcdio.sym
View File

@@ -42,6 +42,7 @@ cdio_free_device_list
cdio_from_bcd8
cdio_get_arg
cdio_get_cdtext
cdio_get_cdtext_raw
cdio_get_default_device
cdio_get_default_device_bincue
cdio_get_default_device_bsdi
@@ -179,6 +180,7 @@ cdio_version_string
cdio_warn
cdtext_destroy
cdtext_field2str
cdtext_genre2str
cdtext_get
cdtext_get_const
cdtext_init

34
lib/driver/mmc/mmc.c
View File

@@ -324,16 +324,15 @@ mmc_get_mcn_private ( void *p_env,
return true on success, false on error or CD-Text information does
not exist.
*/
bool
mmc_init_cdtext_private ( void *p_user_data,
const mmc_run_cmd_fn_t run_mmc_cmd,
set_cdtext_field_fn_t set_cdtext_field_fn
uint8_t *
mmc_read_cdtext_private ( void *p_user_data,
const mmc_run_cmd_fn_t run_mmc_cmd
)
{
generic_img_private_t *p_env = p_user_data;
mmc_cdb_t cdb = {{0, }};
unsigned char wdata[5000] = { 0, };
unsigned char * wdata;
int i_status, i_errno;
if ( ! p_env || ! run_mmc_cmd || p_env->b_cdtext_error )
@@ -351,38 +350,45 @@ mmc_init_cdtext_private ( void *p_user_data,
errno = 0;
wdata = calloc(MAX_CDTEXT_DATA_LENGTH, sizeof(unsigned char));
/* We may need to give CD-Text a little more time to complete. */
/* First off, just try and read the size */
i_status = run_mmc_cmd (p_env, mmc_read_timeout_ms,
mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ,
4, &wdata);
4, wdata);
if (i_status != 0) {
cdio_info ("CD-Text read failed for header: %s\n", strerror(errno));
i_errno = errno;
i_errno = errno;
p_env->b_cdtext_error = true;
return false;
free(wdata);
return NULL;
} else {
/* Now read the CD-Text data */
int i_cdtext = CDIO_MMC_GET_LEN16(wdata);
if (i_cdtext > sizeof(wdata)) i_cdtext = sizeof(wdata);
if (i_cdtext+2 > 5000)
i_cdtext = MAX_CDTEXT_DATA_LENGTH-2;
else
wdata = realloc(wdata,i_cdtext+2);
/* the 2 bytes holding the size are not included in i_cdtext */
CDIO_MMC_SET_READ_LENGTH16(cdb.field, i_cdtext);
i_status = run_mmc_cmd (p_env, mmc_read_timeout_ms,
mmc_get_cmd_len(cdb.field[0]),
&cdb, SCSI_MMC_DATA_READ,
i_cdtext, &wdata);
i_cdtext, wdata);
if (i_status != 0) {
cdio_info ("CD-Text read for text failed: %s\n", strerror(errno));
i_errno = errno;
p_env->b_cdtext_error = true;
return false;
free(wdata);
return NULL;
}
p_env->b_cdtext_init = true;
return cdtext_data_init(p_env, p_env->i_first_track, wdata, i_cdtext-2,
set_cdtext_field_fn);
return wdata;
}
}

6
lib/driver/mmc/mmc_private.h
View File

@@ -16,7 +16,6 @@
*/
#include <cdio/mmc.h>
#include "cdtext_private.h"
/*! Convert milliseconds to seconds taking the ceiling value, i.e.
1002 milliseconds gets rounded to 2 seconds.
@@ -131,9 +130,8 @@ char *mmc_get_mcn_private ( void *p_env,
mmc_run_cmd_fn_t run_mmc_cmd
);
bool mmc_init_cdtext_private ( void *p_user_data,
mmc_run_cmd_fn_t run_mmc_cmd,
set_cdtext_field_fn_t set_cdtext_field_fn
uint8_t * mmc_read_cdtext_private ( void *p_user_data,
mmc_run_cmd_fn_t run_mmc_cmd
);
/*!

2
lib/driver/netbsd.c
View File

@@ -558,6 +558,7 @@ static cdio_funcs_t _funcs = {
.get_arg = get_arg_netbsd,
.get_blocksize = get_blocksize_mmc,
.get_cdtext = get_cdtext_generic,
.get_cdtext_raw = read_cdtext_generic,
.get_default_device = cdio_get_default_device_netbsd,
.get_devices = cdio_get_devices_netbsd,
.get_disc_last_lsn = get_disc_last_lsn_netbsd,
@@ -601,6 +602,7 @@ cdio_open_netbsd(const char *source_name)
_img_private_t *_data;
_data = calloc(1, sizeof(_img_private_t));
_data->gen.b_cdtext_error = false;
_data->gen.init = false;
_data->gen.fd = -1;
_data->toc_valid = false;

4
lib/driver/os2.c
View File

@@ -650,8 +650,6 @@ init_os2 (void *p_user_data)
p_env->gen.init = true;
p_env->gen.toc_init = false;
p_env->gen.b_cdtext_init = false;
p_env->gen.b_cdtext_error = false;
p_env->gen.fd = p_env->h_cd;
return true;
@@ -1447,6 +1445,7 @@ cdio_open_os2 (const char *psz_orig_source)
_funcs.get_blocksize = get_blocksize_os2;
#endif
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext_raw = read_cdtext_generic;
_funcs.get_default_device = cdio_get_default_device_os2;
_funcs.get_devices = cdio_get_devices_os2;
_funcs.get_disc_last_lsn = get_disc_last_lsn_os2;
@@ -1487,6 +1486,7 @@ cdio_open_os2 (const char *psz_orig_source)
_data = calloc(1, sizeof (_img_private_t));
_data->access_mode = _AM_OS2;
_data->gen.b_cdtext_error = false;
_data->gen.init = false;
_data->gen.fd = -1;

19
lib/driver/osx.c
View File

@@ -856,20 +856,6 @@ get_hwinfo_osx ( const CdIo_t *p_cdio, /*out*/ cdio_hwinfo_t *hw_info)
}
#endif
/*
Get cdtext information in p_user_data for track i_track.
For disc information i_track is 0.
Return the CD-TEXT or NULL if obj is NULL,
CD-TEXT information does not exist, or (as is the case here)
we don't know how to get this implemented.
*/
static cdtext_t *
get_cdtext_osx (void *p_user_data, track_t i_track)
{
return NULL;
}
static void
_free_osx (void *p_user_data) {
_img_private_t *p_env = p_user_data;
@@ -1893,7 +1879,8 @@ cdio_open_osx (const char *psz_orig_source)
.eject_media = _eject_media_osx,
.free = _free_osx,
.get_arg = _get_arg_osx,
.get_cdtext = get_cdtext_osx,
.get_cdtext = NULL,
.get_cdtext_raw = NULL,
.get_default_device = cdio_get_default_device_osx,
.get_devices = cdio_get_devices_osx,
.get_disc_last_lsn = get_disc_last_lsn_osx,
@@ -1930,8 +1917,6 @@ cdio_open_osx (const char *psz_orig_source)
_data->gen.init = false;
_data->gen.fd = -1;
_data->gen.toc_init = false;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source) {
psz_source=cdio_get_default_device_osx();

2
lib/driver/solaris.c
View File

@@ -1380,6 +1380,7 @@ cdio_open_am_solaris (const char *psz_orig_source, const char *access_mode)
_funcs.get_blocksize = get_blocksize_solaris;
#endif
_funcs.get_cdtext = get_cdtext_generic;
_funcs.get_cdtext_raw = read_cdtext_generic;
_funcs.get_default_device = cdio_get_default_device_solaris;
_funcs.get_devices = cdio_get_devices_solaris;
_funcs.get_disc_last_lsn = get_disc_last_lsn_solaris;
@@ -1422,7 +1423,6 @@ cdio_open_am_solaris (const char *psz_orig_source, const char *access_mode)
_data->gen.init = false;
_data->gen.fd = -1;
_data->gen.toc_init = false;
_data->gen.b_cdtext_init = false;
_data->gen.b_cdtext_error = false;
if (NULL == psz_orig_source) {