965 lines
22 KiB
C
965 lines
22 KiB
C
|
|
/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
|
|
Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
|
|
Provided under GPL version 2 or later.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "../config.h"
|
|
#endif
|
|
|
|
/* ts A61008 */
|
|
/* #include <a ssert.h> */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include "libburn.h"
|
|
#include "structure.h"
|
|
#include "write.h"
|
|
#include "debug.h"
|
|
#include "init.h"
|
|
|
|
#include "libdax_msgs.h"
|
|
extern struct libdax_msgs *libdax_messenger;
|
|
|
|
|
|
/* ts A61008 : replaced Assert by if and return 0 */
|
|
/* a ssert(!(pos > BURN_POS_END)); */
|
|
|
|
#define RESIZE(TO, NEW, pos) {\
|
|
void *tmp;\
|
|
\
|
|
if (pos > BURN_POS_END)\
|
|
return 0;\
|
|
if (pos == BURN_POS_END)\
|
|
pos = TO->NEW##s;\
|
|
if ((int) pos > TO->NEW##s)\
|
|
return 0;\
|
|
\
|
|
tmp = realloc(TO->NEW, sizeof(struct NEW *) * (TO->NEW##s + 1));\
|
|
if (!tmp)\
|
|
return 0;\
|
|
TO->NEW = tmp;\
|
|
memmove(TO->NEW + pos + 1, TO->NEW + pos,\
|
|
sizeof(struct NEW *) * (TO->NEW##s - pos));\
|
|
TO->NEW##s++;\
|
|
}
|
|
|
|
struct burn_disc *burn_disc_create(void)
|
|
{
|
|
struct burn_disc *d;
|
|
d = calloc(1, sizeof(struct burn_disc));
|
|
if (d == NULL) /* ts A70825 */
|
|
return NULL;
|
|
d->refcnt = 1;
|
|
d->sessions = 0;
|
|
d->session = NULL;
|
|
return d;
|
|
}
|
|
|
|
void burn_disc_free(struct burn_disc *d)
|
|
{
|
|
d->refcnt--;
|
|
if (d->refcnt == 0) {
|
|
/* dec refs on all elements */
|
|
int i;
|
|
|
|
for (i = 0; i < d->sessions; i++)
|
|
burn_session_free(d->session[i]);
|
|
free(d->session);
|
|
free(d);
|
|
}
|
|
}
|
|
|
|
struct burn_session *burn_session_create(void)
|
|
{
|
|
struct burn_session *s;
|
|
int i;
|
|
|
|
s = calloc(1, sizeof(struct burn_session));
|
|
if (s == NULL) /* ts A70825 */
|
|
return NULL;
|
|
s->refcnt = 1;
|
|
s->tracks = 0;
|
|
s->track = NULL;
|
|
s->hidefirst = 0;
|
|
for (i = 0; i < 8; i++) {
|
|
s->cdtext[i] = NULL;
|
|
s->cdtext_language[i] = 0x00; /* Unknown */
|
|
s->cdtext_char_code[i] = 0x00; /* ISO-8859-1 */
|
|
s->cdtext_copyright[i] = 0x00;
|
|
}
|
|
s->cdtext_language[0] = 0x09; /* Single-block default is English */
|
|
return s;
|
|
}
|
|
|
|
void burn_session_hide_first_track(struct burn_session *s, int onoff)
|
|
{
|
|
s->hidefirst = onoff;
|
|
}
|
|
|
|
void burn_session_free(struct burn_session *s)
|
|
{
|
|
int i;
|
|
|
|
s->refcnt--;
|
|
if (s->refcnt == 0) {
|
|
/* dec refs on all elements */
|
|
for (i = 0; i < s->tracks; i++)
|
|
burn_track_free(s->track[i]);
|
|
for (i = 0; i < 8; i++)
|
|
burn_cdtext_free(&(s->cdtext[i]));
|
|
free(s->track);
|
|
free(s);
|
|
}
|
|
|
|
}
|
|
|
|
int burn_disc_add_session(struct burn_disc *d, struct burn_session *s,
|
|
unsigned int pos)
|
|
{
|
|
RESIZE(d, session, pos);
|
|
d->session[pos] = s;
|
|
s->refcnt++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts A81202: this function was in the API but not implemented.
|
|
*/
|
|
int burn_disc_remove_session(struct burn_disc *d, struct burn_session *s)
|
|
{
|
|
int i, skip = 0;
|
|
|
|
if (d->session == NULL)
|
|
return 0;
|
|
for (i = 0; i < d->sessions; i++) {
|
|
if (s == d->session[i]) {
|
|
skip++;
|
|
continue;
|
|
}
|
|
d->session[i - skip] = d->session[i];
|
|
}
|
|
if (!skip)
|
|
return 0;
|
|
burn_session_free(s);
|
|
d->sessions--;
|
|
return 1;
|
|
}
|
|
|
|
|
|
struct burn_track *burn_track_create(void)
|
|
{
|
|
struct burn_track *t;
|
|
int i;
|
|
|
|
t = calloc(1, sizeof(struct burn_track));
|
|
if (t == NULL) /* ts A70825 */
|
|
return NULL;
|
|
t->refcnt = 1;
|
|
t->indices = 0;
|
|
t->offset = 0;
|
|
t->offsetcount = 0;
|
|
t->tail = 0;
|
|
t->tailcount = 0;
|
|
t->mode = BURN_MODE1;
|
|
t->isrc.has_isrc = 0;
|
|
t->pad = 1;
|
|
|
|
/* ts A70213 */
|
|
t->fill_up_media = 0;
|
|
/* ts A70218 */
|
|
t->default_size = 0;
|
|
|
|
t->entry = NULL;
|
|
t->source = NULL;
|
|
t->eos = 0;
|
|
|
|
/* ts A61101 */
|
|
t->sourcecount = 0;
|
|
t->writecount = 0;
|
|
t->written_sectors = 0;
|
|
|
|
/* ts A61031 */
|
|
t->open_ended = 0;
|
|
t->track_data_done = 0;
|
|
/* ts B10103 */
|
|
t->end_on_premature_eoi = 0;
|
|
|
|
t->postgap = 0;
|
|
t->pregap1 = 0;
|
|
t->pregap2 = 0;
|
|
|
|
/* ts A61024 */
|
|
t->swap_source_bytes = 0;
|
|
|
|
/* ts B11206 */
|
|
for (i = 0; i < 8; i++)
|
|
t->cdtext[i] = NULL;
|
|
|
|
return t;
|
|
}
|
|
|
|
void burn_track_free(struct burn_track *t)
|
|
{
|
|
int i;
|
|
|
|
t->refcnt--;
|
|
if (t->refcnt == 0) {
|
|
/* dec refs on all elements */
|
|
if (t->source)
|
|
burn_source_free(t->source);
|
|
for (i = 0; i < 8; i++)
|
|
burn_cdtext_free(&(t->cdtext[i]));
|
|
free(t);
|
|
}
|
|
}
|
|
|
|
int burn_session_add_track(struct burn_session *s, struct burn_track *t,
|
|
unsigned int pos)
|
|
{
|
|
RESIZE(s, track, pos);
|
|
s->track[pos] = t;
|
|
t->refcnt++;
|
|
return 1;
|
|
}
|
|
|
|
int burn_session_remove_track(struct burn_session *s, struct burn_track *t)
|
|
{
|
|
struct burn_track **tmp;
|
|
int i, pos = -1;
|
|
|
|
/* ts A61008 */
|
|
/* a ssert(s->track != NULL); */
|
|
if (s->track == NULL)
|
|
return 0;
|
|
|
|
burn_track_free(t);
|
|
|
|
/* Find the position */
|
|
for (i = 0; i < s->tracks; i++) {
|
|
if (t == s->track[i]) {
|
|
pos = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pos == -1)
|
|
return 0;
|
|
|
|
/* Is it the last track? */
|
|
if (pos != s->tracks - 1) {
|
|
memmove(&s->track[pos], &s->track[pos + 1],
|
|
sizeof(struct burn_track *) * (s->tracks - (pos + 1)));
|
|
}
|
|
|
|
s->tracks--;
|
|
tmp = realloc(s->track, sizeof(struct burn_track *) * s->tracks);
|
|
if (tmp)
|
|
s->track = tmp;
|
|
return 1;
|
|
}
|
|
|
|
void burn_structure_print_disc(struct burn_disc *d)
|
|
{
|
|
int i;
|
|
char msg[40];
|
|
|
|
sprintf(msg, "This disc has %d sessions", d->sessions);
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
|
|
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
|
|
msg, 0, 0);
|
|
for (i = 0; i < d->sessions; i++) {
|
|
burn_structure_print_session(d->session[i]);
|
|
}
|
|
}
|
|
void burn_structure_print_session(struct burn_session *s)
|
|
{
|
|
int i;
|
|
char msg[40];
|
|
|
|
sprintf(msg, " Session has %d tracks", s->tracks);
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
|
|
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
|
|
msg, 0, 0);
|
|
for (i = 0; i < s->tracks; i++) {
|
|
burn_structure_print_track(s->track[i]);
|
|
}
|
|
}
|
|
void burn_structure_print_track(struct burn_track *t)
|
|
{
|
|
char msg[80];
|
|
|
|
sprintf(msg, " track size %d sectors",
|
|
burn_track_get_sectors(t));
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
|
|
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
|
|
msg, 0, 0);
|
|
}
|
|
|
|
void burn_track_define_data(struct burn_track *t, int offset, int tail,
|
|
int pad, int mode)
|
|
{
|
|
int type_to_form(int mode, unsigned char *ctladr, int *form);
|
|
int burn_sector_length(int tracktype);
|
|
unsigned char ctladr;
|
|
int form = -1; /* unchanged form will be considered an error too */
|
|
char msg[80];
|
|
|
|
type_to_form(mode, &ctladr, &form);
|
|
if (form == -1 || burn_sector_length(mode) <= 0) {
|
|
|
|
sprintf(msg,
|
|
"Attempt to set track mode to unusable value 0x%X",
|
|
(unsigned int) mode);
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00020115,
|
|
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
|
|
msg, 0, 0);
|
|
return;
|
|
}
|
|
|
|
t->offset = offset;
|
|
t->pad = pad;
|
|
t->mode = mode;
|
|
t->tail = tail;
|
|
}
|
|
|
|
|
|
/* ts A61024 */
|
|
int burn_track_set_byte_swap(struct burn_track *t, int swap_source_bytes)
|
|
{
|
|
if (swap_source_bytes != 0 && swap_source_bytes != 1)
|
|
return 0;
|
|
t->swap_source_bytes = swap_source_bytes;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts A90911 : API */
|
|
int burn_track_set_cdxa_conv(struct burn_track *t, int value)
|
|
{
|
|
if (value < 0 || value > 1)
|
|
return 0;
|
|
t->cdxa_conversion = value;
|
|
return 1;
|
|
}
|
|
|
|
|
|
void burn_track_set_isrc(struct burn_track *t, char *country, char *owner,
|
|
unsigned char year, unsigned int serial)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 2; ++i) {
|
|
|
|
/* ts A61008 : This is always true */
|
|
/* a ssert((country[i] >= '0' || country[i] < '9') &&
|
|
(country[i] >= 'a' || country[i] < 'z') &&
|
|
(country[i] >= 'A' || country[i] < 'Z')); */
|
|
/* ts A61008 : now coordinated with sector.c: char_to_isrc() */
|
|
if (! ((country[i] >= '0' && country[i] <= '9') ||
|
|
(country[i] >= 'a' && country[i] <= 'z') ||
|
|
(country[i] >= 'A' && country[i] <= 'Z') ) )
|
|
goto is_not_allowed;
|
|
|
|
t->isrc.country[i] = country[i];
|
|
}
|
|
for (i = 0; i < 3; ++i) {
|
|
|
|
/* ts A61008 : This is always true */
|
|
/* a ssert((owner[i] >= '0' || owner[i] < '9') &&
|
|
(owner[i] >= 'a' || owner[i] < 'z') &&
|
|
(owner[i] >= 'A' || owner[i] < 'Z')); */
|
|
/* ts A61008 : now coordinated with sector.c: char_to_isrc() */
|
|
if (! ((owner[i] >= '0' && owner[i] <= '9') ||
|
|
(owner[i] >= 'a' && owner[i] <= 'z') ||
|
|
(owner[i] >= 'A' && owner[i] <= 'Z') ) )
|
|
goto is_not_allowed;
|
|
|
|
t->isrc.owner[i] = owner[i];
|
|
}
|
|
|
|
/* ts A61008 */
|
|
/* a ssert(year <= 99); */
|
|
if (year > 99)
|
|
goto is_not_allowed;
|
|
|
|
t->isrc.year = year;
|
|
|
|
/* ts A61008 */
|
|
/* a ssert(serial <= 99999); */
|
|
if (serial > 99999)
|
|
goto is_not_allowed;
|
|
|
|
t->isrc.serial = serial;
|
|
|
|
/* ts A61008 */
|
|
t->isrc.has_isrc = 1;
|
|
return;
|
|
is_not_allowed:;
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00020114,
|
|
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
|
|
"Attempt to set ISRC with bad data", 0, 0);
|
|
return;
|
|
}
|
|
|
|
void burn_track_clear_isrc(struct burn_track *t)
|
|
{
|
|
t->isrc.has_isrc = 0;
|
|
}
|
|
|
|
int burn_track_get_sectors(struct burn_track *t)
|
|
{
|
|
/* ts A70125 : was int */
|
|
off_t size = 0;
|
|
int sectors, seclen;
|
|
|
|
seclen = burn_sector_length(t->mode);
|
|
|
|
if (t->cdxa_conversion == 1)
|
|
/* ts A90911 : will read blocks of 2056 bytes and write 2048 */
|
|
seclen += 8;
|
|
|
|
if (t->source != NULL) /* ts A80808 : mending sigsegv */
|
|
size = t->offset + t->source->get_size(t->source) + t->tail;
|
|
else if(t->entry != NULL) {
|
|
/* ts A80808 : all burn_toc_entry of track starts should now
|
|
have (extensions_valid & 1), even those from CD.
|
|
*/
|
|
if (t->entry->extensions_valid & 1)
|
|
size = ((off_t) t->entry->track_blocks) * (off_t) 2048;
|
|
}
|
|
sectors = size / seclen;
|
|
if (size % seclen)
|
|
sectors++;
|
|
return sectors;
|
|
}
|
|
|
|
|
|
/* ts A70125 */
|
|
int burn_track_set_sectors(struct burn_track *t, int sectors)
|
|
{
|
|
off_t size, seclen;
|
|
int ret;
|
|
|
|
seclen = burn_sector_length(t->mode);
|
|
size = seclen * (off_t) sectors - (off_t) t->offset - (off_t) t->tail;
|
|
if (size < 0)
|
|
return 0;
|
|
ret = t->source->set_size(t->source, size);
|
|
t->open_ended = (t->source->get_size(t->source) <= 0);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts A70218 , API since A70328 */
|
|
int burn_track_set_size(struct burn_track *t, off_t size)
|
|
{
|
|
if (t->source == NULL)
|
|
return 0;
|
|
if (t->source->set_size == NULL)
|
|
return 0;
|
|
t->open_ended = (size <= 0);
|
|
return t->source->set_size(t->source, size);
|
|
}
|
|
|
|
|
|
/* ts A70213 */
|
|
int burn_track_set_fillup(struct burn_track *t, int fill_up_media)
|
|
{
|
|
t->fill_up_media = fill_up_media;
|
|
if (fill_up_media)
|
|
t->open_ended = 0;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts A70213 */
|
|
/**
|
|
@param flag bit0= force new size even if existing track size is larger
|
|
*/
|
|
int burn_track_apply_fillup(struct burn_track *t, off_t max_size, int flag)
|
|
{
|
|
int max_sectors, ret = 2;
|
|
char msg[80];
|
|
|
|
if (t->fill_up_media <= 0)
|
|
return 2;
|
|
max_sectors = max_size / 2048;
|
|
if (burn_track_get_sectors(t) < max_sectors || (flag & 1)) {
|
|
sprintf(msg, "Setting total track size to %ds (payload %ds)\n",
|
|
max_sectors & 0x7fffffff,
|
|
(int) ((t->source->get_size(t->source) / 2048)
|
|
& 0x7fffffff));
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
|
|
LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
|
|
msg, 0, 0);
|
|
ret = burn_track_set_sectors(t, max_sectors);
|
|
t->open_ended = 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts A61031 */
|
|
int burn_track_is_open_ended(struct burn_track *t)
|
|
{
|
|
return !!t->open_ended;
|
|
}
|
|
|
|
|
|
/* ts A70218 : API */
|
|
int burn_track_set_default_size(struct burn_track *t, off_t size)
|
|
{
|
|
t->default_size = size;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts A70218 */
|
|
off_t burn_track_get_default_size(struct burn_track *t)
|
|
{
|
|
return t->default_size;
|
|
}
|
|
|
|
|
|
/* ts A61101 : API function */
|
|
int burn_track_get_counters(struct burn_track *t,
|
|
off_t *read_bytes, off_t *written_bytes)
|
|
{
|
|
/*
|
|
fprintf(stderr, "libburn_experimental: sizeof(off_t)=%d\n",
|
|
sizeof(off_t));
|
|
*/
|
|
*read_bytes = t->sourcecount;
|
|
*written_bytes = t->writecount;
|
|
return 1;
|
|
}
|
|
|
|
/* ts A61031 */
|
|
int burn_track_is_data_done(struct burn_track *t)
|
|
{
|
|
return !!t->track_data_done;
|
|
}
|
|
|
|
int burn_track_get_shortage(struct burn_track *t)
|
|
{
|
|
int size;
|
|
int seclen;
|
|
|
|
seclen = burn_sector_length(t->mode);
|
|
size = t->offset + t->source->get_size(t->source) + t->tail;
|
|
if (size % seclen)
|
|
return seclen - size % seclen;
|
|
return 0;
|
|
}
|
|
|
|
int burn_session_get_sectors(struct burn_session *s)
|
|
{
|
|
int sectors = 0, i;
|
|
|
|
for (i = 0; i < s->tracks; i++)
|
|
sectors += burn_track_get_sectors(s->track[i]);
|
|
return sectors;
|
|
}
|
|
|
|
|
|
int burn_disc_get_sectors(struct burn_disc *d)
|
|
{
|
|
int sectors = 0, i;
|
|
|
|
for (i = 0; i < d->sessions; i++)
|
|
sectors += burn_session_get_sectors(d->session[i]);
|
|
return sectors;
|
|
}
|
|
|
|
void burn_track_get_entry(struct burn_track *t, struct burn_toc_entry *entry)
|
|
{
|
|
if (t->entry == NULL)
|
|
memset(entry, 0, sizeof(struct burn_toc_entry));
|
|
else
|
|
memcpy(entry, t->entry, sizeof(struct burn_toc_entry));
|
|
}
|
|
|
|
void burn_session_get_leadout_entry(struct burn_session *s,
|
|
struct burn_toc_entry *entry)
|
|
{
|
|
if (s->leadout_entry == NULL)
|
|
memset(entry, 0, sizeof(struct burn_toc_entry));
|
|
else
|
|
memcpy(entry, s->leadout_entry, sizeof(struct burn_toc_entry));
|
|
}
|
|
|
|
struct burn_session **burn_disc_get_sessions(struct burn_disc *d, int *num)
|
|
{
|
|
*num = d->sessions;
|
|
return d->session;
|
|
}
|
|
|
|
struct burn_track **burn_session_get_tracks(struct burn_session *s, int *num)
|
|
{
|
|
*num = s->tracks;
|
|
return s->track;
|
|
}
|
|
|
|
int burn_track_get_mode(struct burn_track *track)
|
|
{
|
|
return track->mode;
|
|
}
|
|
|
|
int burn_session_get_hidefirst(struct burn_session *session)
|
|
{
|
|
return session->hidefirst;
|
|
}
|
|
|
|
|
|
/* ts A80808 : Enhance CD toc to DVD toc */
|
|
int burn_disc_cd_toc_extensions(struct burn_disc *d, int flag)
|
|
{
|
|
int sidx= 0, tidx= 0, ret;
|
|
struct burn_toc_entry *entry, *prev_entry= NULL;
|
|
/* ts A81126 : ticket 146 : There was a SIGSEGV in here */
|
|
char *msg_data = NULL, *msg;
|
|
|
|
BURN_ALLOC_MEM(msg_data, char, 321);
|
|
strcpy(msg_data,
|
|
"Damaged CD table-of-content detected and truncated.");
|
|
strcat(msg_data, " In burn_disc_cd_toc_extensions: ");
|
|
msg = msg_data + strlen(msg_data);
|
|
if (d->session == NULL) {
|
|
strcpy(msg, "d->session == NULL");
|
|
goto failure;
|
|
}
|
|
for (sidx = 0; sidx < d->sessions; sidx++) {
|
|
if (d->session[sidx] == NULL) {
|
|
sprintf(msg, "d->session[%d of %d] == NULL",
|
|
sidx, d->sessions);
|
|
goto failure;
|
|
}
|
|
if (d->session[sidx]->track == NULL) {
|
|
sprintf(msg, "d->session[%d of %d]->track == NULL",
|
|
sidx, d->sessions);
|
|
goto failure;
|
|
}
|
|
if (d->session[sidx]->leadout_entry == NULL) {
|
|
sprintf(msg,
|
|
" Session %d of %d: Leadout entry missing.",
|
|
sidx, d->sessions);
|
|
goto failure;
|
|
}
|
|
for (tidx = 0; tidx < d->session[sidx]->tracks + 1; tidx++) {
|
|
if (tidx < d->session[sidx]->tracks) {
|
|
if (d->session[sidx]->track[tidx] == NULL) {
|
|
sprintf(msg,
|
|
"d->session[%d of %d]->track[%d of %d] == NULL",
|
|
sidx, d->sessions, tidx, d->session[sidx]->tracks);
|
|
goto failure;
|
|
}
|
|
entry = d->session[sidx]->track[tidx]->entry;
|
|
if (entry == NULL) {
|
|
sprintf(msg,
|
|
"session %d of %d, track %d of %d, entry == NULL",
|
|
sidx, d->sessions, tidx,
|
|
d->session[sidx]->tracks);
|
|
goto failure;
|
|
}
|
|
} else
|
|
entry = d->session[sidx]->leadout_entry;
|
|
entry->session_msb = 0;
|
|
entry->point_msb = 0;
|
|
entry->start_lba = burn_msf_to_lba(entry->pmin,
|
|
entry->psec, entry->pframe);
|
|
if (tidx > 0) {
|
|
prev_entry->track_blocks =
|
|
entry->start_lba
|
|
- prev_entry->start_lba;
|
|
prev_entry->extensions_valid |= 1;
|
|
}
|
|
if (tidx == d->session[sidx]->tracks) {
|
|
entry->session_msb = 0;
|
|
entry->point_msb = 0;
|
|
entry->track_blocks = 0;
|
|
entry->extensions_valid |= 1;
|
|
}
|
|
prev_entry = entry;
|
|
}
|
|
}
|
|
{ret = 1; goto ex;}
|
|
failure:
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x0002015f,
|
|
LIBDAX_MSGS_SEV_MISHAP, LIBDAX_MSGS_PRIO_HIGH, msg_data, 0, 0);
|
|
d->sessions= sidx;
|
|
ret = 0;
|
|
ex:;
|
|
BURN_FREE_MEM(msg_data);
|
|
return ret;
|
|
}
|
|
|
|
|
|
struct burn_cdtext *burn_cdtext_create(void)
|
|
{
|
|
struct burn_cdtext *t;
|
|
int i;
|
|
|
|
t = burn_alloc_mem(sizeof(struct burn_cdtext), 1, 0);
|
|
if (t == NULL)
|
|
return NULL;
|
|
for(i = 0; i < Libburn_pack_num_typeS; i ++) {
|
|
t->payload[i] = NULL;
|
|
t->length[i] = 0;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
|
|
void burn_cdtext_free(struct burn_cdtext **cdtext)
|
|
{
|
|
struct burn_cdtext *t;
|
|
int i;
|
|
|
|
t = *cdtext;
|
|
if (t == NULL)
|
|
return;
|
|
for (i = 0; i < Libburn_pack_num_typeS; i++)
|
|
if (t->payload[i] != NULL)
|
|
free(t->payload[i]);
|
|
free(t);
|
|
}
|
|
|
|
|
|
static int burn_cdtext_name_to_type(char *pack_type_name)
|
|
{
|
|
int i, j;
|
|
static char *pack_type_names[] = {
|
|
Libburn_pack_type_nameS
|
|
};
|
|
|
|
for (i = 0; i < Libburn_pack_num_typeS; i++) {
|
|
if (pack_type_names[i][0] == 0)
|
|
continue;
|
|
for (j = 0; pack_type_names[i][j]; j++)
|
|
if (pack_type_names[i][j] != pack_type_name[j] &&
|
|
tolower(pack_type_names[i][j]) !=
|
|
pack_type_name[j])
|
|
break;
|
|
if (pack_type_names[i][j] == 0)
|
|
return Libburn_pack_type_basE + i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
/* @param flag bit0= double byte characters
|
|
*/
|
|
static int burn_cdtext_set(struct burn_cdtext **cdtext,
|
|
int pack_type, char *pack_type_name,
|
|
unsigned char *payload, int length, int flag)
|
|
{
|
|
int i;
|
|
struct burn_cdtext *t;
|
|
|
|
if (pack_type_name != NULL)
|
|
if (pack_type_name[0])
|
|
pack_type = burn_cdtext_name_to_type(pack_type_name);
|
|
if (pack_type < Libburn_pack_type_basE ||
|
|
pack_type >= Libburn_pack_type_basE + Libburn_pack_num_typeS) {
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x0002018c,
|
|
LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
|
|
"CD-TEXT pack type out of range", 0, 0);
|
|
return 0;
|
|
}
|
|
t = *cdtext;
|
|
if (t == NULL) {
|
|
*cdtext = t = burn_cdtext_create();
|
|
if (t == NULL)
|
|
return -1;
|
|
}
|
|
i = pack_type - Libburn_pack_type_basE;
|
|
if (t->payload[i] != NULL)
|
|
free(t->payload[i]);
|
|
t->payload[i] = burn_alloc_mem((size_t) length, 1, 0);
|
|
if (t->payload[i] == NULL)
|
|
return -1;
|
|
memcpy(t->payload[i], payload, length);
|
|
t->length[i] = length;
|
|
t->flags = (t->flags & ~(1 << i)) | (flag & (1 << i));
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* @return 1=single byte char , 2= double byte char , <=0 error */
|
|
static int burn_cdtext_get(struct burn_cdtext *t, int pack_type,
|
|
char *pack_type_name,
|
|
unsigned char **payload, int *length, int flag)
|
|
{
|
|
if (pack_type_name != NULL)
|
|
if (pack_type_name[0])
|
|
pack_type = burn_cdtext_name_to_type(pack_type_name);
|
|
if (pack_type < Libburn_pack_type_basE ||
|
|
pack_type >= Libburn_pack_type_basE + Libburn_pack_num_typeS) {
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x0002018c,
|
|
LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
|
|
"CD-TEXT pack type out of range", 0, 0);
|
|
return 0;
|
|
}
|
|
*payload = t->payload[pack_type - Libburn_pack_type_basE];
|
|
*length = t->length[pack_type - Libburn_pack_type_basE];
|
|
return 1 + ((t->flags >> (pack_type - Libburn_pack_type_basE)) & 1);
|
|
}
|
|
|
|
|
|
static int burn_cdtext_check_blockno(int block)
|
|
{
|
|
if (block < 0 || block > 7) {
|
|
libdax_msgs_submit(libdax_messenger, -1, 0x0002018d,
|
|
LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
|
|
"CD-TEXT block number out of range", 0, 0);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
/* @param flag bit0= double byte characters
|
|
*/
|
|
int burn_track_set_cdtext(struct burn_track *t, int block,
|
|
int pack_type, char *pack_type_name,
|
|
unsigned char *payload, int length, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
ret = burn_cdtext_set(&(t->cdtext[block]), pack_type, pack_type_name,
|
|
payload, length, flag & 1);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
/* @return 1=single byte char , 2= double byte char , <=0 error */
|
|
int burn_track_get_cdtext(struct burn_track *t, int block,
|
|
int pack_type, char *pack_type_name,
|
|
unsigned char **payload, int *length, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
ret = burn_cdtext_get(t->cdtext[block], pack_type, pack_type_name,
|
|
payload, length, 0);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
int burn_track_dispose_cdtext(struct burn_track *t, int block)
|
|
{
|
|
int i;
|
|
|
|
if (block == -1) {
|
|
for (i= 0; i < 8; i++)
|
|
burn_cdtext_free(&(t->cdtext[i]));
|
|
return 1;
|
|
}
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
burn_cdtext_free(&(t->cdtext[0]));
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
/* @param flag bit0= double byte characters
|
|
*/
|
|
int burn_session_set_cdtext(struct burn_session *s, int block,
|
|
int pack_type, char *pack_type_name,
|
|
unsigned char *payload, int length, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
ret = burn_cdtext_set(&(s->cdtext[block]), pack_type, pack_type_name,
|
|
payload, length, flag & 1);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
/* @return 1=single byte char , 2= double byte char , <=0 error */
|
|
int burn_session_get_cdtext(struct burn_session *s, int block,
|
|
int pack_type, char *pack_type_name,
|
|
unsigned char **payload, int *length, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
ret = burn_cdtext_get(s->cdtext[block], pack_type, pack_type_name,
|
|
payload, length, 0);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
int burn_session_set_cdtext_par(struct burn_session *s,
|
|
int char_codes[8], int copyrights[8],
|
|
int block_languages[8], int flag)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (char_codes[i] >= 0 && char_codes[i] <= 255)
|
|
s->cdtext_char_code[i] = char_codes[i];
|
|
if (copyrights[i] >= 0 && copyrights[i] <= 255)
|
|
s->cdtext_copyright[i] = copyrights[i];
|
|
if (block_languages[i] >= 0 && block_languages[i] <= 255)
|
|
s->cdtext_language[i] = block_languages[i];
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
int burn_session_get_cdtext_par(struct burn_session *s,
|
|
int char_codes[8], int copyrights[8],
|
|
int block_languages[8], int flag)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
char_codes[i] = s->cdtext_char_code[i];
|
|
copyrights[i] = s->cdtext_copyright[i];
|
|
block_languages[i]= s->cdtext_language[i];
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* ts B11206 API */
|
|
int burn_session_dispose_cdtext(struct burn_session *s, int block)
|
|
{
|
|
int i;
|
|
|
|
if (block == -1) {
|
|
for (i= 0; i < 8; i++) {
|
|
burn_session_dispose_cdtext(s, i);
|
|
s->cdtext_char_code[i] = 0x01; /* 7 bit ASCII */
|
|
s->cdtext_copyright[i] = 0;
|
|
s->cdtext_language[i] = 0;
|
|
}
|
|
return 1;
|
|
}
|
|
if (burn_cdtext_check_blockno(block) <= 0)
|
|
return 0;
|
|
burn_cdtext_free(&(s->cdtext[block]));
|
|
s->cdtext_language[block] = 0x09; /* english */
|
|
return 1;
|
|
}
|
|
|
|
|