Remove obsolete files
This commit is contained in:
parent
e943c8c648
commit
ca771aae2e
@ -1,14 +0,0 @@
|
||||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
|
||||
|
||||
#include "errors.h"
|
||||
#include <stdio.h>
|
||||
|
||||
void iso_warn(enum iso_warnings w)
|
||||
{
|
||||
printf("WARNING: %u\n", w);
|
||||
}
|
||||
|
||||
void iso_error(enum iso_errors e)
|
||||
{
|
||||
printf("ERROR: %u\n", e);
|
||||
}
|
@ -1,19 +0,0 @@
|
||||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
|
||||
|
||||
#ifndef __ERRORS
|
||||
#define __ERRORS
|
||||
|
||||
enum iso_warnings
|
||||
{
|
||||
ISO_WARNING_FOO
|
||||
};
|
||||
|
||||
enum iso_errors
|
||||
{
|
||||
ISO_ERROR_FOO
|
||||
};
|
||||
|
||||
void iso_warn(enum iso_warnings w);
|
||||
void iso_error(enum iso_errors e);
|
||||
|
||||
#endif /* __ERRORS */
|
@ -1,928 +0,0 @@
|
||||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
|
||||
|
||||
#ifndef LIBBURN_H
|
||||
#define LIBBURN_H
|
||||
|
||||
/* Needed for off_t which is the (POSIX-ly) appropriate type for
|
||||
expressing a file or stream size.
|
||||
|
||||
XXX we should enforce 64-bitness for off_t
|
||||
*/
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifndef DOXYGEN
|
||||
|
||||
#if defined(__cplusplus)
|
||||
#define BURN_BEGIN_DECLS \
|
||||
namespace burn { \
|
||||
extern "C" {
|
||||
#define BURN_END_DECLS \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define BURN_BEGIN_DECLS
|
||||
#define BURN_END_DECLS
|
||||
#endif
|
||||
|
||||
BURN_BEGIN_DECLS
|
||||
|
||||
#endif
|
||||
|
||||
/** References a physical drive in the system */
|
||||
struct burn_drive;
|
||||
|
||||
/** References a whole disc */
|
||||
struct burn_disc;
|
||||
|
||||
/** References a single session on a disc */
|
||||
struct burn_session;
|
||||
|
||||
/** References a single track on a disc */
|
||||
struct burn_track;
|
||||
|
||||
/** Session format for normal audio or data discs */
|
||||
#define BURN_CDROM 0
|
||||
/** Session format for obsolete CD-I discs */
|
||||
#define BURN_CDI 0x10
|
||||
/** Session format for CDROM-XA discs */
|
||||
#define BURN_CDXA 0x20
|
||||
|
||||
#define BURN_POS_END 100
|
||||
|
||||
/** Mask for mode bits */
|
||||
#define BURN_MODE_BITS 127
|
||||
|
||||
/** Track mode - mode 0 data
|
||||
0 bytes of user data. it's all 0s. mode 0. get it? HAH
|
||||
*/
|
||||
#define BURN_MODE0 (1 << 0)
|
||||
/** Track mode - mode "raw" - all 2352 bytes supplied by app
|
||||
FOR DATA TRACKS ONLY!
|
||||
*/
|
||||
#define BURN_MODE_RAW (1 << 1)
|
||||
/** Track mode - mode 1 data
|
||||
2048 bytes user data, and all the LEC money can buy
|
||||
*/
|
||||
#define BURN_MODE1 (1 << 2)
|
||||
/** Track mode - mode 2 data
|
||||
defaults to formless, 2336 bytes of user data, unprotected
|
||||
| with a data form if required.
|
||||
*/
|
||||
#define BURN_MODE2 (1 << 3)
|
||||
/** Track mode modifier - Form 1, | with MODE2 for reasonable results
|
||||
2048 bytes of user data, 4 bytes of subheader
|
||||
*/
|
||||
#define BURN_FORM1 (1 << 4)
|
||||
/** Track mode modifier - Form 2, | with MODE2 for reasonable results
|
||||
lots of user data. not much LEC.
|
||||
*/
|
||||
#define BURN_FORM2 (1 << 5)
|
||||
/** Track mode - audio
|
||||
2352 bytes per sector. may be | with 4ch or preemphasis.
|
||||
NOT TO BE CONFUSED WITH BURN_MODE_RAW
|
||||
*/
|
||||
#define BURN_AUDIO (1 << 6)
|
||||
/** Track mode modifier - 4 channel audio. */
|
||||
#define BURN_4CH (1 << 7)
|
||||
/** Track mode modifier - Digital copy permitted, can be set on any track.*/
|
||||
#define BURN_COPY (1 << 8)
|
||||
/** Track mode modifier - 50/15uS pre-emphasis */
|
||||
#define BURN_PREEMPHASIS (1 << 9)
|
||||
/** Input mode modifier - subcodes present packed 16 */
|
||||
#define BURN_SUBCODE_P16 (1 << 10)
|
||||
/** Input mode modifier - subcodes present packed 96 */
|
||||
#define BURN_SUBCODE_P96 (1 << 11)
|
||||
/** Input mode modifier - subcodes present raw 96 */
|
||||
#define BURN_SUBCODE_R96 (1 << 12)
|
||||
|
||||
/** Possible disc writing style/modes */
|
||||
enum burn_write_types
|
||||
{
|
||||
/** Packet writing.
|
||||
currently unsupported
|
||||
*/
|
||||
BURN_WRITE_PACKET,
|
||||
/** Track At Once recording.
|
||||
2s gaps between tracks, no fonky lead-ins
|
||||
*/
|
||||
BURN_WRITE_TAO,
|
||||
/** Session At Once.
|
||||
block type MUST be BURN_BLOCK_SAO
|
||||
*/
|
||||
BURN_WRITE_SAO,
|
||||
/** Raw disc at once recording.
|
||||
all subcodes must be provided by lib or user
|
||||
only raw block types are supported
|
||||
*/
|
||||
BURN_WRITE_RAW
|
||||
};
|
||||
|
||||
/** Data format to send to the drive */
|
||||
enum burn_block_types
|
||||
{
|
||||
/** sync, headers, edc/ecc provided by lib/user */
|
||||
BURN_BLOCK_RAW0 = 1,
|
||||
/** sync, headers, edc/ecc and p/q subs provided by lib/user */
|
||||
BURN_BLOCK_RAW16 = 2,
|
||||
/** sync, headers, edc/ecc and packed p-w subs provided by lib/user */
|
||||
BURN_BLOCK_RAW96P = 4,
|
||||
/** sync, headers, edc/ecc and raw p-w subs provided by lib/user */
|
||||
BURN_BLOCK_RAW96R = 8,
|
||||
/** only 2048 bytes of user data provided by lib/user */
|
||||
BURN_BLOCK_MODE1 = 256,
|
||||
/** 2336 bytes of user data provided by lib/user */
|
||||
BURN_BLOCK_MODE2R = 512,
|
||||
/** 2048 bytes of user data provided by lib/user
|
||||
subheader provided in write parameters
|
||||
are we ever going to support this shit? I vote no.
|
||||
(supposed to be supported on all drives...)
|
||||
*/
|
||||
BURN_BLOCK_MODE2_PATHETIC = 1024,
|
||||
/** 2048 bytes of data + 8 byte subheader provided by lib/user
|
||||
hey, this is also dumb
|
||||
*/
|
||||
BURN_BLOCK_MODE2_LAME = 2048,
|
||||
/** 2324 bytes of data provided by lib/user
|
||||
subheader provided in write parameters
|
||||
no sir, I don't like it.
|
||||
*/
|
||||
BURN_BLOCK_MODE2_OBSCURE = 4096,
|
||||
/** 2332 bytes of data supplied by lib/user
|
||||
8 bytes sub header provided in write parameters
|
||||
this is the second least suck mode2, and is mandatory for
|
||||
all drives to support.
|
||||
*/
|
||||
BURN_BLOCK_MODE2_OK = 8192,
|
||||
/** SAO block sizes are based on cue sheet, so use this. */
|
||||
BURN_BLOCK_SAO = 16384
|
||||
};
|
||||
|
||||
/** Possible status' of the drive in regard to the disc in it. */
|
||||
enum burn_disc_status
|
||||
{
|
||||
/** The current status is not yet known */
|
||||
BURN_DISC_UNREADY,
|
||||
/** The drive holds a blank disc */
|
||||
BURN_DISC_BLANK,
|
||||
/** There is no disc at all in the drive */
|
||||
BURN_DISC_EMPTY,
|
||||
/** There is an incomplete disc in the drive */
|
||||
BURN_DISC_APPENDABLE,
|
||||
/** There is a disc with data on it in the drive */
|
||||
BURN_DISC_FULL
|
||||
};
|
||||
|
||||
/** Possible types of messages form the library. */
|
||||
enum burn_message_type
|
||||
{
|
||||
/** Diagnostic/Process information. For the curious user. */
|
||||
BURN_MESSAGE_INFO,
|
||||
/** A warning regarding a possible problem. The user should probably
|
||||
be notified, but its not fatal. */
|
||||
BURN_MESSAGE_WARNING,
|
||||
/** An error message. This usually means the current process will be
|
||||
aborted, and the user should definately see these. */
|
||||
BURN_MESSAGE_ERROR
|
||||
};
|
||||
|
||||
/** Possible information messages */
|
||||
enum burn_message_info
|
||||
{
|
||||
BURN_INFO_FOO
|
||||
};
|
||||
|
||||
/** Possible warning messages */
|
||||
enum burn_message_warning
|
||||
{
|
||||
BURN_WARNING_FOO
|
||||
};
|
||||
|
||||
/** Possible error messages */
|
||||
enum burn_message_error
|
||||
{
|
||||
BURN_ERROR_CANCELLED
|
||||
};
|
||||
|
||||
/** Possible data source return values */
|
||||
enum burn_source_status
|
||||
{
|
||||
/** The source is ok */
|
||||
BURN_SOURCE_OK,
|
||||
/** The source is at end of file */
|
||||
BURN_SOURCE_EOF,
|
||||
/** The source is unusable */
|
||||
BURN_SOURCE_FAILED
|
||||
};
|
||||
|
||||
|
||||
/** Possible busy states for a drive */
|
||||
enum burn_drive_status
|
||||
{
|
||||
/** The drive is not in an operation */
|
||||
BURN_DRIVE_IDLE,
|
||||
/** The library is spawning the processes to handle a pending
|
||||
operation (A read/write/etc is about to start but hasn't quite
|
||||
yet) */
|
||||
BURN_DRIVE_SPAWNING,
|
||||
/** The drive is reading data from a disc */
|
||||
BURN_DRIVE_READING,
|
||||
/** The drive is writing data to a disc */
|
||||
BURN_DRIVE_WRITING,
|
||||
/** The drive is writing Lead-In */
|
||||
BURN_DRIVE_WRITING_LEADIN,
|
||||
/** The drive is writing Lead-Out */
|
||||
BURN_DRIVE_WRITING_LEADOUT,
|
||||
/** The drive is erasing a disc */
|
||||
BURN_DRIVE_ERASING,
|
||||
/** The drive is being grabbed */
|
||||
BURN_DRIVE_GRABBING
|
||||
};
|
||||
|
||||
/** Information about a track on a disc - this is from the q sub channel of the
|
||||
lead-in area of a disc. The documentation here is very terse.
|
||||
See a document such as mmc3 for proper information.
|
||||
*/
|
||||
struct burn_toc_entry
|
||||
{
|
||||
/** Session the track is in */
|
||||
unsigned char session;
|
||||
/** Type of data. for this struct to be valid, it must be 1 */
|
||||
unsigned char adr;
|
||||
/** Type of data in the track */
|
||||
unsigned char control;
|
||||
/** Zero. Always. Really. */
|
||||
unsigned char tno;
|
||||
/** Track number or special information */
|
||||
unsigned char point;
|
||||
unsigned char min;
|
||||
unsigned char sec;
|
||||
unsigned char frame;
|
||||
unsigned char zero;
|
||||
/** Track start time minutes for normal tracks */
|
||||
unsigned char pmin;
|
||||
/** Track start time seconds for normal tracks */
|
||||
unsigned char psec;
|
||||
/** Track start time frames for normal tracks */
|
||||
unsigned char pframe;
|
||||
};
|
||||
|
||||
|
||||
/** Data source for tracks */
|
||||
struct burn_source {
|
||||
/** Reference count for the data source. Should be 1 when a new source
|
||||
is created. Increment it to take a reference for yourself. Use
|
||||
burn_source_free to destroy your reference to it. */
|
||||
int refcount;
|
||||
|
||||
/** Read data from the source */
|
||||
int (*read)(struct burn_source *,
|
||||
unsigned char *buffer,
|
||||
int size);
|
||||
|
||||
/** Read subchannel data from the source (NULL if lib generated) */
|
||||
int (*read_sub)(struct burn_source *,
|
||||
unsigned char *buffer,
|
||||
int size);
|
||||
|
||||
/** Get the size of the source's data */
|
||||
off_t (*get_size)(struct burn_source *);
|
||||
|
||||
/** Clean up the source specific data */
|
||||
void (*free_data)(struct burn_source *);
|
||||
|
||||
/** Next source, for when a source runs dry and padding is disabled
|
||||
THIS IS AUTOMATICALLY HANDLED, DO NOT TOUCH
|
||||
*/
|
||||
struct burn_source *next;
|
||||
|
||||
/** Source specific data */
|
||||
void *data;
|
||||
};
|
||||
|
||||
|
||||
/** Information on a drive in the system */
|
||||
struct burn_drive_info
|
||||
{
|
||||
/** Name of the vendor of the drive */
|
||||
char vendor[9];
|
||||
/** Name of the drive */
|
||||
char product[17];
|
||||
/** Revision of the drive */
|
||||
char revision[5];
|
||||
/** Location of the drive in the filesystem. */
|
||||
char location[17];
|
||||
|
||||
/** Can the drive read DVD-RAM discs */
|
||||
unsigned int read_dvdram:1;
|
||||
/** Can the drive read DVD-R discs */
|
||||
unsigned int read_dvdr:1;
|
||||
/** Can the drive read DVD-ROM discs */
|
||||
unsigned int read_dvdrom:1;
|
||||
/** Can the drive read CD-R discs */
|
||||
unsigned int read_cdr:1;
|
||||
/** Can the drive read CD-RW discs */
|
||||
unsigned int read_cdrw:1;
|
||||
|
||||
/** Can the drive write DVD-RAM discs */
|
||||
unsigned int write_dvdram:1;
|
||||
/** Can the drive write DVD-R discs */
|
||||
unsigned int write_dvdr:1;
|
||||
/** Can the drive write CD-R discs */
|
||||
unsigned int write_cdr:1;
|
||||
/** Can the drive write CD-RW discs */
|
||||
unsigned int write_cdrw:1;
|
||||
|
||||
/** Can the drive simulate a write */
|
||||
unsigned int write_simulate:1;
|
||||
|
||||
/** Can the drive report C2 errors */
|
||||
unsigned int c2_errors:1;
|
||||
|
||||
/** The size of the drive's buffer (in kilobytes) */
|
||||
int buffer_size;
|
||||
/**
|
||||
* The supported block types in tao mode.
|
||||
* They should be tested with the desired block type.
|
||||
* See also burn_block_types.
|
||||
*/
|
||||
int tao_block_types;
|
||||
/**
|
||||
* The supported block types in sao mode.
|
||||
* They should be tested with the desired block type.
|
||||
* See also burn_block_types.
|
||||
*/
|
||||
int sao_block_types;
|
||||
/**
|
||||
* The supported block types in raw mode.
|
||||
* They should be tested with the desired block type.
|
||||
* See also burn_block_types.
|
||||
*/
|
||||
int raw_block_types;
|
||||
/**
|
||||
* The supported block types in packet mode.
|
||||
* They should be tested with the desired block type.
|
||||
* See also burn_block_types.
|
||||
*/
|
||||
int packet_block_types;
|
||||
|
||||
/** The value by which this drive can be indexed when using functions
|
||||
in the library. This is the value to pass to all libbburn functions
|
||||
that operate on a drive. */
|
||||
struct burn_drive *drive;
|
||||
};
|
||||
|
||||
/** Messages from the library */
|
||||
struct burn_message
|
||||
{
|
||||
/** The drive associated with the message. NULL if the error is not
|
||||
related to a specific drive. */
|
||||
struct burn_drive *drive;
|
||||
|
||||
/** The type of message this is. See message_type for details. */
|
||||
enum burn_message_type type;
|
||||
|
||||
/** The actual message */
|
||||
union detail {
|
||||
struct {
|
||||
enum burn_message_info message;
|
||||
} info;
|
||||
struct {
|
||||
enum burn_message_warning message;
|
||||
} warning;
|
||||
struct {
|
||||
enum burn_message_error message;
|
||||
} error;
|
||||
} detail;
|
||||
};
|
||||
|
||||
/** Operation progress report. All values are 0 based indices.
|
||||
* */
|
||||
struct burn_progress {
|
||||
/** The total number of sessions */
|
||||
int sessions;
|
||||
/** Current session.*/
|
||||
int session;
|
||||
/** The total number of tracks */
|
||||
int tracks;
|
||||
/** Current track. */
|
||||
int track;
|
||||
/** The total number of indices */
|
||||
int indices;
|
||||
/** Curent index. */
|
||||
int index;
|
||||
/** The starting logical block address */
|
||||
int start_sector;
|
||||
/** The number of sector */
|
||||
int sectors;
|
||||
/** The current sector being processed */
|
||||
int sector;
|
||||
};
|
||||
|
||||
/** Initialize the library.
|
||||
This must be called before using any other functions in the library. It
|
||||
may be called more than once with no effect.
|
||||
If is possible to 'restart' the library by shutting it down and
|
||||
re-initializing it, though there is no good reason to do that.
|
||||
@return Nonzero if the library was able to initialize; zero if
|
||||
initialization failed.
|
||||
*/
|
||||
int burn_initialize(void);
|
||||
|
||||
/** Shutdown the library.
|
||||
This should be called before exiting your application. Make sure that all
|
||||
drives you have grabbed are released <i>before</i> calling this.
|
||||
*/
|
||||
void burn_finish(void);
|
||||
|
||||
/** Set the verbosity level of the library. The default value is 0, which means
|
||||
that nothing is output on stderr. The more you increase this, the more
|
||||
debug output should be displayed on stderr for you.
|
||||
@param level The verbosity level desired. 0 for nothing, higher positive
|
||||
values for more information output.
|
||||
*/
|
||||
void burn_set_verbosity(int level);
|
||||
|
||||
/** Returns a newly allocated burn_message structure. This message should be
|
||||
freed with burn_message_free() when you are finished with it.
|
||||
@return A message or NULL when there are no more messages to retrieve.
|
||||
*/
|
||||
struct burn_message* burn_get_message(void);
|
||||
|
||||
/** Frees a burn_message structure */
|
||||
void burn_message_free(struct burn_message *msg);
|
||||
|
||||
/** Scans for drives. This function MUST be called until it returns nonzero.
|
||||
No drives can be in use when this is called or it will assert.
|
||||
All drive pointers are invalidated by using this function. Do NOT store
|
||||
drive pointers across calls to this function or death AND pain will ensue.
|
||||
When the app is done with the burn_drive_info array, it must be freed with
|
||||
burn_drive_info_free()
|
||||
@param drives Returns an array of drives (cdroms/burners). The returned
|
||||
array should be freed when it is no longer needed, and
|
||||
before calling this function again to rescan.
|
||||
@param n_drives Returns the number of hardware drives in @c drives.
|
||||
@return Zero while scanning is not complete; non-zero when it is finished.
|
||||
*/
|
||||
int burn_drive_scan(struct burn_drive_info *drives[],
|
||||
unsigned int *n_drives);
|
||||
/** Frees a burn_drive_info array returned by burn_drive_scan
|
||||
@param info The array to free
|
||||
*/
|
||||
void burn_drive_info_free(struct burn_drive_info *info);
|
||||
|
||||
/** Grab a drive. This must be done before the drive can be used (for reading,
|
||||
writing, etc). It may be neccesary to call this function more than once
|
||||
to grab a drive. See burn_grab for details.
|
||||
@param drive The drive to grab. This is found in a returned
|
||||
burn_drive_info struct.
|
||||
@param load Nonzero to make the drive attempt to load a disc (close its
|
||||
tray door, etc).
|
||||
@return 1 if the drive has been grabbed, else 0
|
||||
*/
|
||||
int burn_drive_grab(struct burn_drive *drive, int load);
|
||||
|
||||
/** Release a drive. This should not be done until the drive is no longer
|
||||
busy (see burn_drive_get_status).
|
||||
@param drive The drive to release.
|
||||
@param eject Nonzero to make the drive eject the disc in it.
|
||||
*/
|
||||
void burn_drive_release(struct burn_drive *drive, int eject);
|
||||
|
||||
/** Returns what kind of disc a drive is holding. This function may need to be
|
||||
called more than once to get a proper status from it. See burn_status
|
||||
for details.
|
||||
@param drive The drive to query for a disc.
|
||||
@return The status of the drive, or what kind of disc is in it.
|
||||
*/
|
||||
enum burn_disc_status burn_disc_get_status(struct burn_drive *drive);
|
||||
|
||||
/** Tells whether a disc can be erased or not
|
||||
@return Non-zero means erasable
|
||||
*/
|
||||
int burn_disc_erasable(struct burn_drive *d);
|
||||
|
||||
/** Returns the progress and status of a drive.
|
||||
@param drive The drive to query busy state for.
|
||||
@param p Returns the progress of the operation, NULL if you don't care
|
||||
@return the current status of the drive. See also burn_drive_status.
|
||||
*/
|
||||
enum burn_drive_status burn_drive_get_status(struct burn_drive *drive,
|
||||
struct burn_progress *p);
|
||||
|
||||
/** Creates a write_opts struct for burning to the specified drive
|
||||
must be freed with burn_write_opts_free
|
||||
@param drive The drive to write with
|
||||
@return The write_opts
|
||||
*/
|
||||
struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive);
|
||||
|
||||
/** Frees a write_opts struct created with burn_write_opts_new
|
||||
@param opts write_opts to free
|
||||
*/
|
||||
void burn_write_opts_free(struct burn_write_opts *opts);
|
||||
|
||||
/** Creates a write_opts struct for reading from the specified drive
|
||||
must be freed with burn_write_opts_free
|
||||
@param drive The drive to read from
|
||||
@return The read_opts
|
||||
*/
|
||||
struct burn_read_opts *burn_read_opts_new(struct burn_drive *drive);
|
||||
|
||||
/** Frees a read_opts struct created with burn_read_opts_new
|
||||
@param opts write_opts to free
|
||||
*/
|
||||
void burn_read_opts_free(struct burn_read_opts *opts);
|
||||
|
||||
/** Erase a disc in the drive. The drive must be grabbed successfully BEFORE
|
||||
calling this functions. Always ensure that the drive reports a status of
|
||||
BURN_DISC_FULL before calling this function. An erase operation is not
|
||||
cancellable, as control of the operation is passed wholly to the drive and
|
||||
there is no way to interrupt it safely.
|
||||
@param drive The drive with which to erase a disc.
|
||||
@param fast Nonzero to do a fast erase, where only the disc's headers are
|
||||
erased; zero to erase the entire disc.
|
||||
*/
|
||||
void burn_disc_erase(struct burn_drive *drive, int fast);
|
||||
|
||||
/** Read a disc from the drive and write it to an fd pair. The drive must be
|
||||
grabbed successfully BEFORE calling this function. Always ensure that the
|
||||
drive reports a status of BURN_DISC_FULL before calling this function.
|
||||
@param drive The drive from which to read a disc.
|
||||
@param o The options for the read operation.
|
||||
*/
|
||||
void burn_disc_read(struct burn_drive *drive, const struct burn_read_opts *o);
|
||||
|
||||
/** Write a disc in the drive. The drive must be grabbed successfully BEFORE
|
||||
calling this function. Always ensure that the drive reports a status of
|
||||
BURN_DISC_BLANK or BURN_STATUS_FULL (to append a new session to the
|
||||
disc) before calling this function.
|
||||
@param o The options for the writing operation.
|
||||
@param disc The struct burn_disc * that described the disc to be created
|
||||
*/
|
||||
void burn_disc_write(struct burn_write_opts *o, struct burn_disc *disc);
|
||||
|
||||
/** Cancel an operation on a drive.
|
||||
This will only work when the drive's busy state is BURN_DRIVE_READING or
|
||||
BURN_DRIVE_WRITING.
|
||||
@param drive The drive on which to cancel the current operation.
|
||||
*/
|
||||
void burn_drive_cancel(struct burn_drive *drive);
|
||||
|
||||
/** Convert a minute-second-frame (MSF) value to sector count
|
||||
@param m Minute component
|
||||
@param s Second component
|
||||
@param f Frame component
|
||||
@return The sector count
|
||||
*/
|
||||
int burn_msf_to_sectors(int m, int s, int f);
|
||||
|
||||
/** Convert a sector count to minute-second-frame (MSF)
|
||||
@param sectors The sector count
|
||||
@param m Returns the minute component
|
||||
@param s Returns the second component
|
||||
@param f Returns the frame component
|
||||
*/
|
||||
void burn_sectors_to_msf(int sectors, int *m, int *s, int *f);
|
||||
|
||||
/** Convert a minute-second-frame (MSF) value to an lba
|
||||
@param m Minute component
|
||||
@param s Second component
|
||||
@param f Frame component
|
||||
@return The lba
|
||||
*/
|
||||
int burn_msf_to_lba(int m, int s, int f);
|
||||
|
||||
/** Convert an lba to minute-second-frame (MSF)
|
||||
@param lba The lba
|
||||
@param m Returns the minute component
|
||||
@param s Returns the second component
|
||||
@param f Returns the frame component
|
||||
*/
|
||||
void burn_lba_to_msf(int lba, int *m, int *s, int *f);
|
||||
|
||||
/** Create a new disc (for DAO recording)*/
|
||||
struct burn_disc *burn_disc_create(void);
|
||||
|
||||
/** Delete disc and decrease the reference count on all its sessions
|
||||
@param d The disc to be freed
|
||||
*/
|
||||
void burn_disc_free(struct burn_disc *d);
|
||||
|
||||
/** Create a new session (For SAO at once recording, or to be added to a
|
||||
disc for DAO)
|
||||
*/
|
||||
struct burn_session *burn_session_create(void);
|
||||
|
||||
/** Free a session (and decrease reference count on all tracks inside)
|
||||
@param s Session to be freed
|
||||
*/
|
||||
void burn_session_free(struct burn_session *s);
|
||||
|
||||
/** Add a session to a disc at a specific position, increasing the
|
||||
sessions's reference count.
|
||||
@param d Disc to add the session to
|
||||
@param s Session to add to the disc
|
||||
@param pos position to add at (BURN_POS_END is "at the end")
|
||||
@return 0 for failure, 1 for success
|
||||
*/
|
||||
int burn_disc_add_session(struct burn_disc *d, struct burn_session *s,
|
||||
unsigned int pos);
|
||||
|
||||
/** Remove a session from a disc
|
||||
@param d Disc to remove session from
|
||||
@param s Session pointer to find and remove
|
||||
*/
|
||||
int burn_disc_remove_session(struct burn_disc *d, struct burn_session *s);
|
||||
|
||||
|
||||
/** Create a track (for TAO recording, or to put in a session) */
|
||||
struct burn_track *burn_track_create(void);
|
||||
|
||||
/** Free a track
|
||||
@param t Track to free
|
||||
*/
|
||||
void burn_track_free(struct burn_track *t);
|
||||
|
||||
/** Add a track to a session at specified position
|
||||
@param s Session to add to
|
||||
@param t Track to insert in session
|
||||
@param pos position to add at (BURN_POS_END is "at the end")
|
||||
@return 0 for failure, 1 for success
|
||||
*/
|
||||
int burn_session_add_track(struct burn_session *s, struct burn_track *t,
|
||||
unsigned int pos);
|
||||
|
||||
/** Remove a track from a session
|
||||
@param s Session to remove track from
|
||||
@param t Track pointer to find and remove
|
||||
@return 0 for failure, 1 for success
|
||||
*/
|
||||
int burn_session_remove_track(struct burn_session *s, struct burn_track *t);
|
||||
|
||||
|
||||
/** Define the data in a track
|
||||
@param t the track to define
|
||||
@param offset The lib will write this many 0s before start of data
|
||||
@param tail The number of extra 0s to write after data
|
||||
@param pad 1 means the lib should pad the last sector with 0s if the
|
||||
track isn't exactly sector sized. (otherwise the lib will
|
||||
begin reading from the next track)
|
||||
@param mode data format (bitfield)
|
||||
*/
|
||||
void burn_track_define_data(struct burn_track *t, int offset, int tail,
|
||||
int pad, int mode);
|
||||
|
||||
/** Set the ISRC details for a track
|
||||
@param t The track to change
|
||||
@param country the 2 char country code. Each character must be
|
||||
only numbers or letters.
|
||||
@param owner 3 char owner code. Each character must be only numbers
|
||||
or letters.
|
||||
@param year 2 digit year. A number in 0-99 (Yep, not Y2K friendly).
|
||||
@param serial 5 digit serial number. A number in 0-99999.
|
||||
*/
|
||||
void burn_track_set_isrc(struct burn_track *t, char *country, char *owner,
|
||||
unsigned char year, unsigned int serial);
|
||||
|
||||
/** Disable ISRC parameters for a track
|
||||
@param t The track to change
|
||||
*/
|
||||
void burn_track_clear_isrc(struct burn_track *t);
|
||||
|
||||
/** Hide the first track in the "pre gap" of the disc
|
||||
@param s session to change
|
||||
@param onoff 1 to enable hiding, 0 to disable
|
||||
*/
|
||||
void burn_session_hide_first_track(struct burn_session *s, int onoff);
|
||||
|
||||
/** Get the drive's disc struct - free when done
|
||||
@param d drive to query
|
||||
@return the disc struct
|
||||
*/
|
||||
struct burn_disc *burn_drive_get_disc(struct burn_drive *d);
|
||||
|
||||
/** Set the track's data source
|
||||
@param t The track to set the data source for
|
||||
@param s The data source to use for the contents of the track
|
||||
@return An error code stating if the source is ready for use for
|
||||
writing the track, or if an error occured
|
||||
|
||||
*/
|
||||
enum burn_source_status burn_track_set_source(struct burn_track *t,
|
||||
struct burn_source *s);
|
||||
|
||||
/** Free a burn_source (decrease its refcount and maybe free it)
|
||||
@param s Source to free
|
||||
*/
|
||||
void burn_source_free(struct burn_source *s);
|
||||
|
||||
/** Creates a data source for an image file (and maybe subcode file) */
|
||||
struct burn_source *burn_file_source_new(const char *path,
|
||||
const char *subpath);
|
||||
|
||||
/** Creates a data source for an image file (resp. a track) from an open
|
||||
readable filedescriptor, an eventually open readable subcodes file
|
||||
descriptor and eventually a fixed size in bytes.
|
||||
@param datafd The source of data.
|
||||
@param subfd The eventual source for subcodes. Not used if -1.
|
||||
@param size The eventual fixed size of eventually both fds.
|
||||
If this value is 0, the size will be determined from datafd.
|
||||
*/
|
||||
struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size);
|
||||
|
||||
/** Tells how long a track will be on disc */
|
||||
int burn_track_get_sectors(struct burn_track *);
|
||||
|
||||
|
||||
/** Sets drive read and write speed
|
||||
@param d The drive to set speed for
|
||||
@param read Read speed in k/s (0 is max)
|
||||
@param write Write speed in k/s (0 is max)
|
||||
*/
|
||||
void burn_drive_set_speed(struct burn_drive *d, int read, int write);
|
||||
|
||||
/* these are for my debugging, they will disappear */
|
||||
void burn_structure_print_disc(struct burn_disc *d);
|
||||
void burn_structure_print_session(struct burn_session *s);
|
||||
void burn_structure_print_track(struct burn_track *t);
|
||||
|
||||
/** Sets the write type for the write_opts struct
|
||||
@param opts The write opts to change
|
||||
@param write_type The write type to use
|
||||
@param block_type The block type to use
|
||||
@return Returns 1 on success and 0 on failure.
|
||||
*/
|
||||
int burn_write_opts_set_write_type(struct burn_write_opts *opts,
|
||||
enum burn_write_types write_type,
|
||||
int block_type);
|
||||
|
||||
/** Supplies toc entries for writing - not normally required for cd mastering
|
||||
@param opts The write opts to change
|
||||
@param count The number of entries
|
||||
@param toc_entries
|
||||
*/
|
||||
void burn_write_opts_set_toc_entries(struct burn_write_opts *opts,
|
||||
int count,
|
||||
struct burn_toc_entry *toc_entries);
|
||||
|
||||
/** Sets the session format for a disc
|
||||
@param opts The write opts to change
|
||||
@param format The session format to set
|
||||
*/
|
||||
void burn_write_opts_set_format(struct burn_write_opts *opts, int format);
|
||||
|
||||
/** Sets the simulate value for the write_opts struct
|
||||
@param opts The write opts to change
|
||||
@param sim If non-zero, the drive will perform a simulation instead of a burn
|
||||
@return Returns 1 on success and 0 on failure.
|
||||
*/
|
||||
int burn_write_opts_set_simulate(struct burn_write_opts *opts, int sim);
|
||||
|
||||
/** Controls buffer underrun prevention
|
||||
@param opts The write opts to change
|
||||
@param underrun_proof if non-zero, buffer underrun protection is enabled
|
||||
@return Returns 1 on success and 0 on failure.
|
||||
*/
|
||||
int burn_write_opts_set_underrun_proof(struct burn_write_opts *opts,
|
||||
int underrun_proof);
|
||||
|
||||
/** Sets whether to use opc or not with the write_opts struct
|
||||
@param opts The write opts to change
|
||||
@param opc If non-zero, optical power calibration will be performed at
|
||||
start of burn
|
||||
|
||||
*/
|
||||
void burn_write_opts_set_perform_opc(struct burn_write_opts *opts, int opc);
|
||||
|
||||
void burn_write_opts_set_has_mediacatalog(struct burn_write_opts *opts, int has_mediacatalog);
|
||||
|
||||
void burn_write_opts_set_mediacatalog(struct burn_write_opts *opts, unsigned char mediacatalog[13]);
|
||||
|
||||
/** Sets whether to read in raw mode or not
|
||||
@param opts The read opts to change
|
||||
@param raw_mode If non-zero, reading will be done in raw mode, so that everything in the data tracks on the
|
||||
disc is read, including headers.
|
||||
*/
|
||||
void burn_read_opts_set_raw(struct burn_read_opts *opts, int raw_mode);
|
||||
|
||||
/** Sets whether to report c2 errors or not
|
||||
@param opts The read opts to change
|
||||
@param c2errors If non-zero, report c2 errors.
|
||||
*/
|
||||
void burn_read_opts_set_c2errors(struct burn_read_opts *opts, int c2errors);
|
||||
|
||||
/** Sets whether to read subcodes from audio tracks or not
|
||||
@param opts The read opts to change
|
||||
@param subcodes_audio If non-zero, read subcodes from audio tracks on the disc.
|
||||
*/
|
||||
void burn_read_opts_read_subcodes_audio(struct burn_read_opts *opts,
|
||||
int subcodes_audio);
|
||||
|
||||
/** Sets whether to read subcodes from data tracks or not
|
||||
@param opts The read opts to change
|
||||
@param subcodes_data If non-zero, read subcodes from data tracks on the disc.
|
||||
*/
|
||||
void burn_read_opts_read_subcodes_data(struct burn_read_opts *opts,
|
||||
int subcodes_data);
|
||||
|
||||
/** Sets whether to recover errors if possible
|
||||
@param opts The read opts to change
|
||||
@param hardware_error_recovery If non-zero, attempt to recover errors if possible.
|
||||
*/
|
||||
void burn_read_opts_set_hardware_error_recovery(struct burn_read_opts *opts,
|
||||
int hardware_error_recovery);
|
||||
|
||||
/** Sets whether to report recovered errors or not
|
||||
@param opts The read opts to change
|
||||
@param report_recovered_errors If non-zero, recovered errors will be reported.
|
||||
*/
|
||||
void burn_read_opts_report_recovered_errors(struct burn_read_opts *opts,
|
||||
int report_recovered_errors);
|
||||
|
||||
/** Sets whether blocks with unrecoverable errors should be read or not
|
||||
@param opts The read opts to change
|
||||
@param transfer_damaged_blocks If non-zero, blocks with unrecoverable errors will still be read.
|
||||
*/
|
||||
void burn_read_opts_transfer_damaged_blocks(struct burn_read_opts *opts,
|
||||
int transfer_damaged_blocks);
|
||||
|
||||
/** Sets the number of retries to attempt when trying to correct an error
|
||||
@param opts The read opts to change
|
||||
@param hardware_error_retries The number of retries to attempt when correcting an error.
|
||||
*/
|
||||
void burn_read_opts_set_hardware_error_retries(struct burn_read_opts *opts,
|
||||
unsigned char hardware_error_retries);
|
||||
|
||||
/** Gets the maximum write speed for a drive
|
||||
@param d Drive to query
|
||||
@return Maximum write speed in K/s
|
||||
*/
|
||||
int burn_drive_get_write_speed(struct burn_drive *d);
|
||||
|
||||
/** Gets the maximum read speed for a drive
|
||||
@param d Drive to query
|
||||
@return Maximum read speed in K/s
|
||||
*/
|
||||
int burn_drive_get_read_speed(struct burn_drive *d);
|
||||
|
||||
/** Gets a copy of the toc_entry structure associated with a track
|
||||
@param t Track to get the entry from
|
||||
@param entry Struct for the library to fill out
|
||||
*/
|
||||
void burn_track_get_entry(struct burn_track *t, struct burn_toc_entry *entry);
|
||||
|
||||
/** Gets a copy of the toc_entry structure associated with a session's lead out
|
||||
@param s Session to get the entry from
|
||||
@param entry Struct for the library to fill out
|
||||
*/
|
||||
void burn_session_get_leadout_entry(struct burn_session *s,
|
||||
struct burn_toc_entry *entry);
|
||||
|
||||
/** Gets an array of all the sessions for the disc
|
||||
THIS IS NO LONGER VALID AFTER YOU ADD OR REMOVE A SESSION
|
||||
@param d Disc to get session array for
|
||||
@param num Returns the number of sessions in the array
|
||||
@return array of sessions
|
||||
*/
|
||||
struct burn_session **burn_disc_get_sessions(struct burn_disc *d,
|
||||
int *num);
|
||||
|
||||
int burn_disc_get_sectors(struct burn_disc *d);
|
||||
|
||||
/** Gets an array of all the tracks for a session
|
||||
THIS IS NO LONGER VALID AFTER YOU ADD OR REMOVE A TRACK
|
||||
@param s session to get track array for
|
||||
@param num Returns the number of tracks in the array
|
||||
@return array of tracks
|
||||
*/
|
||||
struct burn_track **burn_session_get_tracks(struct burn_session *s,
|
||||
int *num);
|
||||
|
||||
int burn_session_get_sectors(struct burn_session *s);
|
||||
|
||||
/** Gets the mode of a track
|
||||
@param track the track to query
|
||||
@return the track's mode
|
||||
*/
|
||||
int burn_track_get_mode(struct burn_track *track);
|
||||
|
||||
/** Returns whether the first track of a session is hidden in the pregap
|
||||
@param session the session to query
|
||||
@return non-zero means the first track is hidden
|
||||
*/
|
||||
int burn_session_get_hidefirst(struct burn_session *session);
|
||||
|
||||
/** Returns the library's version in its parts
|
||||
@param major The major version number
|
||||
@param minor The minor version number
|
||||
@param micro The micro version number
|
||||
*/
|
||||
void burn_version(int *major, int *minor, int *micro);
|
||||
|
||||
#ifndef DOXYGEN
|
||||
|
||||
BURN_END_DECLS
|
||||
|
||||
#endif
|
||||
|
||||
#endif /*LIBBURN_H*/
|
@ -1,340 +0,0 @@
|
||||
/* vim: set noet ts=8 sts=8 sw=8 : */
|
||||
|
||||
#include "struct.h"
|
||||
#include "util.h"
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
struct struct_element {
|
||||
uint8_t ch;
|
||||
|
||||
int bytes; /* The number of bytes in the value to convert
|
||||
* from/to. */
|
||||
uint8_t end; /* The endianness specifier. */
|
||||
int mul; /* The number of values to convert. */
|
||||
|
||||
union { /* Pointer to the value. */
|
||||
uint8_t *val8;
|
||||
uint16_t *val16;
|
||||
uint32_t *val32;
|
||||
time_t *time;
|
||||
} val;
|
||||
};
|
||||
|
||||
/* check if a character is a valid endian-ness specifier */
|
||||
#define isend(a) ((a) == '=' || (a) == '<' || (a) == '>')
|
||||
|
||||
static int iso_struct_element_make(struct struct_element *elem,
|
||||
int mul,
|
||||
char end,
|
||||
char ch)
|
||||
{
|
||||
if (!end) {
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
elem->end = '>'; /* default endianness is native */
|
||||
#else
|
||||
elem->end = '<';
|
||||
#endif
|
||||
} else {
|
||||
elem->end = end;
|
||||
}
|
||||
|
||||
elem->ch = ch;
|
||||
elem->mul = mul;
|
||||
elem->val.val8 = NULL;
|
||||
switch(toupper(ch)) {
|
||||
case 'X':
|
||||
case 'B':
|
||||
elem->bytes = 1;
|
||||
break;
|
||||
case 'H':
|
||||
elem->bytes = 2;
|
||||
break;
|
||||
case 'L':
|
||||
elem->bytes = 4;
|
||||
break;
|
||||
case 'S':
|
||||
elem->bytes = 7;
|
||||
elem->end = '<';
|
||||
break;
|
||||
case 'T':
|
||||
elem->bytes = 17;
|
||||
elem->end = '<';
|
||||
break;
|
||||
default:
|
||||
elem->bytes = -1;
|
||||
break;
|
||||
}
|
||||
return elem->bytes * elem->mul * ((elem->end == '=') ? 2 : 1);
|
||||
}
|
||||
|
||||
static int iso_struct_element_make_v(struct struct_element *elem,
|
||||
va_list *ap)
|
||||
{
|
||||
int mul = va_arg(*ap, int);
|
||||
int end = va_arg(*ap, int);
|
||||
int ch = va_arg(*ap, int);
|
||||
return iso_struct_element_make(elem, mul, end, ch);
|
||||
}
|
||||
|
||||
static int iso_struct_element_parse(const char **ffmt,
|
||||
struct struct_element *elem)
|
||||
{
|
||||
off_t pos;
|
||||
const char *fmt = *ffmt;
|
||||
int mul;
|
||||
char end = 0;
|
||||
|
||||
mul = 1;
|
||||
for (pos=0; isdigit(fmt[pos]) || isend(fmt[pos]); pos++) {
|
||||
if (isdigit(fmt[pos])) {
|
||||
mul = atoi( fmt + pos );
|
||||
while (isdigit(fmt[pos+1])) pos++;
|
||||
} else {
|
||||
end = fmt[pos];
|
||||
}
|
||||
}
|
||||
|
||||
(*ffmt) += pos + 1;
|
||||
|
||||
return iso_struct_element_make(elem, mul, end, fmt[pos]);
|
||||
}
|
||||
|
||||
/* read a single integer from data[i] to elem[i], interpreting the endian-ness
|
||||
* and offset appropriately. */
|
||||
static uint32_t iso_struct_element_read_int(struct struct_element *elem,
|
||||
const uint8_t *data,
|
||||
int i)
|
||||
{
|
||||
uint32_t el;
|
||||
|
||||
switch(elem->end) {
|
||||
case '>':
|
||||
el = iso_read_msb(data + i*elem->bytes, elem->bytes);
|
||||
break;
|
||||
case '<':
|
||||
el = iso_read_lsb(data + i*elem->bytes, elem->bytes);
|
||||
break;
|
||||
case '=':
|
||||
el = iso_read_bb(data + i*elem->bytes*2, elem->bytes);
|
||||
}
|
||||
|
||||
switch(elem->bytes) {
|
||||
case 1:
|
||||
elem->val.val8[i] = el;
|
||||
break;
|
||||
case 2:
|
||||
elem->val.val16[i] = el;
|
||||
break;
|
||||
case 4:
|
||||
elem->val.val32[i] = el;
|
||||
break;
|
||||
}
|
||||
|
||||
return el;
|
||||
}
|
||||
|
||||
/* write a single integer from elem[i] to data[i]. */
|
||||
static uint32_t iso_struct_element_write1(struct struct_element *elem,
|
||||
uint8_t *data,
|
||||
int i)
|
||||
{
|
||||
uint32_t el;
|
||||
|
||||
switch(elem->bytes) {
|
||||
case 1:
|
||||
el = elem->val.val8[i];
|
||||
break;
|
||||
case 2:
|
||||
el = elem->val.val16[i];
|
||||
break;
|
||||
case 4:
|
||||
el = elem->val.val32[i];
|
||||
break;
|
||||
}
|
||||
|
||||
switch(elem->end) {
|
||||
case '>':
|
||||
iso_msb(data + i*elem->bytes, el, elem->bytes);
|
||||
break;
|
||||
case '<':
|
||||
iso_lsb(data + i*elem->bytes, el, elem->bytes);
|
||||
break;
|
||||
case '=':
|
||||
iso_bb(data + i*elem->bytes*2, el, elem->bytes);
|
||||
}
|
||||
|
||||
return el;
|
||||
}
|
||||
|
||||
static int iso_struct_element_read(struct struct_element *elem,
|
||||
const uint8_t *data)
|
||||
{
|
||||
int size = elem->bytes * ((elem->end == '=') ? 2 : 1);
|
||||
int i;
|
||||
|
||||
if (elem->ch == 'x') {
|
||||
return size * elem->mul;
|
||||
}
|
||||
|
||||
for (i=0; i<elem->mul; i++) {
|
||||
switch(toupper(elem->ch)) {
|
||||
case 'S':
|
||||
/*
|
||||
elem->val.time[i] = iso_datetime_read_7(&data[i*7]);
|
||||
*/
|
||||
break;
|
||||
case 'T':
|
||||
/*
|
||||
elem->val.time[i] = iso_datetime_read_17(&data[i*17]);
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
iso_struct_element_read_int(elem, data, i);
|
||||
}
|
||||
}
|
||||
|
||||
return size * elem->mul;
|
||||
}
|
||||
|
||||
static int iso_struct_element_write(struct struct_element *elem,
|
||||
uint8_t *data)
|
||||
{
|
||||
int size = elem->bytes * ((elem->end == '=') ? 2 : 1);
|
||||
int i;
|
||||
uint32_t ret;
|
||||
|
||||
if (elem->ch == 'x') {
|
||||
return size*elem->mul;
|
||||
}
|
||||
|
||||
for (i=0; i<elem->mul; i++) {
|
||||
switch(toupper(elem->ch)) {
|
||||
case 'S':
|
||||
iso_datetime_7(&data[i*7], elem->val.time[i]);
|
||||
ret = elem->val.time[i];
|
||||
break;
|
||||
case 'T':
|
||||
iso_datetime_17(&data[i*17], elem->val.time[i]);
|
||||
ret = elem->val.time[i];
|
||||
break;
|
||||
default:
|
||||
ret = iso_struct_element_write1(elem, data, i);
|
||||
break;
|
||||
}
|
||||
|
||||
if (islower(elem->ch) && ret == 0) {
|
||||
memset(data + size*i, 0, size*(elem->mul-i));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return size * elem->mul;
|
||||
}
|
||||
|
||||
int iso_struct_unpack(const char *fmt, const uint8_t *data, ...)
|
||||
{
|
||||
int num_conv;
|
||||
int ret;
|
||||
va_list ap;
|
||||
struct struct_element elem;
|
||||
off_t off;
|
||||
|
||||
va_start(ap, data);
|
||||
num_conv = 0;
|
||||
off = 0;
|
||||
while(*fmt) {
|
||||
ret = iso_struct_element_parse(&fmt, &elem);
|
||||
if (ret < 0) {
|
||||
va_end(ap);
|
||||
return -1;
|
||||
}
|
||||
if (elem.ch != 'x') {
|
||||
elem.val.val8 = va_arg(ap, void*);
|
||||
}
|
||||
off += iso_struct_element_read(&elem, data + off);
|
||||
num_conv++;
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
return num_conv;
|
||||
}
|
||||
|
||||
int iso_struct_pack(const char *fmt, uint8_t *data, ...)
|
||||
{
|
||||
int num_conv;
|
||||
int ret;
|
||||
va_list ap;
|
||||
struct struct_element elem;
|
||||
off_t off;
|
||||
|
||||
va_start(ap, data);
|
||||
num_conv = 0;
|
||||
off = 0;
|
||||
while(*fmt) {
|
||||
ret = iso_struct_element_parse(&fmt, &elem);
|
||||
if (ret < 0) {
|
||||
va_end(ap);
|
||||
return -1;
|
||||
}
|
||||
if (elem.ch != 'x') {
|
||||
elem.val.val8 = va_arg(ap, void*);
|
||||
}
|
||||
off += iso_struct_element_write(&elem, data + off);
|
||||
num_conv++;
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
return num_conv;
|
||||
}
|
||||
|
||||
int iso_struct_pack_long(uint8_t *data, ...)
|
||||
{
|
||||
int num_conv;
|
||||
int ret;
|
||||
int i, j;
|
||||
va_list ap;
|
||||
struct struct_element *elem = NULL;
|
||||
off_t off;
|
||||
|
||||
va_start(ap, data);
|
||||
num_conv = 0;
|
||||
off = 0;
|
||||
|
||||
elem = calloc(1, sizeof(struct struct_element));
|
||||
i=0;
|
||||
while ((ret = iso_struct_element_make_v(&elem[i], &ap) > 0)) {
|
||||
elem = realloc(elem, (++i + 1) * sizeof(struct struct_element));
|
||||
}
|
||||
for (j=0; j<i; j++) {
|
||||
if (elem[j].ch != 'x') {
|
||||
elem[j].val.val8 = va_arg(ap, void*);
|
||||
}
|
||||
off += iso_struct_element_write(&elem[j], data + off);
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
if (ret < 0) {
|
||||
return -1;
|
||||
}
|
||||
return num_conv;
|
||||
}
|
||||
|
||||
int iso_struct_calcsize(const char *fmt)
|
||||
{
|
||||
int ret, total;
|
||||
struct struct_element elem;
|
||||
|
||||
total = 0;
|
||||
while (*fmt) {
|
||||
ret = iso_struct_element_parse(&fmt, &elem);
|
||||
if (ret < 0) {
|
||||
return -1;
|
||||
}
|
||||
total += ret;
|
||||
}
|
||||
return total;
|
||||
}
|
@ -1,77 +0,0 @@
|
||||
/* vim: set noet ts=8 sts=8 sw=8 : */
|
||||
|
||||
/**
|
||||
* \file struct.h
|
||||
* Add functionality similar to the python "struct" module to make it easier
|
||||
* to read and write .iso structures.
|
||||
*
|
||||
* The following conversions are supported:
|
||||
* B uint8_t, the arg should be (uint8_t*)
|
||||
* H uint16_t, the arg should be (uint16_t*)
|
||||
* L uint32_t, the arg should be (uint32_t*)
|
||||
* S a 7-byte timestamp, the arg should be (time_t*)
|
||||
* T a 17-byte timestamp, the arg should be (time_t*)
|
||||
* x ignored field, no arg should be specified
|
||||
*
|
||||
* Any of the first 3 conversions may be preceded by a endian specifier:
|
||||
* < little-endian
|
||||
* > big-endian
|
||||
* = both-endian (ie. according to ecma119 7.2.3 or 7.3.3)
|
||||
*
|
||||
* Each conversion specifier may also be preceded by a length specifier. For
|
||||
* example, "<5L" specifies an array of 5 little-endian 32-bit integers. Note
|
||||
* that "=L" takes 8 bytes while "<L" and ">L" each take 4.
|
||||
*
|
||||
* You can use a lower-case conversion specifier instead of an upper-case one
|
||||
* to signify that the (multi-element) conversion should stop when a zero is
|
||||
* reached. This is useful for writing out NULL-terminated strings. Note that
|
||||
* this has no effect when unpacking data from a struct.
|
||||
*/
|
||||
|
||||
#ifndef __ISO_STRUCT
|
||||
#define __ISO_STRUCT
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* Unpack a struct into its components. The list of components is a list of
|
||||
* pointers to the variables to write.
|
||||
*
|
||||
* For example:
|
||||
* uint8_t byte1, byte2;
|
||||
* uint16_t uint;
|
||||
* iso_struct_unpack("BB=H", data, &byte1, &byte2, &uint);
|
||||
*
|
||||
* \return The number of conversions performed, or -1 on error.
|
||||
*/
|
||||
int iso_struct_unpack(const char *fmt, const uint8_t *data, ...);
|
||||
|
||||
/**
|
||||
* Write out a struct from its components. The list of components is a list of
|
||||
* pointers to the variables to write and the buffer to which to write
|
||||
* is assumed to be large
|
||||
* enough to take the data.
|
||||
*
|
||||
* \return The number of conversions performed, or -1 on error.
|
||||
*/
|
||||
int iso_struct_pack(const char *fmt, uint8_t *data, ...);
|
||||
|
||||
/**
|
||||
* Achieves the same effect as iso_struct_pack(), but the format is passed as
|
||||
* a sequence of (int, char, char) triples. This list is terminated by
|
||||
* (0, 0, 0) and the list of parameters follows.
|
||||
*
|
||||
* Example: iso_struct_pack_long(data, 4, '=', 'H', 0, 0, 0, &val) is the same
|
||||
* as iso_struct_pack("4=H", 0, 0, 0, &val)
|
||||
*/
|
||||
int iso_struct_pack_long(uint8_t *data, ...);
|
||||
|
||||
/**
|
||||
* Calculate the size of a given format string.
|
||||
*
|
||||
* \return The sum of the length of all formats in the string, in bytes. Return
|
||||
* -1 on error.
|
||||
*/
|
||||
int iso_struct_calcsize(const char *fmt);
|
||||
|
||||
#endif
|
138
libisofs/test.c
138
libisofs/test.c
@ -1,138 +0,0 @@
|
||||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
|
||||
/* vim: set ts=8 sts=8 sw=8 noet : */
|
||||
|
||||
#define _GNU_SOURCE
|
||||
|
||||
#include "libisofs/libisofs.h"
|
||||
#include "libburn/libburn.h"
|
||||
#include <getopt.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <assert.h>
|
||||
#include <sys/types.h>
|
||||
#include <dirent.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define SECSIZE 2048
|
||||
|
||||
const char * const optstring = "JRL:h";
|
||||
extern char *optarg;
|
||||
extern int optind;
|
||||
|
||||
void usage()
|
||||
{
|
||||
printf("test [OPTIONS] DIRECTORY OUTPUT\n");
|
||||
}
|
||||
|
||||
void help()
|
||||
{
|
||||
printf(
|
||||
"Options:\n"
|
||||
" -J Add Joliet support\n"
|
||||
" -R Add Rock Ridge support\n"
|
||||
" -L <num> Set the ISO level (1 or 2)\n"
|
||||
" -h Print this message\n"
|
||||
);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct iso_volset *volset;
|
||||
struct iso_volume *volume;
|
||||
struct burn_source *src;
|
||||
unsigned char buf[2048];
|
||||
FILE *fd;
|
||||
int c;
|
||||
int level=1, flags=0;
|
||||
DIR *dir;
|
||||
struct dirent *ent;
|
||||
|
||||
while ((c = getopt(argc, argv, optstring)) != -1) {
|
||||
switch(c) {
|
||||
case 'h':
|
||||
usage();
|
||||
help();
|
||||
exit(0);
|
||||
break;
|
||||
case 'J':
|
||||
flags |= ECMA119_JOLIET;
|
||||
break;
|
||||
case 'R':
|
||||
flags |= ECMA119_ROCKRIDGE;
|
||||
break;
|
||||
case 'L':
|
||||
level = atoi(optarg);
|
||||
break;
|
||||
case '?':
|
||||
usage();
|
||||
exit(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc < 2) {
|
||||
printf ("must pass directory to build iso from\n");
|
||||
usage();
|
||||
return 1;
|
||||
}
|
||||
if (argc < 3) {
|
||||
printf ("must supply output file\n");
|
||||
usage();
|
||||
return 1;
|
||||
}
|
||||
fd = fopen(argv[optind+1], "w");
|
||||
if (!fd) {
|
||||
perror("error opening output file");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
volume = iso_volume_new( "VOLID", "PUBID", "PREPID" );
|
||||
volset = iso_volset_new( volume, "VOLSETID" );
|
||||
dir = opendir(argv[optind]);
|
||||
if (!dir) {
|
||||
perror("error opening input directory");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
while ( (ent = readdir(dir)) ) {
|
||||
struct stat st;
|
||||
char *name;
|
||||
|
||||
if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) {
|
||||
continue;
|
||||
}
|
||||
|
||||
name = malloc(strlen(argv[optind]) + strlen(ent->d_name) + 2);
|
||||
strcpy(name, argv[optind]);
|
||||
strcat(name, "/");
|
||||
strcat(name, ent->d_name);
|
||||
if (lstat(name, &st) == -1) {
|
||||
fprintf(stderr, "error opening file %s: %s\n",
|
||||
name, strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
iso_tree_radd_dir(iso_volume_get_root(volume), name);
|
||||
} else {
|
||||
iso_tree_add_file(iso_volume_get_root(volume), name);
|
||||
}
|
||||
free(name);
|
||||
}
|
||||
|
||||
iso_tree_print(iso_volume_get_root(volume), 0);
|
||||
|
||||
src = iso_source_new_ecma119(volset, 0, level, flags);
|
||||
|
||||
while (src->read(src, buf, 2048) == 2048) {
|
||||
fwrite(buf, 1, 2048, fd);
|
||||
}
|
||||
fclose(fd);
|
||||
|
||||
return 0;
|
||||
}
|