xorriso  1.5.4.pl02
About: GNU xorriso creates, loads, manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions. It is suitable for incremental data backup and for production of bootable ISO 9660 images. GNU xorriso is a statical compilation of the libraries libburn, libisofs, libisoburn, and libjte.
  Fossies Dox: xorriso-1.5.4.pl02.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

options.c
Go to the documentation of this file.
1 
2 /* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
3  Copyright (c) 2006 - 2017 Thomas Schmitt <scdbackup@gmx.net>
4  Provided under GPL version 2 or later.
5 */
6 
7 #ifdef HAVE_CONFIG_H
8 #include "../config.h"
9 #endif
10 
11 #include "libburn.h"
12 #include "options.h"
13 #include "drive.h"
14 #include "transport.h"
15 #include "init.h"
16 #include "write.h"
17 
18 /* ts A61007 */
19 /* #include <a ssert.h> */
20 
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdio.h>
24 
25 #include "libdax_msgs.h"
26 extern struct libdax_msgs *libdax_messenger;
27 
28 
30 {
31  struct burn_write_opts *opts;
32 
33  opts = calloc(1, sizeof(struct burn_write_opts));
34  if (opts == NULL) {
35  libdax_msgs_submit(libdax_messenger, -1, 0x00020111,
37  "Could not allocate new auxiliary object", 0, 0);
38  return NULL;
39  }
40  opts->drive = drive;
41  opts->refcount = 1;
42  opts->write_type = BURN_WRITE_TAO;
44  opts->toc_entry = NULL;
45  opts->toc_entries = 0;
46  opts->simulate = 0;
47  opts->underrun_proof = drive->mdata->p2a_valid > 0 &&
49  opts->perform_opc = 1;
50  opts->obs = -1;
51 
52 #ifdef Libburn_dvd_always_obs_paD
53  opts->obs_pad = 1;
54 #else
55  opts->obs_pad = 0;
56 #endif
57 
58  opts->start_byte = -1;
59  opts->fill_up_media = 0;
60  opts->force_is_set = 0;
61  opts->do_stream_recording = 0;
62  opts->dvd_obs_override = 0;
64  opts->text_packs = NULL;
65  opts->num_text_packs = 0;
66  opts->no_text_pack_crc_check = 0;
67  opts->has_mediacatalog = 0;
68  opts->format = BURN_CDROM;
69  opts->multi = 0;
70  opts->control = 0;
71  return opts;
72 }
73 
75 {
76  if (--opts->refcount > 0)
77  return;
78  if (opts->text_packs != NULL)
79  free(opts->text_packs);
80  free(opts);
81 }
82 
84  struct burn_write_opts **to, int flag)
85 {
86  if (*to != NULL)
88  if (from == NULL)
89  return 1;
90  *to = calloc(1, sizeof(struct burn_write_opts));
91  if (*to == NULL) {
92 out_of_mem:;
93  libdax_msgs_submit(libdax_messenger, -1, 0x00000003,
95  "Out of virtual memory", 0, 0);
96  return -1;
97  }
98  memcpy(*to, from, sizeof(struct burn_write_opts));
99  (*to)->text_packs = NULL;
100  (*to)->num_text_packs = 0;
101  if (from->text_packs != NULL && from->num_text_packs > 0) {
102  (*to)->text_packs = calloc(1, from->num_text_packs * 18);
103  if ((*to)->text_packs == NULL)
104  goto out_of_mem;
105  memcpy((*to)->text_packs, from->text_packs,
106  from->num_text_packs * 18);
107  }
108  (*to)->refcount= 1;
109  return 1;
110 }
111 
113 {
114  struct burn_read_opts *opts;
115 
116  opts = calloc(1, sizeof(struct burn_read_opts));
117  opts->drive = drive;
118  opts->refcount = 1;
119  opts->raw = 0;
120  opts->c2errors = 0;
121  opts->subcodes_audio = 0;
122  opts->subcodes_data = 0;
123  opts->hardware_error_recovery = 0;
124  opts->report_recovered_errors = 0;
125  opts->transfer_damaged_blocks = 0;
126  opts->hardware_error_retries = 3;
127  opts->dap_bit = 0;
128 
129  return opts;
130 }
131 
133 {
134  if (--opts->refcount <= 0)
135  free(opts);
136 }
137 
139  enum burn_write_types write_type,
140  int block_type)
141 {
142  int sector_get_outmode(enum burn_write_types write_type,
143  enum burn_block_types block_type);
144  int spc_block_type(enum burn_block_types b);
145 
146  /* ts A61007 */
147  if (! ( (write_type == BURN_WRITE_SAO && block_type == BURN_BLOCK_SAO)
148  || (opts->drive->block_types[write_type] & block_type) ) ) {
149 bad_combination:;
150  libdax_msgs_submit(libdax_messenger, -1, 0x00020112,
152  "Bad combination of write_type and block_type", 0, 0);
153  return 0;
154  }
155  /* ts A61007 : obsoleting Assert in sector.c:get_outmode() */
156  if (sector_get_outmode(write_type, (enum burn_block_types) block_type)
157  == -1)
158  goto bad_combination;
159  /* ts A61007 : obsoleting Assert in spc.c:spc_block_type() */
160  if (spc_block_type((enum burn_block_types) block_type) == -1)
161  goto bad_combination;
162 
163  opts->write_type = write_type;
164  opts->block_type = block_type;
165  return 1;
166 
167  /* a ssert(0); */
168 }
169 
171  struct burn_toc_entry *toc_entries)
172 {
173  opts->toc_entries = count;
174  opts->toc_entry = calloc(count, sizeof(struct burn_toc_entry));
175  memcpy(opts->toc_entry, &toc_entries,
176  sizeof(struct burn_toc_entry) * count);
177 }
178 
179 void burn_write_opts_set_format(struct burn_write_opts *opts, int format)
180 {
181  opts->format = format;
182 }
183 
185 {
186  opts->simulate = !!sim;
187  return 1;
188 }
189 
191  int underrun_proof)
192 {
193  if (opts->drive->mdata->p2a_valid <= 0 ||
194  opts->drive->mdata->underrun_proof) {
195  opts->underrun_proof = underrun_proof;
196  return 1;
197  }
198  return 0;
199 }
200 
202 {
203  opts->perform_opc = opc;
204 }
205 
207  int has_mediacatalog)
208 {
209  opts->has_mediacatalog = has_mediacatalog;
210 }
211 
213  unsigned char mediacatalog[13])
214 {
215  memcpy(opts->mediacatalog, mediacatalog, 13);
216 }
217 
218 
219 /* ts A61106 */
220 void burn_write_opts_set_multi(struct burn_write_opts *opts, int multi)
221 {
222  opts->multi = !!multi;
223 }
224 
225 
226 /* ts B31024 */
227 /* API */
229  char *severity)
230 {
231  int ret, sevno;
232 
233  ret = libdax_msgs__text_to_sev(severity, &sevno, 0);
234  if (ret <= 0)
235  opts->feat21h_fail_sev = 0;
236  else
237  opts->feat21h_fail_sev = sevno;
238 }
239 
240 
241 /* ts B11204 */
242 /* @param flag bit0=do not verify checksums
243  bit1= repair mismatching checksums
244  bit2= repair checksums if they are 00 00 with each pack
245 */
247  unsigned char *text_packs,
248  int num_packs, int flag)
249 {
250  int ret;
251  unsigned char *pack_buffer = NULL;
252 
253  if (num_packs > Libburn_leadin_cdtext_packs_maX ) {
255  0x0002018b,
257  "Too many CD-TEXT packs", 0, 0);
258  ret= 0; goto ex;
259  }
260 
261  if (num_packs > 0)
262  BURN_ALLOC_MEM(pack_buffer, unsigned char, num_packs * 18);
263 
264  if (opts->text_packs != NULL) {
265  free(opts->text_packs);
266  opts->text_packs = NULL;
267  }
268 
269  if (flag & 1) {
270  opts->no_text_pack_crc_check = 1;
271  } else {
272  opts->no_text_pack_crc_check = 0;
273  ret = burn_cdtext_crc_mismatches(text_packs, num_packs,
274  (flag >> 1) & 3);
275  if (ret > 0) {
276  libdax_msgs_submit(libdax_messenger, -1, 0x0002018f,
278  "CD-TEXT pack CRC mismatch", 0, 0);
279  ret = 0; goto ex;
280  } else if (ret < 0) {
281  libdax_msgs_submit(libdax_messenger, -1, 0x00020190,
283  "CD-TEXT pack CRC mismatch had to be corrected",
284  0, 0);
285  }
286  }
287 
288  if (num_packs > 0) {
289  memcpy(pack_buffer, text_packs, num_packs * 18);
290  opts->text_packs = pack_buffer;
291  pack_buffer = NULL;
292  }
293  opts->num_text_packs = num_packs;
294  ret = 1;
295 ex:;
296  BURN_FREE_MEM(pack_buffer);
297  return ret;
298 }
299 
300 
301 /* ts A61222 */
302 void burn_write_opts_set_start_byte(struct burn_write_opts *opts, off_t value)
303 {
304  opts->start_byte = value;
305 }
306 
307 
308 /* ts A70207 API */
309 /** @param flag Bitfield for control purposes:
310  bit0= do not choose type but check the one that is already set
311  bit1= do not issue error messages via burn_msgs queue
312 */
314  struct burn_write_opts *opts, struct burn_disc *disc,
315  char reasons[BURN_REASONS_LEN], int flag)
316 {
317  struct burn_multi_caps *caps = NULL;
318  struct burn_drive *d = opts->drive;
319  struct burn_disc_mode_demands demands;
320  enum burn_write_types wt;
321  int ret, would_do_sao = 0;
322  char *reason_pt;
323 
324  reasons[0] = 0;
325 
326  if (burn_drive_get_bd_r_pow(d)) {
327  strcat(reasons,
328  "MEDIA: unsuitable BD-R Pseudo Overwrite formatting, ");
329  return BURN_WRITE_NONE;
330  }
331  if (d->status != BURN_DISC_BLANK &&
333  if (d->status == BURN_DISC_FULL)
334  strcat(reasons, "MEDIA: closed or not recordable, ");
335  else
336  strcat(reasons,"MEDIA: no writeable media detected, ");
337  if (!(flag & 3))
339  0x0002013a,
341  "No suitable media detected", 0, 0);
342  return BURN_WRITE_NONE;
343  }
344  ret = burn_disc_get_write_mode_demands(disc, opts, &demands,
345  !!opts->fill_up_media);
346  if (ret <= 0) {
347  strcat(reasons, "cannot recognize job demands, ");
348  {wt = BURN_WRITE_NONE; goto ex;}
349  }
350  if (demands.exotic_track && !d->current_is_cd_profile) {
351  if (demands.audio)
352  strcat(reasons, "audio track prohibited by non-CD, ");
353  else
354  strcat(reasons, "exotic track prohibited by non-CD, ");
355  {wt = BURN_WRITE_NONE; goto ex;}
356  }
357  if ((flag & 1) && opts->write_type != BURN_WRITE_SAO)
358  goto try_tao;
359  reason_pt = reasons + strlen(reasons);
360  strcat(reasons, "SAO: ");
361  if (d->status != BURN_DISC_BLANK) {
362  strcat(reasons, "write type SAO works only on blank media, ");
363  goto try_tao;
364  }
366  ret = burn_disc_get_multi_caps(d, BURN_WRITE_SAO, &caps, 0);
367  if (ret < 0) {
368 no_caps:;
369  strcat(reasons, "cannot inquire write mode capabilities, ");
370  {wt = BURN_WRITE_NONE; goto ex;}
371  } else if (ret == 0) {
372  strcat(reasons, "no SAO offered by drive and media, ");
373  goto no_sao;
374  }
375  if ((opts->multi || demands.multi_session) &&
376  !caps->multi_session)
377  strcat(reasons, "multi session capability lacking, ");
378  if (demands.will_append)
379  strcat(reasons, "appended session capability lacking, ");
380  if (demands.multi_track && !caps->multi_track)
381  strcat(reasons, "multi track capability lacking, ");
382  if (demands.unknown_track_size == 1 &&
383  (caps->might_do_sao == 1 || caps->might_do_sao == 3))
384  strcat(reasons, "track size unpredictable, ");
385  if (demands.mixed_mode)
386  strcat(reasons, "tracks of different modes mixed, ");
387  if (demands.exotic_track && !d->current_is_cd_profile)
388  strcat(reasons, "non-data track on non-cd, ");
389  else if (d->current_is_cd_profile)
390  if ((d->block_types[BURN_WRITE_TAO] & demands.block_types) !=
391  demands.block_types)
392  strcat(reasons, "drive dislikes block type, ");
393  if (d->current_is_cd_profile && opts->fill_up_media)
394  strcat(reasons, "cd sao cannot do media fill up yet, ");
395  if (strcmp(reason_pt, "SAO: ") != 0)
396  goto no_sao;
397  would_do_sao = 1;
398  if (demands.unknown_track_size == 2 && (!(flag & 1)) &&
399  (caps->might_do_sao == 1 || caps->might_do_sao == 3)) {
400  strcat(reasons, "would have to use default track sizes, ");
401  goto no_sao;
402  } else if (caps->might_do_sao >= 3 && !(flag & 1))
403  goto try_tao;
404 do_sao:;
405  if (caps->might_simulate == 0 && opts->simulate && !opts->force_is_set)
406  goto no_simulate;
407  if (!(flag & 1))
410  {wt = BURN_WRITE_SAO; goto ex;}
411 no_sao:;
412 try_tao:;
413  if (opts->num_text_packs > 0) {
414  strcat(reasons, "CD-TEXT: write type SAO required, ");
415  {wt = BURN_WRITE_NONE; goto ex;}
416  }
417  if ((flag & 1) && opts->write_type != BURN_WRITE_TAO)
418  goto try_raw;
419  reason_pt = reasons + strlen(reasons);
420  strcat(reasons, "TAO: ");
422  ret = burn_disc_get_multi_caps(d, BURN_WRITE_TAO, &caps, 0);
423  if (ret < 0)
424  goto no_caps;
425  if (ret == 0) {
426  strcat(reasons, "no TAO offered by drive and media, ");
427  goto no_tao;
428  }
429  if ((opts->multi || demands.multi_session) && !caps->multi_session)
430  strcat(reasons, "multi session capability lacking, ");
431  if (demands.multi_track && !caps->multi_track)
432  strcat(reasons, "multi track capability lacking, ");
433  if (demands.exotic_track && !d->current_is_cd_profile)
434  strcat(reasons, "non-data track on non-cd, ");
435  if (d->current_is_cd_profile && !opts->force_is_set)
436  if ((d->block_types[BURN_WRITE_TAO] & demands.block_types) !=
437  demands.block_types)
438  strcat(reasons, "drive dislikes block type, ");
439  if (strcmp(reason_pt, "TAO: ") != 0)
440  goto no_tao;
441  /* ( TAO data/audio block size will be handled automatically ) */
442  if (caps->might_simulate == 0 && opts->simulate && !opts->force_is_set)
443  goto no_simulate;
444  if (!(flag & 1))
447  {wt = BURN_WRITE_TAO; goto ex;}
448 no_tao:;
449  if (would_do_sao && !(flag & 1))
450  goto do_sao;
451  if (!d->current_is_cd_profile)
452  goto no_write_mode;
453 try_raw:;
454  if ((flag & 1) && opts->write_type != BURN_WRITE_RAW)
455  goto no_write_mode;
456 
457  if (!(flag & 1)) /* For now: no automatic raw write modes */
458  goto no_write_mode;
459 
460  reason_pt = reasons + strlen(reasons);
461  strcat(reasons, "RAW: ");
462  if (!d->current_is_cd_profile)
463  strcat(reasons, "write type RAW prohibited by non-cd, ");
464  else if (d->status != BURN_DISC_BLANK)
465  strcat(reasons, "write type RAW works only on blank media, ");
466  else if ((d->block_types[BURN_WRITE_TAO] & demands.block_types) !=
467  demands.block_types)
468  strcat(reasons, "drive dislikes block type, ");
469  if (strcmp(reason_pt, "RAW: ") != 0)
470  goto no_write_mode;
471  if (!opts->force_is_set)
472  goto no_simulate;
473 
474  /* For now: no setting of raw write modes */
475 
476  {wt = BURN_WRITE_RAW; goto ex;}
477 
478 no_write_mode:;
479  {wt = BURN_WRITE_NONE; goto ex;}
480 
481 no_simulate:;
482  strcat(reasons,
483  "simulation of write job not supported by drive and media, ");
484  {wt = BURN_WRITE_NONE; goto ex;}
485 
486 ex:;
488  if (wt == BURN_WRITE_NONE && !(flag & 3)) {
490  0x0002012b,
492  "Drive offers no suitable write mode with this job",
493  0, 0);
494  }
495  return wt;
496 }
497 
498 
499 /* ts A70213 : new API function */
500 void burn_write_opts_set_fillup(struct burn_write_opts *opts,int fill_up_media)
501 {
502  opts->fill_up_media = !!fill_up_media;
503  return;
504 }
505 
506 
507 /* ts A70303: API */
508 void burn_write_opts_set_force(struct burn_write_opts *opts, int use_force)
509 {
510  opts->force_is_set = !!use_force;
511 }
512 
513 
514 /* ts A80412: API */
516  int value)
517 {
518  opts->do_stream_recording = value;
519 }
520 
521 
522 /* ts A91115: API */
523 void burn_write_opts_set_dvd_obs(struct burn_write_opts *opts, int obs)
524 {
525  if (obs != 0 && obs != 32 * 1024 && obs != 64 * 1024)
526  return;
527  opts->dvd_obs_override = obs;
528 }
529 
530 
531 /* ts B20406: API */
532 void burn_write_opts_set_obs_pad(struct burn_write_opts *opts, int pad)
533 {
534  opts->obs_pad = 2 * !!pad;
535 }
536 
537 
538 /* ts A91115: API */
539 void burn_write_opts_set_stdio_fsync(struct burn_write_opts *opts, int rhythm)
540 {
541  if (rhythm == -1)
542  opts->stdio_fsync_size = -1; /* never */
543  else if (rhythm == 0)
545  else if (rhythm == 1)
546  opts->stdio_fsync_size = 0; /* only at end of writing */
547  else if (rhythm >= 32)
548  opts->stdio_fsync_size = rhythm;
549 }
550 
551 
552 /* ts A70901: API */
554 {
555  return opts->drive;
556 }
557 
558 
559 void burn_read_opts_set_raw(struct burn_read_opts *opts, int raw)
560 {
561  opts->raw = raw;
562 }
563 
564 void burn_read_opts_set_c2errors(struct burn_read_opts *opts, int c2errors)
565 {
566  opts->c2errors = c2errors;
567 }
568 
570  int subcodes_audio)
571 {
572  opts->subcodes_audio = subcodes_audio;
573 }
574 
576  int subcodes_data)
577 {
578  opts->subcodes_data = subcodes_data;
579 }
580 
582  int hardware_error_recovery)
583 {
584  opts->hardware_error_recovery = hardware_error_recovery;
585 }
586 
588  int report_recovered_errors)
589 {
590  opts->report_recovered_errors = report_recovered_errors;
591 }
592 
594  int transfer_damaged_blocks)
595 {
596  opts->transfer_damaged_blocks = transfer_damaged_blocks;
597 }
598 
600  unsigned char
601  hardware_error_retries)
602 {
603  opts->hardware_error_retries = hardware_error_retries;
604 }
605 
int burn_cdtext_crc_mismatches(unsigned char *packs, int num_packs, int flag)
Definition: cdtext.c:103
int burn_disc_get_multi_caps(struct burn_drive *d, enum burn_write_types wt, struct burn_multi_caps **caps, int flag)
Definition: drive.c:2947
int burn_drive_get_bd_r_pow(struct burn_drive *d)
Definition: drive.c:3676
int burn_disc_free_multi_caps(struct burn_multi_caps **caps)
Definition: drive.c:3129
int burn_disc_get_write_mode_demands(struct burn_disc *disc, struct burn_write_opts *opts, struct burn_disc_mode_demands *result, int flag)
Definition: drive.c:3142
#define BURN_FREE_MEM(pt)
Definition: init.h:52
#define BURN_ALLOC_MEM(pt, typ, count)
Definition: init.h:40
#define BURN_REASONS_LEN
Definition: libburn.h:1817
burn_block_types
Definition: libburn.h:192
@ BURN_BLOCK_SAO
Definition: libburn.h:227
@ BURN_BLOCK_MODE1
Definition: libburn.h:202
burn_write_types
Definition: libburn.h:138
@ BURN_WRITE_RAW
Definition: libburn.h:180
@ BURN_WRITE_TAO
Definition: libburn.h:152
@ BURN_WRITE_SAO
Definition: libburn.h:163
@ BURN_WRITE_NONE
Definition: libburn.h:187
#define BURN_CDROM
Definition: libburn.h:70
@ BURN_DISC_BLANK
Definition: libburn.h:244
@ BURN_DISC_APPENDABLE
Definition: libburn.h:254
@ BURN_DISC_FULL
Definition: libburn.h:265
int libdax_msgs_submit(struct libdax_msgs *m, int origin, int error_code, int severity, int priority, char *msg_text, int os_errno, int flag)
Definition: libdax_msgs.c:334
int libdax_msgs__text_to_sev(char *severity_name, int *severity, int flag)
Definition: libdax_msgs.c:250
#define LIBDAX_MSGS_SEV_FATAL
Definition: libdax_msgs.h:217
#define LIBDAX_MSGS_PRIO_HIGH
Definition: libdax_msgs.h:237
#define LIBDAX_MSGS_SEV_SORRY
Definition: libdax_msgs.h:176
#define LIBDAX_MSGS_SEV_WARNING
Definition: libdax_msgs.h:154
#define LIBDAX_MSGS_SEV_FAILURE
Definition: libdax_msgs.h:205
void burn_write_opts_set_obs_pad(struct burn_write_opts *opts, int pad)
Definition: options.c:532
int burn_write_opts_set_simulate(struct burn_write_opts *opts, int sim)
Definition: options.c:184
void burn_read_opts_transfer_damaged_blocks(struct burn_read_opts *opts, int transfer_damaged_blocks)
Definition: options.c:593
void burn_write_opts_free(struct burn_write_opts *opts)
Definition: options.c:74
void burn_write_opts_set_fail21h_sev(struct burn_write_opts *opts, char *severity)
Definition: options.c:228
void burn_read_opts_set_hardware_error_retries(struct burn_read_opts *opts, unsigned char hardware_error_retries)
Definition: options.c:599
enum burn_write_types burn_write_opts_auto_write_type(struct burn_write_opts *opts, struct burn_disc *disc, char reasons[4096], int flag)
Definition: options.c:313
void burn_write_opts_set_has_mediacatalog(struct burn_write_opts *opts, int has_mediacatalog)
Definition: options.c:206
void burn_write_opts_set_format(struct burn_write_opts *opts, int format)
Definition: options.c:179
void burn_write_opts_set_stdio_fsync(struct burn_write_opts *opts, int rhythm)
Definition: options.c:539
void burn_write_opts_set_stream_recording(struct burn_write_opts *opts, int value)
Definition: options.c:515
void burn_write_opts_set_fillup(struct burn_write_opts *opts, int fill_up_media)
Definition: options.c:500
int burn_write_opts_set_underrun_proof(struct burn_write_opts *opts, int underrun_proof)
Definition: options.c:190
void burn_read_opts_read_subcodes_data(struct burn_read_opts *opts, int subcodes_data)
Definition: options.c:575
void burn_read_opts_read_subcodes_audio(struct burn_read_opts *opts, int subcodes_audio)
Definition: options.c:569
struct burn_drive * burn_write_opts_get_drive(struct burn_write_opts *opts)
Definition: options.c:553
void burn_read_opts_set_c2errors(struct burn_read_opts *opts, int c2errors)
Definition: options.c:564
void burn_write_opts_set_dvd_obs(struct burn_write_opts *opts, int obs)
Definition: options.c:523
struct libdax_msgs * libdax_messenger
Definition: init.c:42
void burn_write_opts_set_toc_entries(struct burn_write_opts *opts, int count, struct burn_toc_entry *toc_entries)
Definition: options.c:170
void burn_write_opts_set_force(struct burn_write_opts *opts, int use_force)
Definition: options.c:508
void burn_read_opts_set_raw(struct burn_read_opts *opts, int raw)
Definition: options.c:559
void burn_write_opts_set_perform_opc(struct burn_write_opts *opts, int opc)
Definition: options.c:201
struct burn_read_opts * burn_read_opts_new(struct burn_drive *drive)
Definition: options.c:112
void burn_read_opts_set_hardware_error_recovery(struct burn_read_opts *opts, int hardware_error_recovery)
Definition: options.c:581
void burn_read_opts_report_recovered_errors(struct burn_read_opts *opts, int report_recovered_errors)
Definition: options.c:587
void burn_write_opts_set_start_byte(struct burn_write_opts *opts, off_t value)
Definition: options.c:302
int burn_write_opts_clone(struct burn_write_opts *from, struct burn_write_opts **to, int flag)
Definition: options.c:83
void burn_write_opts_set_multi(struct burn_write_opts *opts, int multi)
Definition: options.c:220
void burn_read_opts_free(struct burn_read_opts *opts)
Definition: options.c:132
struct burn_write_opts * burn_write_opts_new(struct burn_drive *drive)
Definition: options.c:29
int burn_write_opts_set_leadin_text(struct burn_write_opts *opts, unsigned char *text_packs, int num_packs, int flag)
Definition: options.c:246
void burn_write_opts_set_mediacatalog(struct burn_write_opts *opts, unsigned char mediacatalog[13])
Definition: options.c:212
int burn_write_opts_set_write_type(struct burn_write_opts *opts, enum burn_write_types write_type, int block_type)
Definition: options.c:138
#define Libburn_stdio_fsync_limiT
Definition: options.h:101
#define Libburn_leadin_cdtext_packs_maX
Definition: options.h:108
int sector_get_outmode(enum burn_write_types write_type, enum burn_block_types block_type)
Definition: sector.c:70
int spc_block_type(enum burn_block_types b)
Definition: spc.c:1161
enum burn_disc_status status
Definition: transport.h:204
int current_is_cd_profile
Definition: transport.h:210
int global_index
Definition: transport.h:200
int block_types[4]
Definition: transport.h:393
struct scsi_mode_data * mdata
Definition: transport.h:523
int might_simulate
Definition: libburn.h:3697
unsigned int transfer_damaged_blocks
Definition: options.h:137
unsigned char hardware_error_retries
Definition: options.h:141
unsigned int raw
Definition: options.h:125
unsigned int c2errors
Definition: options.h:127
unsigned int subcodes_audio
Definition: options.h:129
unsigned int subcodes_data
Definition: options.h:131
unsigned int dap_bit
Definition: options.h:148
unsigned int report_recovered_errors
Definition: options.h:135
unsigned int hardware_error_recovery
Definition: options.h:133
struct burn_drive * drive
Definition: options.h:116
Definition: libburn.h:351
int force_is_set
Definition: options.h:58
int feat21h_fail_sev
Definition: options.h:96
int no_text_pack_crc_check
Definition: options.h:77
int has_mediacatalog
Definition: options.h:80
int fill_up_media
Definition: options.h:53
int do_stream_recording
Definition: options.h:64
struct burn_toc_entry * toc_entry
Definition: options.h:30
enum burn_block_types block_type
Definition: options.h:25
struct burn_drive * drive
Definition: options.h:17
int dvd_obs_override
Definition: options.h:68
unsigned char * text_packs
Definition: options.h:75
int num_text_packs
Definition: options.h:76
int toc_entries
Definition: options.h:28
off_t start_byte
Definition: options.h:50
unsigned int simulate
Definition: options.h:33
unsigned int perform_opc
Definition: options.h:40
unsigned char multi
Definition: options.h:89
enum burn_write_types write_type
Definition: options.h:23
unsigned int underrun_proof
Definition: options.h:37
unsigned char mediacatalog[13]
Definition: options.h:81
int stdio_fsync_size
Definition: options.h:72
unsigned char control
Definition: options.h:86
int underrun_proof
Definition: transport.h:110