Browse Source

Prepared experiments for writing to DVD (most easy: DVD+RW)

ZeroThreeEight
Thomas Schmitt 15 years ago
parent
commit
94848398c0
  1. 2
      cdrskin/cdrskin_timestamp.h
  2. 8
      libburn/libdax_msgs.h
  3. 132
      libburn/mmc.c
  4. 1
      libburn/options.c
  5. 5
      libburn/options.h
  6. 8
      libburn/sector.c
  7. 15
      libburn/transport.h
  8. 303
      libburn/write.c

2
cdrskin/cdrskin_timestamp.h

@ -1 +1 @@
#define Cdrskin_timestamP "2006.12.18.123242"
#define Cdrskin_timestamP "2006.12.20.111932"

8
libburn/libdax_msgs.h

@ -334,8 +334,12 @@ Range "scdbackup" : 0x00020000 to 0x0002ffff
0x0002011a (NOTE,HIGH) = Padding up track to minimum size
0x0002011b (FATAL,HIGH) = Attempt to read track info from ungrabbed drive
0x0002011c (FATAL,HIGH) = Attempt to read track info from busy drive
0x0002011d (FATAL,HIGH) = SCSI error condition on write
0x0002011e (SORRY, HIGH) = Unsuitable media detected
0x0002011d (FATAL,HIGH) = SCSI error on write
0x0002011e (SORRY,HIGH) = Unsuitable media detected
0x0002011f (SORRY,HIGH) = Burning of DVD+RW is restricted to a single track
0x00020120 (NOTE,HIGH) = FORMAT UNIT ignored
0x00020121 (FATAL,HIGH) = Write preparation setup failed
0x00020122 (FATAL,HIGH) = SCSI error on format_unit
libdax_audioxtr:
0x00020200 (SORRY,HIGH) = Cannot open audio source file

132
libburn/mmc.c

@ -34,6 +34,23 @@
extern struct libdax_msgs *libdax_messenger;
/* ts A61219 : ! HIGHLY EXPERIMENTAL !
Based on knowlege from dvd+rw-tools-7.0 and mmc5r03c.pdf
*/
/*
#define Libburn_support_dvd_plus_rW 1
*/
/* Progress report (with Libburn_support_dvd_plus_rW defined):
ts A61219 : It seems to work with a used (i.e. thoroughly formatted) DVD+RW.
Error messages of class DEBUG appear because of inability to
read TOC or track info. Nevertheless, the written images verify.
ts A61220 : Burned to a virgin DVD+RW by help of new mmc_format_unit()
(did not test wether it would work without). Burned to a
not completely formatted DVD+RW. (Had worked before without
mmc_format_unit(). I did not exceed the formatted range
as reported by dvd+rw-mediainfo.
*/
static unsigned char MMC_GET_TOC[] = { 0x43, 2, 2, 0, 0, 0, 0, 16, 0, 0 };
static unsigned char MMC_GET_ATIP[] = { 0x43, 2, 4, 0, 0, 0, 0, 16, 0, 0 };
@ -62,6 +79,9 @@ static unsigned char MMC_SEND_CUE_SHEET[] =
/* ts A61023 : get size and free space of drive buffer */
static unsigned char MMC_READ_BUFFER_CAPACITY[] = { 0x5C, 0, 0, 0, 0, 0, 0, 16, 0, 0 };
/* ts A61219 : format DVD+RW (and various others) */
static unsigned char MMC_FORMAT_UNIT[] = { 0x04, 0x11, 0, 0, 0, 0 };
static int mmc_function_spy_do_tell = 0;
@ -310,9 +330,10 @@ int mmc_write(struct burn_drive *d, int start, struct buffer *buf)
/* >>> make this scsi_notify_error() when liberated */
if (c.sense[2]!=0) {
char msg[80];
char msg[160];
sprintf(msg,
"SCSI error condition on write : key=%X asc=%2.2Xh ascq=%2.2Xh",
"SCSI error on write(%d,%d): key=%X asc=%2.2Xh ascq=%2.2Xh",
start, len,
c.sense[2],c.sense[12],c.sense[13]);
libdax_msgs_submit(libdax_messenger, d->global_index,
0x0002011d,
@ -355,7 +376,7 @@ void mmc_read_toc(struct burn_drive *d)
/* ts A61106 : also snaps on CD with unclosed track/session */
/* Very unsure wether this old measure is ok.
Obviously higher levels do not care about this.
DVD+RW burns go on after passing through here.
outdated info: DVD+RW burns go on after passing through here.
d->busy = BURN_DRIVE_IDLE;
*/
@ -479,7 +500,7 @@ void mmc_read_disc_info(struct burn_drive *d)
mmc_get_configuration(d);
if ((d->current_profile != 0 || d->status != BURN_DISC_UNREADY)
&& ! d->current_is_cd_profile) {
&& ! d->current_is_supported_profile) {
if (!d->silent_on_scsi_error) {
sprintf(msg,
"Unsuitable media detected. Profile %4.4Xh %s",
@ -536,12 +557,24 @@ void mmc_read_disc_info(struct burn_drive *d)
break;
}
/* ts A61217 : Note for future
>>> growisofs performs OPC if (data[0]<<8)|data[1]<=32
>>> which indicates no OPC entries are attached to the
>>> reply from the drive.
/* >>> ts A61217 : Note for future
growisofs performs OPC if (data[0]<<8)|data[1]<=32
which indicates no OPC entries are attached to the
reply from the drive.
*/
/* ts A61219 : mmc5r03c.pdf 6.22.3.1.13 BG Format Status
0=blank (not yet started)
1=started but neither running nor complete
2=in progress
3=completed
*/
d->bg_format_status = data[7] & 3;
/* <<< ts A61219 : preliminarily declare all DVD+RW blank,
(which is not the same as bg_format_status==0 "blank") */
if (d->current_profile == 0x1a)
d->status = BURN_DISC_BLANK;
}
void mmc_read_atip(struct burn_drive *d)
@ -893,6 +926,7 @@ void mmc_get_configuration(struct burn_drive *d)
d->current_profile = 0;
d->current_profile_text[0] = 0;
d->current_is_cd_profile = 0;
d->current_is_supported_profile = 0;
mmc_function_spy("mmc_get_configuration");
memcpy(c.opcode, MMC_GET_CONFIGURATION, sizeof(MMC_GET_CONFIGURATION));
@ -917,7 +951,13 @@ void mmc_get_configuration(struct burn_drive *d)
d->current_profile = cp;
strcpy(d->current_profile_text, mmc_obtain_profile_name(cp));
if (cp == 0x08 || cp == 0x09 || cp == 0x0a)
d->current_is_cd_profile = 1;
d->current_is_supported_profile = d->current_is_cd_profile = 1;
#ifdef Libburn_support_dvd_plus_rW
if (cp == 0x1a)
d->current_is_supported_profile = 1;
#endif
}
void mmc_sync_cache(struct burn_drive *d)
@ -975,6 +1015,77 @@ int mmc_read_buffer_capacity(struct burn_drive *d)
}
/* ts A61219 : learned much from dvd+rw-tools-7.0: plus_rw_format() */
int mmc_format_unit(struct burn_drive *d)
{
struct buffer buf;
struct command c;
int ret;
char msg[160],descr[80];
mmc_function_spy("mmc_format_unit");
c.retry = 1;
c.oplen = sizeof(MMC_FORMAT_UNIT);
memcpy(c.opcode, MMC_FORMAT_UNIT, sizeof(MMC_FORMAT_UNIT));
c.page = &buf;
c.page->bytes = 12;
c.page->sectors = 0;
c.dir = TO_DRIVE;
memset(c.page->data, 0, c.page->bytes);
descr[0] = 0;
if (d->current_profile == 0x1a) { /* DVD+RW */
c.page->data[1] = 0x02; /* Immed */
c.page->data[3] = 8; /* Format descriptor length */
/* mmc5r03c.pdf , 6.5.4.2.14 */
c.page->data[8] = 0x26 << 2; /* Format type */
memset(c.page->data + 4, 0xff, 4); /* maximum blocksize */
if (d->bg_format_status == 1) /* is partly formatted */
c.page->data[11] = 1; /* Restart bit */
else if(d->bg_format_status == 2) { /* format in progress */
strcpy(msg,"FORMAT UNIT ignored. Already in progress");
libdax_msgs_submit(libdax_messenger, d->global_index,
0x00020120,
LIBDAX_MSGS_SEV_NOTE, LIBDAX_MSGS_PRIO_HIGH,
msg, 0,0);
}
sprintf(descr, "DVD+RW, BGFS %d",
d->bg_format_status);
} else {
/* >>> other formattable types to come */
sprintf(msg, "Unsuitable media detected. Profile %4.4Xh %s",
d->current_profile, d->current_profile_text);
libdax_msgs_submit(libdax_messenger, d->global_index,
0x0002011e,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
msg, 0,0);
return 0;
}
d->issue_command(d, &c);
if (c.error) {
if (c.sense[2]!=0) {
sprintf(msg,
"SCSI error on format_unit(%s): key=%X asc=%2.2Xh ascq=%2.2Xh",
descr,
c.sense[2],c.sense[12],c.sense[13]);
libdax_msgs_submit(libdax_messenger, d->global_index,
0x00020122,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
msg, 0, 0);
}
return 0;
}
for (ret = 0; ret <= 0 ;)
ret = spc_test_unit_ready(d);
mmc_sync_cache(d);
return 1;
}
/* ts A61021 : the mmc specific part of sg.c:enumerate_common()
*/
int mmc_setup_drive(struct burn_drive *d)
@ -993,6 +1104,7 @@ int mmc_setup_drive(struct burn_drive *d)
d->close_session = mmc_close_session;
d->close_track_session = mmc_close;
d->read_buffer_capacity = mmc_read_buffer_capacity;
d->format_unit = mmc_format_unit;
/* ts A61020 */
d->start_lba = -2000000000;
@ -1003,6 +1115,8 @@ int mmc_setup_drive(struct burn_drive *d)
d->current_profile = -1;
d->current_profile_text[0] = 0;
d->current_is_cd_profile = 0;
d->current_is_supported_profile = 0;
d->bg_format_status = -1;
return 1;
}

1
libburn/options.c

@ -32,6 +32,7 @@ struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive)
opts->simulate = 0;
opts->underrun_proof = drive->mdata->underrun_proof;
opts->perform_opc = 1;
opts->obs = -1;
opts->has_mediacatalog = 0;
opts->format = BURN_CDROM;
opts->multi = 0;

5
libburn/options.h

@ -32,6 +32,11 @@ struct burn_write_opts
/** Perform calibration of the drive's laser before beginning the
write. */
unsigned int perform_opc:1;
/* ts A61219 : Output block size to trigger buffer flush if hit.
-1 with CD, 32 kB with DVD */
int obs;
/** A disc can have a media catalog number */
int has_mediacatalog;
unsigned char mediacatalog[13];

8
libburn/sector.c

@ -217,7 +217,8 @@ static unsigned char *get_sector(struct burn_write_opts *opts,
return NULL;
seclen += burn_subcode_length(outmode);
if (out->bytes + (seclen) >= BUFFER_SIZE) {
/* ts A61219 : opts->obs is eventually a 32k trigger for DVD */
if (out->bytes + (seclen) > BUFFER_SIZE || out->bytes == opts->obs) {
int err;
err = d->write(d, d->nwa, out);
if (err == BE_CANCELLED)
@ -642,7 +643,10 @@ int sector_data(struct burn_write_opts *o, struct burn_track *t, int psub)
return 2;
}
if (!t->source->read_sub)
/* ts A61219 : allow track without .entry */
if (t->entry == NULL)
;
else if (!t->source->read_sub)
subcode_user(o, subs, t->entry->point,
t->entry->control, 1, &t->isrc, psub);
else if (!t->source->read_sub(t->source, subs, 96))

15
libburn/transport.h

@ -36,7 +36,12 @@ struct params
struct buffer
{
unsigned char data[BUFFER_SIZE];
/* ts A61219:
Added 4096 bytes reserve against possible buffer overflows.
(Changed in sector.c buffer flush test from >= to > BUFFER_SIZE .
This can at most cause a 1 sector overlap. Sometimes an offset
of 16 byte is applied to the output data (in some RAW mode). ) */
unsigned char data[BUFFER_SIZE + 4096];
int sectors;
int bytes;
};
@ -124,6 +129,11 @@ struct burn_drive
int current_profile;
char current_profile_text[80];
int current_is_cd_profile;
int current_is_supported_profile;
/* ts A61218 from 46h GET CONFIGURATION */
int bg_format_status; /* 0=needs format start, 1=needs format restart*/
volatile int released;
@ -206,6 +216,9 @@ struct burn_drive
/* ts A61023 : get size and free space of drive buffer */
int (*read_buffer_capacity) (struct burn_drive *d);
/* ts A61220 : format media (e.g. DVD+RW) */
int (*format_unit) (struct burn_drive *d);
};
/* end of generic 'drive' data structures */

303
libburn/write.c

@ -580,6 +580,30 @@ ex:;
return ret;
}
/* ts A61218 : outsourced from burn_write_track() */
int burn_disc_init_track_status(struct burn_write_opts *o,
struct burn_session *s, int tnum)
{
struct burn_drive *d = o->drive;
int sectors;
/* ts A61102 */
d->busy = BURN_DRIVE_WRITING;
/* Update progress */
d->progress.start_sector = d->nwa;
d->progress.sectors = sectors;
d->progress.sector = 0;
/* ts A60831: added tnum-line, extended print message on proposal
by bonfire-app@wanadoo.fr in http://libburn.pykix.org/ticket/58 */
d->progress.track = tnum;
return 1;
}
int burn_write_track(struct burn_write_opts *o, struct burn_session *s,
int tnum)
{
@ -637,20 +661,10 @@ int burn_write_track(struct burn_write_opts *o, struct burn_session *s,
/* user data */
/* ts A61102 */
d->busy = BURN_DRIVE_WRITING;
sectors = burn_track_get_sectors(t);
open_ended = burn_track_is_open_ended(t);
/* Update progress */
d->progress.start_sector = d->nwa;
d->progress.sectors = sectors;
d->progress.sector = 0;
/* ts A60831: added tnum-line, extended print message on proposal
by bonfire-app@wanadoo.fr in http://libburn.pykix.org/ticket/58 */
d->progress.track = tnum;
burn_disc_init_track_status(o, s, tnum);
burn_print(12, "track %d is %d sectors long\n", tnum, sectors);
@ -761,6 +775,237 @@ bad_track_mode_found:;
return 0;
}
/* ts A61218 : outsourced from burn_disc_write_sync() */
int burn_disc_init_write_status(struct burn_write_opts *o,
struct burn_disc *disc)
{
struct burn_drive *d = o->drive;
/* init progress before showing the state */
d->progress.session = 0;
d->progress.sessions = disc->sessions;
d->progress.track = 0;
d->progress.tracks = disc->session[0]->tracks;
/* TODO: handle indices */
d->progress.index = 0;
d->progress.indices = disc->session[0]->track[0]->indices;
/* TODO: handle multissession discs */
/* XXX: sectors are only set during write track */
d->progress.start_sector = 0;
d->progress.sectors = 0;
d->progress.sector = 0;
/* ts A61023 */
d->progress.buffer_capacity = 0;
d->progress.buffer_available = 0;
d->progress.buffered_bytes = 0;
d->progress.buffer_min_fill = 0xffffffff;
d->busy = BURN_DRIVE_WRITING;
return 1;
}
/* ts A61218 */
int burn_dvd_write_track(struct burn_write_opts *o,
struct burn_session *s, int tnum)
{
struct burn_track *t = s->track[tnum];
struct burn_drive *d = o->drive;
struct buffer *out = d->buffer;
int sectors;
int i, open_ended = 0, ret= 0;
sectors = burn_track_get_sectors(t);
open_ended = burn_track_is_open_ended(t);
/* >>> any type specific track preparations */;
burn_disc_init_track_status(o, s, tnum);
for (i = 0; open_ended || i < sectors; i++) {
/* From time to time inquire drive buffer */
if ((i%256)==0)
d->read_buffer_capacity(d);
/* transact a (CD sized) sector */
if (!sector_data(o, t, 0))
{ ret = 0; goto ex; }
if (open_ended) {
d->progress.sectors = sectors = i;
if (burn_track_is_data_done(t))
break;
}
/* update current progress */
d->progress.sector++;
}
/* Pad up buffer to next full 32 kB */
if (out->bytes > 0 && out->bytes < o->obs) {
memset(out->data + out->bytes, 0, o->obs - out->bytes);
out->sectors += (o->obs - out->bytes) / 2048;
out->bytes = o->obs;
}
ret = burn_write_flush(o, t);
if (ret <= 0)
goto ex;
/* >>> any normal track finalizing */;
ret = 1;
ex:;
if (ret<=0) {
/* >>> any unnormal track finalizing */;
}
return ret;
}
/* ts A61219 */
int burn_disc_close_session_dvd_plus_rw(struct burn_write_opts *o,
struct burn_session *s)
{
struct burn_drive *d = o->drive;
/* This seems to be a quick end : "if (!dvd_compat)" */
/* >>> Stop de-icing (ongoing background format) quickly
by mmc_close() i(but with opcode[2]=0).
Wait for unit to get ready.
return 1;
*/
/* Else: end eventual background format in a "DVD-RO" compatible way */
d->close_track_session(d, 1, 0); /* same as CLOSE SESSION for CD */
return 1;
}
/* ts A61218 */
int burn_dvd_write_session(struct burn_write_opts *o,
struct burn_session *s)
{
int i,ret;
struct burn_drive *d = o->drive;
for (i = 0; i < s->tracks; i++) {
ret = burn_dvd_write_track(o, s, i);
if (ret <= 0)
break;
}
if (strcmp(d->current_profile_text,"DVD+RW")==0) {
ret = burn_disc_close_session_dvd_plus_rw(o, s);
if (ret <= 0)
return 0;
}
return 1;
}
/* ts A61218 : learned much from dvd+rw-tools-7.0/growisofs_mmc.cpp */
int burn_disc_setup_dvd_plus_rw(struct burn_write_opts *o,
struct burn_disc *disc)
{
struct burn_drive *d = o->drive;
int ret;
fprintf(stderr, "LIBBURN_DEBUG: d->bg_format_status= %d\n",
d->bg_format_status);
if (d->bg_format_status==0 || d->bg_format_status==1) {
/* start or re-start dvd_plus_rw formatting */
ret = d->format_unit(d);
fprintf(stderr, "LIBBURN_DEBUG: format_unit() = %d\n", ret);
if (ret <= 0)
return 0;
}
/* >>> Set speed */;
/* >>> perform OPC if needed */;
d->nwa = 0;
/* >>> d->get_nwa() (default to 0) */;
/* >>> ? what else ? */;
return 1;
}
/* ts A61218 */
int burn_dvd_write_sync(struct burn_write_opts *o,
struct burn_disc *disc)
{
int i, ret;
struct burn_drive *d = o->drive;
char msg[160];
if (strcmp(d->current_profile_text,"DVD+RW")==0) {
if (disc->sessions!=1 || disc->session[0]->tracks>1) {
sprintf(msg,
"Burning of DVD+RW is restricted to a single track");
libdax_msgs_submit(libdax_messenger, d->global_index,
0x0002011f,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
msg, 0,0);
return 0;
}
ret = burn_disc_setup_dvd_plus_rw(o, disc);
if (ret <= 0) {
sprintf(msg,
"Write preparation setup failed for DVD+RW");
libdax_msgs_submit(libdax_messenger, d->global_index,
0x00020121,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
msg, 0,0);
return 0;
}
} else {
sprintf(msg, "Unsuitable media detected. Profile %4.4Xh %s",
d->current_profile, d->current_profile_text);
libdax_msgs_submit(libdax_messenger, d->global_index,
0x0002011e,
LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
msg, 0,0);
return 0;
}
o->obs = 32*1024; /* buffer flush trigger for sector.c:get_sector() */
burn_disc_init_write_status(o, disc);
for (i = 0; i < disc->sessions; i++) {
/* update progress */
d->progress.session = i;
d->progress.tracks = disc->session[i]->tracks;
ret = burn_dvd_write_session(o, disc->session[i]);
if (ret <= 0)
goto ex;
}
/* >>> eventual normal finalization measures */
ret = 1;
ex:;
/* >>> eventual emergency finalization measures */
/* update media state records */
burn_drive_mark_unready(d);
burn_drive_inquire_media(d);
return ret;
}
void burn_disc_write_sync(struct burn_write_opts *o, struct burn_disc *disc)
{
struct cue_sheet *sheet;
@ -774,14 +1019,21 @@ void burn_disc_write_sync(struct burn_write_opts *o, struct burn_disc *disc)
burn_message_clear_queue();
*/
burn_print(1, "sync write of %d sessions\n", disc->sessions);
d->buffer = &buf;
memset(d->buffer, 0, sizeof(struct buffer));
d->rlba = -150;
d->toc_temp = 9;
/* ts A61218 */
if (! d->current_is_cd_profile) {
ret = burn_dvd_write_sync(o, disc);
if (ret <= 0)
goto fail_wo_sync;
return;
}
burn_print(1, "sync write of %d CD sessions\n", disc->sessions);
/* Apparently some drives require this command to be sent, and a few drives
return crap. so we send the command, then ignore the result.
*/
@ -803,27 +1055,7 @@ return crap. so we send the command, then ignore the result.
msg,0,0);
}
/* init progress before showing the state */
d->progress.session = 0;
d->progress.sessions = disc->sessions;
d->progress.track = 0;
d->progress.tracks = disc->session[0]->tracks;
/* TODO: handle indices */
d->progress.index = 0;
d->progress.indices = disc->session[0]->track[0]->indices;
/* TODO: handle multissession discs */
/* XXX: sectors are only set during write track */
d->progress.start_sector = 0;
d->progress.sectors = 0;
d->progress.sector = 0;
/* ts A61023 */
d->progress.buffer_capacity = 0;
d->progress.buffer_available = 0;
d->progress.buffered_bytes = 0;
d->progress.buffer_min_fill = 0xffffffff;
d->busy = BURN_DRIVE_WRITING;
burn_disc_init_write_status(o, disc);
for (i = 0; i < disc->sessions; i++) {
/* update progress */
@ -932,6 +1164,7 @@ return crap. so we send the command, then ignore the result.
fail:
d->sync_cache(d);
fail_wo_sync:;
burn_print(1, "done - failed\n");
libdax_msgs_submit(libdax_messenger, d->global_index, 0x0002010b,
LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,

Loading…
Cancel
Save