fabs/cuetools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

imported sources

Browse Source
This commit is contained in:
Svend Sorensen
2004-06-24 23:32:16 +00:00
commit 2b85ca2167
34 changed files with 3711 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
lib/Makefile Normal file
View File

@@ -0,0 +1,44 @@
YFLAGS+= -d
OBJS= cd.o cdtext.o time.o cuefile.o
CUE_OBJS= cue_parse.o cue_scan.o cue_print.o
TOC_OBJS= toc_parse.o toc_scan.o toc_print.o
toc_scan.c: LFLAGS+= -Ptoc_yy
cue_scan.c: LFLAGS+= -Pcue_yy
toc_parse.c: YFLAGS+= -p toc_yy
cue_parse.c: YFLAGS+= -p cue_yy
TARGETS= libcuefile.a
all: $(TARGETS)
libcuefile.a: libcuefile.a($(OBJS) $(CUE_OBJS) $(TOC_OBJS))
%.c: %.y
$(YACC) -o $@ $(YFLAGS) $<
install: all
uninstall:
clean:
rm -f $(TARGETS)
rm -f *.o *.a *.core *.output
rm -f toc_scan.c toc_parse.c toc_parse.h
rm -f cue_scan.c cue_parse.c cue_parse.h
# dependancies
# generated with `gcc -MM *.c'
# after building lex and yacc .c files
cd.o: cd.c cd.h cdtext.h
cdtext.o: cdtext.c cdtext.h
cuefile.o: cuefile.c cuefile.h cd.h cdtext.h cue.h toc.h
cue_parse.o: cue_parse.c cd.h cdtext.h time.h
cue_print.o: cue_print.c cd.h cdtext.h time.h
cue_scan.o: cue_scan.c cd.h cdtext.h cue_parse.h
time.o: time.c
toc_parse.o: toc_parse.c cd.h cdtext.h time.h
toc_print.o: toc_print.c cd.h cdtext.h time.h
toc_scan.o: toc_scan.c cd.h cdtext.h toc_parse.h

329
lib/cd.c Normal file
View File

@@ -0,0 +1,329 @@
/*
* cd.c -- cd functions
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cd.h"
typedef struct Data Data;
struct Data {
int type; /* DataType */
char *name; /* data source name */
long start; /* start time for data */
long length; /* length of data */
};
struct Track {
Data zero_pre; /* pre-gap generated with zero data */
Data file; /* track data file */
Data zero_post; /* post-gap generated with zero data */
int mode; /* track mode */
int sub_mode; /* sub-channel mode */
int flags; /* flags */
char *isrc; /* IRSC Code (5.22.4) 12 bytes */
Cdtext *cdtext; /* CD-TEXT */
int nindex; /* number of indexes */
long index[MAXINDEX]; /* indexes (in frames) (5.29.2.5)
* relative to start of track
* index[0] should always be zero */
};
struct Cd {
int mode; /* disc mode */
char *catalog; /* Media Catalog Number (5.22.3) */
Cdtext *cdtext; /* CD-TEXT */
int ntrack; /* number of tracks in album */
Track *track[MAXTRACK]; /* array of tracks */
};
Cd *cd_init ()
{
Cd *cd = NULL;
cd = malloc(sizeof(Cd));
if(NULL == cd) {
fprintf(stderr, "unable to create cd\n");
} else {
cd->mode = MODE_CD_DA;
cd->catalog = NULL;
cd->cdtext = cdtext_init();
cd->ntrack = 0;
}
return cd;
}
Track *track_init ()
{
Track *track = NULL;
track = malloc(sizeof(Track));
if (NULL == track) {
fprintf(stderr, "unable to create track\n");
} else {
track->zero_pre.type = DATA_ZERO;
track->zero_pre.name = NULL;
track->zero_pre.start = 0;
track->zero_pre.length = 0;
track->file.type = DATA_AUDIO;
track->file.name = NULL;
track->file.start = 0;
track->file.length = 0;
track->zero_post.type = DATA_ZERO;
track->zero_post.name = NULL;
track->zero_post.start = 0;
track->zero_post.length = 0;
track->mode = MODE_AUDIO;
track->sub_mode = SUB_MODE_RW;
track->flags = FLAG_NONE;
track->isrc = NULL;
track->cdtext = cdtext_init();
track->nindex = 0;
}
return track;
}
/*
* cd structure functions
*/
void cd_set_mode (Cd *cd, int mode)
{
cd->mode = mode;
}
int cd_get_mode (Cd *cd)
{
return cd->mode;
}
void cd_set_catalog (Cd *cd, char *catalog)
{
if (cd->catalog)
free(cd->catalog);
cd->catalog = strdup(catalog);
}
char *cd_get_catalog (Cd *cd)
{
return cd->catalog;
}
Cdtext *cd_get_cdtext (Cd *cd)
{
return cd->cdtext;
}
Track *cd_add_track (Cd *cd)
{
if (MAXTRACK - 1 > cd->ntrack)
cd->ntrack++;
else
fprintf(stderr, "too many tracks\n");
/* this will reinit last track if there were too many */
cd->track[cd->ntrack - 1] = track_init();
return cd->track[cd->ntrack - 1];
}
int cd_get_ntrack (Cd *cd)
{
return cd->ntrack;
}
Track *cd_get_track (Cd *cd, int i)
{
if (0 < i <= cd->ntrack)
return cd->track[i - 1];
return NULL;
}
/*
* track structure functions
*/
void track_set_filename (Track *track, char *filename)
{
if (track->file.name)
free(track->file.name);
track->file.name = strdup(filename);
}
char *track_get_filename (Track *track)
{
return track->file.name;
}
void track_set_start (Track *track, long start)
{
track->file.start = start;
}
long track_get_start (Track *track)
{
return track->file.start;
}
void track_set_length (Track *track, long length)
{
track->file.length = length;
}
long track_get_length (Track *track)
{
return track->file.length;
}
void track_set_mode (Track *track, int mode)
{
track->mode = mode;
}
int track_get_mode (Track *track)
{
return track->mode;
}
void track_set_sub_mode (Track *track, int sub_mode)
{
track->sub_mode = sub_mode;
}
int track_get_sub_mode (Track *track)
{
return track->sub_mode;
}
void track_set_flag (Track *track, int flag)
{
track->flags |= flag;
}
void track_clear_flag (Track *track, int flag)
{
track->flags &= ~flag;
}
int track_is_set_flag (Track *track, int flag)
{
return track->flags & flag;
}
void track_set_zero_pre (Track *track, long length)
{
track->zero_pre.length = length;
}
long track_get_zero_pre (Track *track)
{
return track->zero_pre.length;
}
void track_set_zero_post (Track *track, long length)
{
track->zero_post.length = length;
}
long track_get_zero_post (Track *track)
{
return track->zero_post.length;
}
void track_set_isrc (Track *track, char *isrc)
{
if (track->isrc)
free(track->isrc);
track->isrc = strdup(isrc);
}
char *track_get_isrc (Track *track)
{
return track->isrc;
}
Cdtext *track_get_cdtext (Track *track)
{
return track->cdtext;
}
void track_add_index (Track *track, long index)
{
if (MAXTRACK - 1 > track->nindex)
track->nindex++;
else
fprintf(stderr, "too many indexes\n");
/* this will overwrite last index if there were too many */
track->index[track->nindex - 1] = index;
}
int track_get_nindex (Track *track)
{
return track->nindex;
}
long track_get_index (Track *track, int i)
{
if (0 <= i < track->nindex)
return track->index[i];
return -1;
}
/*
* dump cd information
*/
void cd_track_dump (Track *track)
{
int i;
printf("zero_pre: %ld\n", track->zero_pre.length);
printf("filename: %s\n", track->file.name);
printf("start: %ld\n", track->file.start);
printf("length: %ld\n", track->file.length);
printf("zero_post: %ld\n", track->zero_post.length);
printf("mode: %d\n", track->mode);
printf("sub_mode: %d\n", track->sub_mode);
printf("flags: 0x%x\n", track->flags);
printf("isrc: %s\n", track->isrc);
printf("indexes: %d\n", track->nindex);
for (i = 0; i < track->nindex; ++i)
printf("index %d: %ld\n", i, track->index[i]);
if (NULL != track->cdtext) {
printf("cdtext:\n");
/* cdtext_print(stdout, track->cdtext); */
}
}
void cd_dump (Cd *cd)
{
int i;
printf("Disc Info\n");
printf("mode: %d\n", cd->mode);
printf("catalog: %s\n", cd->catalog);
if (NULL != cd->cdtext) {
printf("cdtext:\n");
/* cdtext_print(stdout, cd->cdtext); */
}
for (i = 0; i < cd->ntrack; ++i) {
printf("Track %d Info\n", i + 1);
cd_track_dump(cd->track[i]);
}
}

147
lib/cd.h Normal file
View File

@@ -0,0 +1,147 @@
/*
* cd.h -- cd structure
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
/* references: MMC-3 draft revsion - 10g */
#ifndef CD_H
#define CD_H
#include "cdtext.h"
#define MAXTRACK 99 /* Red Book track limit */
#define MAXINDEX 99 /* Red Book index limit */
/*
* disc modes
* DATA FORM OF MAIN DATA (5.29.2.8)
*/
enum DiscMode {
MODE_CD_DA, /* CD-DA */
MODE_CD_ROM, /* CD-ROM mode 1 */
MODE_CD_ROM_XA /* CD-ROM XA and CD-I */
};
/*
* track modes
* 5.29.2.8 DATA FORM OF MAIN DATA
* Table 350 - Data Block Type Codes
*/
enum TrackMode {
MODE_AUDIO, /* 2352 byte block length */
MODE_MODE1, /* 2048 byte block length */
MODE_MODE1_RAW, /* 2352 byte block length */
MODE_MODE2, /* 2336 byte block length */
MODE_MODE2_FORM1, /* 2048 byte block length */
MODE_MODE2_FORM2, /* 2324 byte block length */
MODE_MODE2_FORM_MIX, /* 2332 byte block length */
MODE_MODE2_RAW /* 2352 byte block length */
};
/*
* sub-channel mode
* 5.29.2.13 Data Form of Sub-channel
* NOTE: not sure if this applies to cue files
*/
enum TrackSubMode {
SUB_MODE_RW, /* RAW Data */
SUB_MODE_RW_RAW /* PACK DATA (written R-W */
};
/*
* track flags
* Q Sub-channel Control Field (4.2.3.3, 5.29.2.2)
*/
enum TrackFlag {
FLAG_NONE =0x00, /* no flags set */
FLAG_PRE_EMPHASIS =0x01, /* audio recorded with pre-emphasis */
FLAG_COPY_PERMITTED =0x02, /* digital copy permitted */
FLAG_DATA =0x04, /* data track */
FLAG_FOUR_CHANNEL =0x08, /* 4 audio channels */
FLAG_SCMS =0x10, /* SCMS (not Q Sub-ch.) (5.29.2.7) */
FLAG_ANY =0xff /* any flags set */
};
enum DataType {
DATA_AUDIO,
DATA_DATA,
DATA_FIFO,
DATA_ZERO
};
typedef struct Cd Cd;
typedef struct Track Track;
Cd *cd_init ();
void cd_dump (Cd *cd);
/*
* Cd functions
*/
void cd_set_mode (Cd *cd, int mode);
int cd_get_mode (Cd *cd);
void cd_set_catalog (Cd *cd, char *catalog);
char *cd_get_catalog (Cd *cd);
/*
* return pointer to cd's Cdtext
*/
Cdtext *cd_get_cdtext (Cd *cd);
/*
* add a new track to cd, increment number of tracks
* and return pointer to new track
*/
Track *cd_add_track (Cd *cd);
/*
* return number of tracks in cd
*/
int cd_get_ntrack (Cd *cd);
Track *cd_get_track (Cd *cd, int i);
/*
* Track functions
*/
void track_set_filename (Track *track, char *filename);
char *track_get_filename (Track *track);
void track_set_start (Track *track, long start);
long track_get_start (Track *track);
void track_set_length (Track *track, long length);
long track_get_length (Track *track);
void track_set_mode (Track *track, int mode);
int track_get_mode (Track *track);
void track_set_sub_mode (Track *track, int sub_mode);
int track_get_sub_mode (Track *track);
void track_set_flag (Track *track, int flag);
void track_clear_flag (Track *track, int flag);
int track_is_set_flag (Track *track, int flag);
void track_set_zero_pre (Track *track, long length);
long track_get_zero_pre (Track *track);
void track_set_zero_post (Track *track, long length);
long track_get_zero_post (Track *track);
void track_set_isrc (Track *track, char *isrc);
char *track_get_isrc (Track *track);
Cdtext *track_get_cdtext (Track *track);
void track_add_index (Track *track, long index);
int track_get_nindex (Track *track);
long track_get_index (Track *track, int i);
#endif

153
lib/cdtext.c Normal file
View File

@@ -0,0 +1,153 @@
/*
* cdtext.c -- cdtext data structure and functions
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cdtext.h"
struct Cdtext {
int pti;
int format;
char *value;
};
Cdtext *cdtext_init ()
{
Cdtext *new_cdtext = NULL;
Cdtext cdtext[] = {
{PTI_TITLE, FORMAT_CHAR, NULL},
{PTI_PERFORMER, FORMAT_CHAR, NULL},
{PTI_SONGWRITER, FORMAT_CHAR, NULL},
{PTI_COMPOSER, FORMAT_CHAR, NULL},
{PTI_ARRANGER, FORMAT_CHAR, NULL},
{PTI_MESSAGE, FORMAT_CHAR, NULL},
{PTI_DISC_ID, FORMAT_BINARY, NULL},
{PTI_GENRE, FORMAT_BINARY, NULL},
{PTI_TOC_INFO1, FORMAT_BINARY, NULL},
{PTI_TOC_INFO2, FORMAT_BINARY, NULL},
{PTI_RESERVED1, FORMAT_CHAR, NULL},
{PTI_RESERVED2, FORMAT_CHAR, NULL},
{PTI_RESERVED3, FORMAT_CHAR, NULL},
{PTI_RESERVED4, FORMAT_CHAR, NULL},
{PTI_UPC_ISRC, FORMAT_CHAR, NULL},
{PTI_SIZE_INFO, FORMAT_BINARY, NULL},
{PTI_END, FORMAT_CHAR, NULL}
};
new_cdtext = (Cdtext *) calloc (sizeof (cdtext) / sizeof (Cdtext), sizeof (Cdtext));
if (NULL == new_cdtext)
fprintf (stderr, "problem allocating memory\n");
else
memcpy (new_cdtext, cdtext, sizeof(cdtext));
return new_cdtext;
}
void cdtext_delete (Cdtext *cdtext)
{
int i;
if (NULL != cdtext) {
for (i = 0; PTI_END != cdtext[i].pti; i++)
free (cdtext[i].value);
free (cdtext);
}
}
/* return 0 if there is no cdtext, returns non-zero otherwise */
int cdtext_is_empty (Cdtext *cdtext)
{
for (; PTI_END != cdtext->pti; cdtext++)
if (NULL != cdtext->value)
return -1;
return 0;
}
/* sets cdtext's pti entry to field */
void cdtext_set (int pti, char *value, Cdtext *cdtext)
{
if (NULL != value) /* don't pass NULL to strdup */
for (; PTI_END != cdtext->pti; cdtext++)
if (pti == cdtext->pti) {
free (cdtext->value);
cdtext->value = strdup (value);
}
}
/* returns value for pti, NULL if pti is not found */
char *cdtext_get (int pti, Cdtext *cdtext)
{
for (; PTI_END != cdtext->pti; cdtext++)
if (pti == cdtext->pti)
return cdtext->value;
return NULL;
}
const char *cdtext_get_key (int pti, int istrack)
{
char *key = NULL;
switch (pti) {
case PTI_TITLE:
key = "TITLE";
break;
case PTI_PERFORMER:
key = "PERFORMER";
break;
case PTI_SONGWRITER:
key = "SONGWRITER";
break;
case PTI_COMPOSER:
key = "COMPOSER";
break;
case PTI_ARRANGER:
key = "ARRANGER";
break;
case PTI_MESSAGE:
key = "MESSAGE";
break;
case PTI_DISC_ID:
key = "DISC_ID";
break;
case PTI_GENRE:
key = "GENRE";
break;
case PTI_TOC_INFO1:
key = "TOC_INFO1";
break;
case PTI_TOC_INFO2:
key = "TOC_INFO1";
break;
case PTI_RESERVED1:
/* reserved */
break;
case PTI_RESERVED2:
/* reserved */
break;
case PTI_RESERVED3:
/* reserved */
break;
case PTI_RESERVED4:
/* reserved */
break;
case PTI_UPC_ISRC:
if (0 == istrack)
key = "UPC_EAN";
else
key = "ISRC";
break;
case PTI_SIZE_INFO:
key = "SIZE_INFO";
break;
}
return key;
}

65
lib/cdtext.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* cdtext.h
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
/* references: MMC-3 draft revsion - 10g */
#ifndef CDTEXT_H
#define CDTEXT_H
#include <stdio.h>
/* cdtext pack type indicators */
enum Pti {
PTI_TITLE, /* title of album or track titles */
PTI_PERFORMER, /* name(s) of the performer(s) */
PTI_SONGWRITER, /* name(s) of the songwriter(s) */
PTI_COMPOSER, /* name(s) of the composer(s) */
PTI_ARRANGER, /* name(s) of the arranger(s) */
PTI_MESSAGE, /* message(s) from the content provider and/or artist */
PTI_DISC_ID, /* (binary) disc identification information */
PTI_GENRE, /* (binary) genre identification and genre information */
PTI_TOC_INFO1, /* (binary) table of contents information */
PTI_TOC_INFO2, /* (binary) second table of contents information */
PTI_RESERVED1, /* reserved */
PTI_RESERVED2, /* reserved */
PTI_RESERVED3, /* reserved */
PTI_RESERVED4, /* reserved for content provider only */
PTI_UPC_ISRC, /* UPC/EAN code of the album and ISRC code of each track */
PTI_SIZE_INFO, /* (binary) size information of the block */
PTI_END /* terminating PTI (for stepping through PTIs) */
};
enum PtiFormat {
FORMAT_CHAR, /* single or double byte character string */
FORMAT_BINARY /* binary data */
};
typedef struct Cdtext Cdtext;
/* return a pointer to a new Cdtext */
Cdtext *cdtext_init ();
/* release a Cdtext */
void cdtext_delete (Cdtext *cdtext);
/* returns non-zero if there are no CD-TEXT fields set, zero otherwise */
int cdtext_is_empty (Cdtext *cdtext);
/* set CD-TEXT field to value for PTI pti */
void cdtext_set (int pti, char *value, Cdtext *cdtext);
/* returns pointer to CD-TEXT value for PTI pti */
char *cdtext_get (int pti, Cdtext *cdtext);
/*
* returns appropriate string for PTI pti
* if istrack is zero, UPC/EAN string will be returned for PTI_UPC_ISRC
* othwise ISRC string will be returned
*/
const char *cdtext_get_key (int pti, int istrack);
#endif

6
lib/cue.h Normal file
View File

@@ -0,0 +1,6 @@
/*
* cue.h -- cue function declarations
*/
Cd *cue_parse (FILE *fp);
void cue_print (FILE *fp, Cd *cd);

277
lib/cue_parse.y Normal file
View File

@@ -0,0 +1,277 @@
%{
/*
* cue_parse.y -- parser for cue files
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cd.h"
#include "time.h"
#define YYDEBUG 1
extern int cue_yylex();
void yyerror (char *s);
static Cd *cd = NULL;
static Track *track = NULL;
static Track *prev_track = NULL;
static Cdtext *cdtext = NULL;
static char *prev_filename = NULL; /* last file in or before last track */
static char *cur_filename = NULL; /* last file in the last track */
static char *new_filename = NULL; /* last file in this track */
%}
%start cuefile
%union {
long ival;
char *sval;
}
%token <ival> NUMBER
%token <sval> STRING
/* global (header) */
%token CATALOG
%token FFILE
%token BINARY
%token MOTOROLA
%token AIFF
%token WAVE
%token MP3
/* track */
%token TRACK
%token <ival> AUDIO
%token <ival> MODE1_2048
%token <ival> MODE1_2352
%token <ival> MODE2_2336
%token <ival> MODE2_2048
%token <ival> MODE2_2342
%token <ival> MODE2_2332
%token <ival> MODE2_2352
/* ISRC is with CD_TEXT */
%token TRACK_ISRC
%token FLAGS
%token <ival> PRE
%token <ival> DCP
%token <ival> FOUR_CH
%token <ival> SCMS
%token PREGAP
%token INDEX
%token POSTGAP
/* CD-TEXT */
%token <ival> TITLE
%token <ival> PERFORMER
%token <ival> SONGWRITER
%token <ival> COMPOSER
%token <ival> ARRANGER
%token <ival> MESSAGE
%token <ival> DISC_ID
%token <ival> GENRE
%token <ival> TOC_INFO1
%token <ival> TOC_INFO2
%token <ival> UPC_EAN
%token <ival> ISRC
%token <ival> SIZE_INFO
%type <ival> track_mode
%type <ival> track_flag
%type <ival> time
%type <ival> cdtext_item
%%
cuefile
: new_cd global_statements track_list
;
new_cd
: /* empty */ {
cd = cd_init();
cdtext = cd_get_cdtext(cd);
}
;
global_statements
: /* empty */
| global_statements global_statement
;
global_statement
: CATALOG STRING '\n' { cd_set_catalog(cd, $2); }
| cdtext
| track_data
| error '\n'
;
track_data
: FFILE STRING file_format '\n' {
if (NULL != new_filename) {
yyerror("too many files specified\n");
free(new_filename);
}
new_filename = strdup($2);
}
;
track_list
: track
| track_list track
;
track
: new_track track_def track_statements
;
file_format
: BINARY
| MOTOROLA
| AIFF
| WAVE
| MP3
;
new_track
: /*empty */ {
/* save previous track, to later set length */
prev_track = track;
track = cd_add_track(cd);
cdtext = track_get_cdtext(track);
cur_filename = new_filename;
if (NULL != cur_filename)
prev_filename = cur_filename;
if (NULL == prev_filename)
yyerror("no file specified for track");
else
track_set_filename(track, prev_filename);
new_filename = NULL;
}
;
track_def
: TRACK NUMBER track_mode '\n' {
track_set_mode(track, $3);
}
;
track_mode
: AUDIO
| MODE1_2048
| MODE1_2352
| MODE2_2336
| MODE2_2048
| MODE2_2342
| MODE2_2332
| MODE2_2352
;
track_statements
: track_statement
| track_statements track_statement
;
track_statement
: cdtext
| FLAGS track_flags '\n'
| TRACK_ISRC STRING '\n' { track_set_isrc(track, $2); }
| PREGAP time '\n' { track_set_zero_pre(track, $2); }
| INDEX NUMBER time '\n' {
int i = track_get_nindex(track);
long prev_length;
if (0 == i) {
/* first index */
track_set_start(track, $3);
if (NULL != prev_track && NULL == cur_filename) {
/* track shares file with previous track */
prev_length = $3 - track_get_start(prev_track);
track_set_length(prev_track, prev_length);
}
}
for (; i <= $2; i++)
track_add_index(track, \
track_get_zero_pre(track) + $3 \
- track_get_start(track));
}
| POSTGAP time '\n' { track_set_zero_post(track, $2); }
| track_data
| error '\n'
;
track_flags
: /* empty */
| track_flags track_flag { track_set_flag(track, $2); }
;
track_flag
: PRE
| DCP
| FOUR_CH
| SCMS
;
cdtext
: cdtext_item STRING '\n' { cdtext_set ($1, $2, cdtext); }
;
cdtext_item
: TITLE
| PERFORMER
| SONGWRITER
| COMPOSER
| ARRANGER
| MESSAGE
| DISC_ID
| GENRE
| TOC_INFO1
| TOC_INFO2
| UPC_EAN
| ISRC
| SIZE_INFO
;
time
: NUMBER
| NUMBER ':' NUMBER ':' NUMBER { $$ = time_msf_to_frame($1, $3, $5); }
;
%%
/* lexer interface */
extern int cue_lineno;
extern int cue_yydebug;
extern FILE *cue_yyin;
void yyerror (char *s)
{
fprintf(stderr, "%d: %s\n", cue_lineno, s);
}
Cd *cue_parse (FILE *fp)
{
cue_yyin = fp;
cue_yydebug = 0;
if (0 == cue_yyparse())
return cd;
return NULL;
}

146
lib/cue_print.c Normal file
View File

@@ -0,0 +1,146 @@
/*
* cue_print.y -- print cue file
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdio.h>
#include <string.h>
#include "cd.h"
#include "time.h"
void cue_print_track (FILE *fp, Track *track, int trackno);
void cue_print_cdtext (Cdtext *cdtext, FILE *fp, int istrack);
void cue_print_index (long i, FILE *fp);
char *filename = ""; /* last track datafile */
long prev_length = 0; /* last track length */
/* prints cd in cue format */
void cue_print (FILE *fp, Cd *cd)
{
Cdtext *cdtext = cd_get_cdtext(cd);
int i; /* track */
Track *track = NULL;
/* print global information */
if (NULL != cd_get_catalog(cd))
fprintf(fp, "CATALOG %s\n", cd_get_catalog(cd));
cue_print_cdtext(cdtext, fp, 0);
/* print track information */
for (i = 1; i <= cd_get_ntrack(cd); i++) {
track = cd_get_track(cd, i);
fprintf(fp, "\n");
cue_print_track(fp, track, i);
}
}
void cue_print_track (FILE *fp, Track *track, int trackno)
{
Cdtext *cdtext = track_get_cdtext(track);
int i; /* index */
if (NULL != track_get_filename(track)) {
/*
* always print filename for track 1, afterwards only
* print filename if it differs from the previous track
*/
if (0 != strcmp(track_get_filename(track), filename)) {
filename = track_get_filename(track);
fprintf(fp, "FILE \"%s\" ", filename);
/* NOTE: what to do with other formats (MP3, etc)? */
if (MODE_AUDIO == track_get_mode(track))
fprintf(fp, "WAVE\n");
else
fprintf(fp, "BINARY\n");
}
}
fprintf(fp, "TRACK %02d ", trackno);
switch (track_get_mode(track)) {
case MODE_AUDIO:
fprintf(fp, "AUDIO\n");
break;
case MODE_MODE1:
fprintf(fp, "MODE1/2048\n");
break;
case MODE_MODE1_RAW:
fprintf(fp, "MODE1/2352\n");
break;
case MODE_MODE2:
fprintf(fp, "MODE2/2048\n");
break;
case MODE_MODE2_FORM1:
fprintf(fp, "MODE2/2336\n");
break;
case MODE_MODE2_FORM2:
fprintf(fp, "MODE2/2324\n");
break;
case MODE_MODE2_FORM_MIX:
fprintf(fp, "MODE2/2336\n");
break;
case MODE_MODE2_RAW:
fprintf(fp, "MODE2/2352\n");
break;
}
cue_print_cdtext(cdtext, fp, 1);
if (0 != track_is_set_flag(track, FLAG_ANY)) {
fprintf(fp, "FLAGS");
if (0 != track_is_set_flag(track, FLAG_PRE_EMPHASIS))
fprintf(fp, " PRE");
if (0 != track_is_set_flag(track, FLAG_COPY_PERMITTED))
fprintf(fp, " DCP");
if (0 != track_is_set_flag(track, FLAG_FOUR_CHANNEL))
fprintf(fp, " 4CH");
if (0 != track_is_set_flag(track, FLAG_SCMS))
fprintf(fp, " SCMS");
fprintf(fp, "\n");
}
if (NULL != track_get_isrc(track))
fprintf(fp, "ISRC %s\n", track_get_isrc(track));
if (0 != track_get_zero_pre(track))
fprintf (fp, "PREGAP %s\n", time_frame_to_mmssff(track_get_zero_pre(track)));
/* don't print index 0 if index 1 = 0 */
if (track_get_index(track, 1) == 0)
i = 1;
else
i = 0;
for (; i < track_get_nindex(track); i++) {
fprintf(fp, "INDEX %02d ", i);
cue_print_index( \
track_get_index(track, i) \
+ track_get_start(track) \
- track_get_zero_pre(track) , fp);
}
if (0 != track_get_zero_post(track))
fprintf (fp, "POSTGAP %s\n", time_frame_to_mmssff(track_get_zero_post(track)));
prev_length = track_get_length(track);
}
void cue_print_cdtext (Cdtext *cdtext, FILE *fp, int istrack)
{
int pti;
char *value = NULL;
for (pti = 0; PTI_END != pti; pti++)
if (NULL != (value = cdtext_get(pti, cdtext))) {
fprintf(fp, "%s", cdtext_get_key(pti, istrack));
fprintf(fp, " \"%s\"\n", value);
}
}
void cue_print_index (long i, FILE *fp)
{
fprintf (fp, "%s\n", time_frame_to_mmssff(i));
}

94
lib/cue_scan.l Normal file
View File

@@ -0,0 +1,94 @@
%{
/*
* cue_scan.l -- lexer for cue files
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdlib.h>
#include <string.h>
#include "cd.h"
#include "cue_parse.h"
int cue_lineno = 1;
%}
ws [ \t\r]
nonws [^ \t\r\n]
%option noyywrap
%s NAME
%%
\"(\\.|[^\\"])*\" {
cue_yylval.sval = strdup(yytext + 1);
cue_yylval.sval[strlen(cue_yylval.sval) - 1] = '\0';
BEGIN(INITIAL);
return STRING;
}
<NAME>{nonws}+ {
cue_yylval.sval = strdup(yytext);
BEGIN(INITIAL);
return STRING;
}
CATALOG { BEGIN(NAME); return CATALOG; }
FILE { BEGIN(NAME); return FFILE; }
BINARY { return BINARY; }
MOTOROLA { return MOTOROLA; }
AIFF { return AIFF; }
WAVE { return WAVE; }
MP3 { return MP3; }
TRACK { return TRACK; }
AUDIO { cue_yylval.ival = MODE_AUDIO; return AUDIO; }
MODE1\/2048 { cue_yylval.ival = MODE_MODE1; return MODE1_2048; }
MODE1\/2352 { cue_yylval.ival = MODE_MODE1_RAW; return MODE1_2352; }
MODE2\/2336 { cue_yylval.ival = MODE_MODE2; return MODE2_2336; }
MODE2\/2048 { cue_yylval.ival = MODE_MODE2_FORM1; return MODE2_2048; }
MODE2\/2342 { cue_yylval.ival = MODE_MODE2_FORM2; return MODE2_2342; }
MODE2\/2332 { cue_yylval.ival = MODE_MODE2_FORM_MIX; return MODE2_2332; }
MODE2\/2352 { cue_yylval.ival = MODE_MODE2_RAW; return MODE2_2352; }
FLAGS { return FLAGS; }
PRE { cue_yylval.ival = FLAG_PRE_EMPHASIS; return PRE; }
DCP { cue_yylval.ival = FLAG_COPY_PERMITTED; return DCP; }
4CH { cue_yylval.ival = FLAG_FOUR_CHANNEL; return FOUR_CH; }
SCMS { cue_yylval.ival = FLAG_SCMS; return SCMS; }
PREGAP { return PREGAP; }
INDEX { return INDEX; }
POSTGAP { return POSTGAP; }
TITLE { BEGIN(NAME); cue_yylval.ival = PTI_TITLE; return TITLE; }
PERFORMER { BEGIN(NAME); cue_yylval.ival = PTI_PERFORMER; return PERFORMER; }
SONGWRITER { BEGIN(NAME); cue_yylval.ival = PTI_SONGWRITER; return SONGWRITER; }
COMPOSER { BEGIN(NAME); cue_yylval.ival = PTI_COMPOSER; return COMPOSER; }
ARRANGER { BEGIN(NAME); cue_yylval.ival = PTI_ARRANGER; return ARRANGER; }
MESSAGE { BEGIN(NAME); cue_yylval.ival = PTI_MESSAGE; return MESSAGE; }
DISC_ID { BEGIN(NAME); cue_yylval.ival = PTI_DISC_ID; return DISC_ID; }
GENRE { BEGIN(NAME); cue_yylval.ival = PTI_GENRE; return GENRE; }
TOC_INFO1 { BEGIN(NAME); cue_yylval.ival = PTI_TOC_INFO1; return TOC_INFO1; }
TOC_INFO2 { BEGIN(NAME); cue_yylval.ival = PTI_TOC_INFO2; return TOC_INFO2; }
UPC_EAN { BEGIN(NAME); cue_yylval.ival = PTI_UPC_ISRC; return UPC_EAN; }
ISRC/{ws}+\" { BEGIN(NAME); cue_yylval.ival = PTI_UPC_ISRC; return ISRC; }
SIZE_INFO { BEGIN(NAME); cue_yylval.ival = PTI_SIZE_INFO; return SIZE_INFO; }
ISRC { BEGIN(NAME); return TRACK_ISRC; }
^{ws}*REM.*\n { cue_lineno++; /* ignore comments */ }
{ws}+ { /* ignore whitespace */ }
[[:digit:]]+ { cue_yylval.ival = atoi(yytext); return NUMBER; }
: { return yytext[0]; }
^{ws}*\n { cue_lineno++; /* blank line */ }
\n { cue_lineno++; return '\n'; }
. { fprintf(stderr, "bad character '%c'\n", yytext[0]); }
%%

90
lib/cuefile.c Normal file
View File

@@ -0,0 +1,90 @@
/*
* cuefile.c -- cue/toc functions
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdlib.h>
#include <string.h>
#include "cuefile.h"
#include "cue.h"
#include "toc.h"
Cd *cf_parse (char *name, int *format)
{
FILE *fp = NULL;
Cd *cd = NULL;
if (UNKNOWN == *format)
if (UNKNOWN == (*format = cf_format_from_suffix(name))) {
fprintf(stderr, "%s: unknown format\n", name);
return NULL;
}
if (0 == strcmp("-", name)) {
fp = stdin;
} else if (NULL == (fp = fopen(name, "r"))) {
fprintf(stderr, "%s: error opening file\n", name);
return NULL;
}
switch (*format) {
case CUE:
cd = cue_parse(fp);
break;
case TOC:
cd = toc_parse(fp);
break;
}
if(stdin != fp)
fclose(fp);
return cd;
}
int cf_print (char *name, int *format, Cd *cd)
{
FILE *fp = NULL;
if (UNKNOWN == *format)
if (UNKNOWN == (*format = cf_format_from_suffix(name))) {
fprintf(stderr, "%s: unknown format\n", name);
return -1;
}
if (0 == strcmp("-", name)) {
fp = stdout;
} else if (NULL == (fp = fopen(name, "w"))) {
fprintf(stderr, "%s: error opening file\n", name);
return -1;
}
switch (*format) {
case CUE:
cue_print(fp, cd);
break;
case TOC:
toc_print(fp, cd);
break;
}
if(stdout != fp)
fclose(fp);
return 0;
}
int cf_format_from_suffix (char *name)
{
char *suffix;
if (0 != (suffix = strrchr(name, '.'))) {
if (0 == strcasecmp(".cue", suffix))
return CUE;
else if (0 == strcasecmp(".toc", suffix))
return TOC;
}
return UNKNOWN;
}

16
lib/cuefile.h Normal file
View File

@@ -0,0 +1,16 @@
/*
* cuefile.h -- cue/toc public declarations
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include "cd.h"
enum {CUE, TOC, UNKNOWN};
typedef struct Cue Cue;
Cd *cf_parse (char *fname, int *format);
int cf_print (char *fname, int *format, Cd *cue);
int cf_format_from_suffix (char *fname);

43
lib/time.c Normal file
View File

@@ -0,0 +1,43 @@
/*
* time.c -- time functions
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdio.h>
#include <stdlib.h>
long time_msf_to_frame (int m, int s, int f)
{
return (m * 60 + s) * 75 + f;
}
void msf_frame_to_msf (long frame, int *m, int *s, int *f)
{
*f = frame % 75; /* 0 <= frames <= 74 */
frame /= 75;
*s = frame % 60; /* 0 <= seconds <= 59 */
frame /= 60;
*m = frame; /* 0 <= minutes */
}
void time_frame_to_msf (long frame, int *m, int *s, int *f)
{
*f = frame % 75; /* 0 <= frames <= 74 */
frame /= 75;
*s = frame % 60; /* 0 <= seconds <= 59 */
frame /= 60;
*m = frame; /* 0 <= minutes */
}
/* print frame in mm:ss:ff format */
char *time_frame_to_mmssff (long f)
{
static char msf[9];
int minutes, seconds, frames;
msf_frame_to_msf(f, &minutes, &seconds, &frames);
sprintf(msf, "%02d:%02d:%02d", minutes, seconds, frames);
return msf;
}

15
lib/time.h Normal file
View File

@@ -0,0 +1,15 @@
/* time.h -- time declarations
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#ifndef TIME_H
#define TIME_H
long time_msf_to_frame (int m, int s, int f);
long time_mmssff_to_frame (char *mmssff);
void time_frame_to_msf (long frame, int *m, int *s, int *f);
char *time_frame_to_mmssff (long f);
#endif

6
lib/toc.h Normal file
View File

@@ -0,0 +1,6 @@
/*
* toc.h -- toc function declarations
*/
Cd *toc_parse (FILE *fp);
void toc_print (FILE *fp, Cd *cd);

345
lib/toc_parse.y Normal file
View File

@@ -0,0 +1,345 @@
%{
/*
* toc_parse.y -- parser for toc files
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cd.h"
#include "time.h"
#define YYDEBUG 1
extern int toc_yylex();
void yyerror (char *s);
static Cd *cd = NULL;
static Track *track = NULL;
static Cdtext *cdtext = NULL;
%}
%start tocfile
%union {
long ival;
char *sval;
}
%token <ival> NUMBER
%token <sval> STRING
/* global (header) */
%token CATALOG
%token <ival> CD_DA
%token <ival> CD_ROM
%token <ival> CD_ROM_XA
/* track */
%token TRACK
%token <ival> AUDIO
%token <ival> MODE1
%token <ival> MODE1_RAW
%token <ival> MODE2
%token <ival> MODE2_FORM1
%token <ival> MODE2_FORM2
%token <ival> MODE2_FORM_MIX
%token <ival> MODE2_RAW
%token <ival> RW
%token <ival> RW_RAW
%token NO
%token <ival> COPY
%token <ival> PRE_EMPHASIS
%token <ival> TWO_CHANNEL_AUDIO
%token <ival> FOUR_CHANNEL_AUDIO
%token ISRC
%token SILENCE
%token ZERO
%token AUDIOFILE
%token DATAFILE
%token FIFO
%token START
%token PREGAP
%token INDEX
/* CD-TEXT */
%token CD_TEXT
%token LANGUAGE_MAP
%token LANGUAGE
%token <ival> TITLE
%token <ival> PERFORMER
%token <ival> SONGWRITER
%token <ival> COMPOSER
%token <ival> ARRANGER
%token <ival> MESSAGE
%token <ival> DISC_ID
%token <ival> GENRE
%token <ival> TOC_INFO1
%token <ival> TOC_INFO2
%token <ival> UPC_EAN
%token <ival> ISRC
%token <ival> SIZE_INFO
%type <ival> disc_mode
%type <ival> track_modes
%type <ival> track_mode
%type <ival> track_sub_mode
%type <ival> track_set_flag
%type <ival> track_clear_flag
%type <ival> time
%type <ival> cdtext_item
%%
tocfile
: new_cd global_statements track_list
;
new_cd
: /* empty */ {
cd = cd_init();
cdtext = cd_get_cdtext(cd);
}
;
global_statements
: /* empty */
| global_statements global_statement
;
global_statement
: CATALOG STRING '\n' { cd_set_catalog(cd, $2); }
| disc_mode '\n' { cd_set_mode(cd, $1); }
| CD_TEXT '{' opt_nl language_map cdtext_langs '}' '\n'
| error '\n'
;
disc_mode
: CD_DA
| CD_ROM
| CD_ROM_XA
;
track_list
: track
| track_list track
;
track
: new_track track_def track_statements {
while (2 > track_get_nindex(track))
track_add_index(track, 0);
}
;
new_track
: /* empty */ {
track = cd_add_track(cd);
cdtext = track_get_cdtext(track);
/* add 0 index */
track_add_index(track, 0);
}
;
track_def
: TRACK track_modes '\n' { track_set_mode(track, $2); }
;
track_modes
: track_mode
| track_mode track_sub_mode { track_set_sub_mode(track, $2); }
;
track_mode
: AUDIO
| MODE1
| MODE1_RAW
| MODE2
| MODE2_FORM1
| MODE2_FORM2
| MODE2_FORM_MIX
| MODE2_RAW
;
track_sub_mode
: RW
| RW_RAW
;
track_statements
: track_statement
| track_statements track_statement
;
track_statement
: track_flags
| ISRC STRING '\n' { track_set_isrc(track, $2); }
| CD_TEXT '{' opt_nl cdtext_langs '}' '\n'
| track_data
| track_pregap
| track_index
| error '\n'
;
track_flags
: track_set_flag { track_set_flag(track, $1); }
| track_clear_flag { track_clear_flag(track, $1); }
;
track_set_flag
: COPY '\n'
| PRE_EMPHASIS '\n'
| FOUR_CHANNEL_AUDIO '\n'
;
track_clear_flag
: NO PRE_EMPHASIS '\n' { $$ = $2; }
| NO COPY '\n' { $$ = $2; }
| TWO_CHANNEL_AUDIO '\n'
;
track_data
: zero_data time '\n' {
if (NULL == track_get_filename(track))
track_set_zero_pre(track, $2);
else
track_set_zero_post(track, $2);
}
| AUDIOFILE STRING time '\n' {
track_set_filename(track, $2);
track_set_start(track, $3);
}
| AUDIOFILE STRING time time '\n' {
track_set_filename(track, $2);
track_set_start(track, $3);
track_set_length(track, $4);
}
| DATAFILE STRING '\n' {
track_set_filename(track, $2);
}
| DATAFILE STRING time '\n' {
track_set_filename(track, $2);
track_set_start(track, $3);
}
| FIFO STRING time '\n' {
track_set_filename(track, $2);
track_set_start(track, $3);
}
;
zero_data
: SILENCE
| ZERO
;
track_pregap
: START '\n'
| START time '\n' {
track_add_index(track, $2);
}
| PREGAP time '\n' {
track_set_zero_pre(track, $2);
track_add_index(track, $2);
}
;
track_index
: INDEX time '\n' { track_add_index(track, $2); }
;
language_map
: LANGUAGE_MAP '{' opt_nl languages '}' '\n'
;
languages
: language
| languages language
;
language
: NUMBER ':' NUMBER opt_nl
;
cdtext_langs
: cdtext_lang
| cdtext_langs cdtext_lang
;
cdtext_lang
: LANGUAGE NUMBER '{' opt_nl cdtext_defs '}' '\n'
;
cdtext_defs
: /* empty */
| cdtext_defs cdtext_def
;
cdtext_def
: cdtext_item STRING '\n' {
cdtext_set ($1, $2, cdtext);
}
| cdtext_item '{' bytes '}' '\n' {
yyerror("binary CD-TEXT data not supported\n");
}
;
cdtext_item
: TITLE
| PERFORMER
| SONGWRITER
| COMPOSER
| ARRANGER
| MESSAGE
| DISC_ID
| GENRE
| TOC_INFO1
| TOC_INFO2
| UPC_EAN
| ISRC
| SIZE_INFO
;
bytes
: /* empty */
| bytes ',' NUMBER
;
time
: NUMBER { $$ = $1; }
| NUMBER ':' NUMBER ':' NUMBER { $$ = time_msf_to_frame($1, $3, $5); }
;
opt_nl
: /* empty */
| '\n'
;
%%
/* lexer interface */
extern int toc_lineno;
extern int toc_yydebug;
extern FILE *toc_yyin;
void yyerror (char *s)
{
fprintf(stderr, "%d: %s\n", toc_lineno, s);
}
Cd *toc_parse (FILE *fp)
{
toc_yyin = fp;
toc_yydebug = 0;
if (0 == toc_yyparse())
return cd;
return NULL;
}

149
lib/toc_print.c Normal file
View File

@@ -0,0 +1,149 @@
/*
* toc_print.c -- print toc file
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdio.h>
#include <string.h>
#include "cd.h"
#include "time.h"
void toc_print_track (FILE *fp, Track *track);
void toc_print_cdtext (Cdtext *cdtext, FILE *fp, int istrack);
void toc_print (FILE *fp, Cd *cd)
{
Cdtext *cdtext = cd_get_cdtext(cd);
int i; /* track */
Track *track;
switch(cd_get_mode(cd)) {
case MODE_CD_DA:
fprintf(fp, "CD_DA\n");
break;
case MODE_CD_ROM:
fprintf(fp, "CD_ROM\n");
break;
case MODE_CD_ROM_XA:
fprintf(fp, "CD_ROM_XA\n");
break;
}
if (NULL != cd_get_catalog(cd))
fprintf(fp, "CATALOG \"%s\"\n", cd_get_catalog(cd));
if(0 != cdtext_is_empty(cdtext)) {
fprintf(fp, "CD_TEXT {\n");
fprintf(fp, "\tLANGUAGE_MAP { 0:9 }\n");
fprintf(fp, "\tLANGUAGE 0 {\n");
toc_print_cdtext(cdtext, fp, 0);
fprintf(fp, "\t}\n");
fprintf(fp, "}\n");
}
for (i = 1; i <= cd_get_ntrack(cd); i++) {
track = cd_get_track(cd, i);
fprintf(fp, "\n");
toc_print_track(fp, track);
}
}
void toc_print_track (FILE *fp, Track *track)
{
Cdtext *cdtext = track_get_cdtext(track);
int i; /* index */
fprintf(fp, "TRACK ");
switch (track_get_mode(track)) {
case MODE_AUDIO:
fprintf(fp, "AUDIO");
break;
case MODE_MODE1:
fprintf(fp, "MODE1");
break;
case MODE_MODE1_RAW:
fprintf(fp, "MODE1_RAW");
break;
case MODE_MODE2:
fprintf(fp, "MODE2");
break;
case MODE_MODE2_FORM1:
fprintf(fp, "MODE2_FORM1");
break;
case MODE_MODE2_FORM2:
fprintf(fp, "MODE2_FORM2");
break;
case MODE_MODE2_FORM_MIX:
fprintf(fp, "MODE2_FORM_MIX");
break;
}
fprintf(fp, "\n");
if (0 != track_is_set_flag(track, FLAG_PRE_EMPHASIS))
fprintf(fp, "PRE_EMPHASIS\n");
if (0 != track_is_set_flag(track, FLAG_COPY_PERMITTED))
fprintf(fp, "COPY\n");
if (0 != track_is_set_flag(track, FLAG_FOUR_CHANNEL))
fprintf(fp, "FOUR_CHANNEL_AUDIO\n");
if (NULL != track_get_isrc(track))
fprintf(fp, "ISRC \"%s\"\n", track_get_isrc(track));
if (0 != cdtext_is_empty(cdtext)) {
fprintf(fp, "CD_TEXT {\n");
fprintf(fp, "\tLANGUAGE 0 {\n");
toc_print_cdtext(cdtext, fp, 1);
fprintf(fp, "\t}\n");
fprintf(fp, "}\n");
}
if (0 != track_get_zero_pre(track)) {
fprintf(fp, "ZERO ");
fprintf(fp, "%s", time_frame_to_mmssff(track_get_zero_pre(track)));
fprintf(fp, "\n");
}
fprintf(fp, "FILE ");
fprintf(fp, "\"%s\" ", track_get_filename(track));
if (0 == track_get_start(track))
fprintf(fp, "0");
else
fprintf(fp, "%s", time_frame_to_mmssff(track_get_start(track)));
if (0 != track_get_length(track))
fprintf(fp, " %s", time_frame_to_mmssff(track_get_length(track)));
fprintf(fp, "\n");
if (0 != track_get_zero_post(track)) {
fprintf(fp, "ZERO ");
fprintf(fp, "%s", time_frame_to_mmssff(track_get_zero_post(track)));
fprintf(fp, "\n");
}
if (track_get_index(track, 1) != 0) {
fprintf(fp, "START ");
fprintf(fp, "%s\n", time_frame_to_mmssff(track_get_index(track, 1)));
}
for (i = 2; i < track_get_nindex(track); i++) {
fprintf(fp, "INDEX ");
fprintf(fp, "%s\n", time_frame_to_mmssff( \
track_get_index(track, i) - track_get_index(track, 0) \
));
}
}
void toc_print_cdtext (Cdtext *cdtext, FILE *fp, int istrack)
{
int pti;
char *value = NULL;
for (pti = 0; PTI_END != pti; pti++) {
if (NULL != (value = cdtext_get(pti, cdtext))) {
fprintf(fp, "\t\t");
fprintf(fp, "%s", cdtext_get_key(pti, istrack));
fprintf(fp, " \"%s\"\n", value);
}
}
}

102
lib/toc_scan.l Normal file
View File

@@ -0,0 +1,102 @@
%{
/*
* toc_scan.l -- lexer for toc files
*
* Copyright (C) 2004 Svend Sorensen <sorensen@freeshell.org>
* For license terms, see the file COPYING in this distribution.
*/
#include <stdlib.h>
#include <string.h>
#include "cd.h"
#include "toc_parse.h"
int toc_lineno = 1;
%}
ws [ \t\r]
nonws [^ \t\r\n]
%option noyywrap
%s NAME
%%
\"(\\.|[^\\"])*\" {
toc_yylval.sval = strdup(yytext + 1);
toc_yylval.sval[strlen(toc_yylval.sval) - 1] = '\0';
BEGIN(INITIAL);
return STRING;
}
<NAME>{nonws}+ {
toc_yylval.sval = strdup(yytext);
BEGIN(INITIAL);
return STRING;
}
CATALOG { BEGIN(NAME); return CATALOG; }
CD_DA { toc_yylval.ival = MODE_CD_DA; return CD_DA; }
CD_ROM { toc_yylval.ival = MODE_CD_ROM; return CD_ROM; }
CD_ROM_XA { toc_yylval.ival = MODE_CD_ROM_XA; return CD_ROM_XA; }
TRACK { return TRACK; }
AUDIO { toc_yylval.ival = MODE_AUDIO; return AUDIO; }
MODE1 { toc_yylval.ival = MODE_MODE1; return MODE1; }
MODE1_RAW { toc_yylval.ival = MODE_MODE1_RAW; return MODE1_RAW; }
MODE2 { toc_yylval.ival = MODE_MODE2; return MODE2; }
MODE2_FORM1 { toc_yylval.ival = MODE_MODE2_FORM1; return MODE2_FORM1; }
MODE2_FORM2 { toc_yylval.ival = MODE_MODE2_FORM2; return MODE2_FORM2; }
MODE2_FORM_MIX { toc_yylval.ival = MODE_MODE2_FORM_MIX; return MODE2_FORM_MIX; }
MODE2_RAW { toc_yylval.ival = MODE_MODE2_RAW; return MODE2_RAW; }
RW { toc_yylval.ival = SUB_MODE_RW; return RW; }
RW_RAW { toc_yylval.ival = SUB_MODE_RW_RAW; return RW_RAW; }
NO { return NO; }
COPY { toc_yylval.ival = FLAG_PRE_EMPHASIS; return COPY; }
PRE_EMPHASIS { toc_yylval.ival = FLAG_COPY_PERMITTED; return PRE_EMPHASIS; }
FOUR_CHANNEL_AUDIO { toc_yylval.ival = FLAG_FOUR_CHANNEL; return FOUR_CHANNEL_AUDIO; }
TWO_CHANNEL_AUDIO { toc_yylval.ival = FLAG_FOUR_CHANNEL; return TWO_CHANNEL_AUDIO; }
/* ISRC is with CD-TEXT items */
SILENCE { return SILENCE; }
ZERO { return ZERO; }
(AUDIO)?FILE { BEGIN(NAME); return AUDIOFILE; }
DATAFILE { BEGIN(NAME); return DATAFILE; }
FIFO { BEGIN(NAME); return FIFO; }
START { return START; }
PREGAP { return PREGAP; }
INDEX { return INDEX; }
CD_TEXT { return CD_TEXT; }
LANGUAGE_MAP { return LANGUAGE_MAP; }
LANGUAGE { return LANGUAGE; }
TITLE { BEGIN(NAME); toc_yylval.ival = PTI_TITLE; return TITLE; }
PERFORMER { BEGIN(NAME); toc_yylval.ival = PTI_PERFORMER; return PERFORMER; }
SONGWRITER { BEGIN(NAME); toc_yylval.ival = PTI_SONGWRITER; return SONGWRITER; }
COMPOSER { BEGIN(NAME); toc_yylval.ival = PTI_COMPOSER; return COMPOSER; }
ARRANGER { BEGIN(NAME); toc_yylval.ival = PTI_ARRANGER; return ARRANGER; }
MESSAGE { BEGIN(NAME); toc_yylval.ival = PTI_MESSAGE; return MESSAGE; }
DISC_ID { BEGIN(NAME); toc_yylval.ival = PTI_DISC_ID; return DISC_ID; }
GENRE { BEGIN(NAME); toc_yylval.ival = PTI_GENRE; return GENRE; }
TOC_INFO1 { BEGIN(NAME); toc_yylval.ival = PTI_TOC_INFO1; return TOC_INFO1; }
TOC_INFO2 { BEGIN(NAME); toc_yylval.ival = PTI_TOC_INFO2; return TOC_INFO2; }
UPC_EAN { BEGIN(NAME); toc_yylval.ival = PTI_UPC_ISRC; return UPC_EAN; }
ISRC { BEGIN(NAME); toc_yylval.ival = PTI_UPC_ISRC; return ISRC; }
SIZE_INFO { BEGIN(NAME); toc_yylval.ival = PTI_SIZE_INFO; return SIZE_INFO; }
"//".*\n { toc_lineno++; /* ignore comments */ }
{ws}+ { /* ignore whitespace */ }
[[:digit:]]+ { toc_yylval.ival = atoi(yytext); return NUMBER; }
:|,|\{|\} { return yytext[0]; }
^{ws}*\n { toc_lineno++; /* blank line */ }
\n { toc_lineno++; return '\n'; }
. { fprintf(stderr, "bad character '%c'\n", yytext[0]); }
%%