Mario Danic
15 years ago
commit
2f2c115e08
96 changed files with 15010 additions and 0 deletions
@ -0,0 +1,5 @@ |
|||
Developers: |
|||
|
|||
Mario ฤaniฤ |
|||
Luke Biddell |
|||
Anant Narayanan |
|||
@ -0,0 +1,280 @@ |
|||
GNU GENERAL PUBLIC LICENSE |
|||
Version 2, June 1991 |
|||
|
|||
Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
|||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|||
Everyone is permitted to copy and distribute verbatim copies |
|||
of this license document, but changing it is not allowed. |
|||
|
|||
Preamble |
|||
|
|||
The licenses for most software are designed to take away your |
|||
freedom to share and change it. By contrast, the GNU General Public |
|||
License is intended to guarantee your freedom to share and change free |
|||
software--to make sure the software is free for all its users. This |
|||
General Public License applies to most of the Free Software |
|||
Foundation's software and to any other program whose authors commit to |
|||
using it. (Some other Free Software Foundation software is covered by |
|||
the GNU Library General Public License instead.) You can apply it to |
|||
your programs, too. |
|||
|
|||
When we speak of free software, we are referring to freedom, not |
|||
price. Our General Public Licenses are designed to make sure that you |
|||
have the freedom to distribute copies of free software (and charge for |
|||
this service if you wish), that you receive source code or can get it |
|||
if you want it, that you can change the software or use pieces of it |
|||
in new free programs; and that you know you can do these things. |
|||
|
|||
To protect your rights, we need to make restrictions that forbid |
|||
anyone to deny you these rights or to ask you to surrender the rights. |
|||
These restrictions translate to certain responsibilities for you if you |
|||
distribute copies of the software, or if you modify it. |
|||
|
|||
For example, if you distribute copies of such a program, whether |
|||
gratis or for a fee, you must give the recipients all the rights that |
|||
you have. You must make sure that they, too, receive or can get the |
|||
source code. And you must show them these terms so they know their |
|||
rights. |
|||
|
|||
We protect your rights with two steps: (1) copyright the software, and |
|||
(2) offer you this license which gives you legal permission to copy, |
|||
distribute and/or modify the software. |
|||
|
|||
Also, for each author's protection and ours, we want to make certain |
|||
that everyone understands that there is no warranty for this free |
|||
software. If the software is modified by someone else and passed on, we |
|||
want its recipients to know that what they have is not the original, so |
|||
that any problems introduced by others will not reflect on the original |
|||
authors' reputations. |
|||
|
|||
Finally, any free program is threatened constantly by software |
|||
patents. We wish to avoid the danger that redistributors of a free |
|||
program will individually obtain patent licenses, in effect making the |
|||
program proprietary. To prevent this, we have made it clear that any |
|||
patent must be licensed for everyone's free use or not licensed at all. |
|||
|
|||
The precise terms and conditions for copying, distribution and |
|||
modification follow. |
|||
|
|||
GNU GENERAL PUBLIC LICENSE |
|||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
|||
|
|||
0. This License applies to any program or other work which contains |
|||
a notice placed by the copyright holder saying it may be distributed |
|||
under the terms of this General Public License. The "Program", below, |
|||
refers to any such program or work, and a "work based on the Program" |
|||
means either the Program or any derivative work under copyright law: |
|||
that is to say, a work containing the Program or a portion of it, |
|||
either verbatim or with modifications and/or translated into another |
|||
language. (Hereinafter, translation is included without limitation in |
|||
the term "modification".) Each licensee is addressed as "you". |
|||
|
|||
Activities other than copying, distribution and modification are not |
|||
covered by this License; they are outside its scope. The act of |
|||
running the Program is not restricted, and the output from the Program |
|||
is covered only if its contents constitute a work based on the |
|||
Program (independent of having been made by running the Program). |
|||
Whether that is true depends on what the Program does. |
|||
|
|||
1. You may copy and distribute verbatim copies of the Program's |
|||
source code as you receive it, in any medium, provided that you |
|||
conspicuously and appropriately publish on each copy an appropriate |
|||
copyright notice and disclaimer of warranty; keep intact all the |
|||
notices that refer to this License and to the absence of any warranty; |
|||
and give any other recipients of the Program a copy of this License |
|||
along with the Program. |
|||
|
|||
You may charge a fee for the physical act of transferring a copy, and |
|||
you may at your option offer warranty protection in exchange for a fee. |
|||
|
|||
2. You may modify your copy or copies of the Program or any portion |
|||
of it, thus forming a work based on the Program, and copy and |
|||
distribute such modifications or work under the terms of Section 1 |
|||
above, provided that you also meet all of these conditions: |
|||
|
|||
a) You must cause the modified files to carry prominent notices |
|||
stating that you changed the files and the date of any change. |
|||
|
|||
b) You must cause any work that you distribute or publish, that in |
|||
whole or in part contains or is derived from the Program or any |
|||
part thereof, to be licensed as a whole at no charge to all third |
|||
parties under the terms of this License. |
|||
|
|||
c) If the modified program normally reads commands interactively |
|||
when run, you must cause it, when started running for such |
|||
interactive use in the most ordinary way, to print or display an |
|||
announcement including an appropriate copyright notice and a |
|||
notice that there is no warranty (or else, saying that you provide |
|||
a warranty) and that users may redistribute the program under |
|||
these conditions, and telling the user how to view a copy of this |
|||
License. (Exception: if the Program itself is interactive but |
|||
does not normally print such an announcement, your work based on |
|||
the Program is not required to print an announcement.) |
|||
|
|||
These requirements apply to the modified work as a whole. If |
|||
identifiable sections of that work are not derived from the Program, |
|||
and can be reasonably considered independent and separate works in |
|||
themselves, then this License, and its terms, do not apply to those |
|||
sections when you distribute them as separate works. But when you |
|||
distribute the same sections as part of a whole which is a work based |
|||
on the Program, the distribution of the whole must be on the terms of |
|||
this License, whose permissions for other licensees extend to the |
|||
entire whole, and thus to each and every part regardless of who wrote it. |
|||
|
|||
Thus, it is not the intent of this section to claim rights or contest |
|||
your rights to work written entirely by you; rather, the intent is to |
|||
exercise the right to control the distribution of derivative or |
|||
collective works based on the Program. |
|||
|
|||
In addition, mere aggregation of another work not based on the Program |
|||
with the Program (or with a work based on the Program) on a volume of |
|||
a storage or distribution medium does not bring the other work under |
|||
the scope of this License. |
|||
|
|||
3. You may copy and distribute the Program (or a work based on it, |
|||
under Section 2) in object code or executable form under the terms of |
|||
Sections 1 and 2 above provided that you also do one of the following: |
|||
|
|||
a) Accompany it with the complete corresponding machine-readable |
|||
source code, which must be distributed under the terms of Sections |
|||
1 and 2 above on a medium customarily used for software interchange; or, |
|||
|
|||
b) Accompany it with a written offer, valid for at least three |
|||
years, to give any third party, for a charge no more than your |
|||
cost of physically performing source distribution, a complete |
|||
machine-readable copy of the corresponding source code, to be |
|||
distributed under the terms of Sections 1 and 2 above on a medium |
|||
customarily used for software interchange; or, |
|||
|
|||
c) Accompany it with the information you received as to the offer |
|||
to distribute corresponding source code. (This alternative is |
|||
allowed only for noncommercial distribution and only if you |
|||
received the program in object code or executable form with such |
|||
an offer, in accord with Subsection b above.) |
|||
|
|||
The source code for a work means the preferred form of the work for |
|||
making modifications to it. For an executable work, complete source |
|||
code means all the source code for all modules it contains, plus any |
|||
associated interface definition files, plus the scripts used to |
|||
control compilation and installation of the executable. However, as a |
|||
special exception, the source code distributed need not include |
|||
anything that is normally distributed (in either source or binary |
|||
form) with the major components (compiler, kernel, and so on) of the |
|||
operating system on which the executable runs, unless that component |
|||
itself accompanies the executable. |
|||
|
|||
If distribution of executable or object code is made by offering |
|||
access to copy from a designated place, then offering equivalent |
|||
access to copy the source code from the same place counts as |
|||
distribution of the source code, even though third parties are not |
|||
compelled to copy the source along with the object code. |
|||
|
|||
4. You may not copy, modify, sublicense, or distribute the Program |
|||
except as expressly provided under this License. Any attempt |
|||
otherwise to copy, modify, sublicense or distribute the Program is |
|||
void, and will automatically terminate your rights under this License. |
|||
However, parties who have received copies, or rights, from you under |
|||
this License will not have their licenses terminated so long as such |
|||
parties remain in full compliance. |
|||
|
|||
5. You are not required to accept this License, since you have not |
|||
signed it. However, nothing else grants you permission to modify or |
|||
distribute the Program or its derivative works. These actions are |
|||
prohibited by law if you do not accept this License. Therefore, by |
|||
modifying or distributing the Program (or any work based on the |
|||
Program), you indicate your acceptance of this License to do so, and |
|||
all its terms and conditions for copying, distributing or modifying |
|||
the Program or works based on it. |
|||
|
|||
6. Each time you redistribute the Program (or any work based on the |
|||
Program), the recipient automatically receives a license from the |
|||
original licensor to copy, distribute or modify the Program subject to |
|||
these terms and conditions. You may not impose any further |
|||
restrictions on the recipients' exercise of the rights granted herein. |
|||
You are not responsible for enforcing compliance by third parties to |
|||
this License. |
|||
|
|||
7. If, as a consequence of a court judgment or allegation of patent |
|||
infringement or for any other reason (not limited to patent issues), |
|||
conditions are imposed on you (whether by court order, agreement or |
|||
otherwise) that contradict the conditions of this License, they do not |
|||
excuse you from the conditions of this License. If you cannot |
|||
distribute so as to satisfy simultaneously your obligations under this |
|||
License and any other pertinent obligations, then as a consequence you |
|||
may not distribute the Program at all. For example, if a patent |
|||
license would not permit royalty-free redistribution of the Program by |
|||
all those who receive copies directly or indirectly through you, then |
|||
the only way you could satisfy both it and this License would be to |
|||
refrain entirely from distribution of the Program. |
|||
|
|||
If any portion of this section is held invalid or unenforceable under |
|||
any particular circumstance, the balance of the section is intended to |
|||
apply and the section as a whole is intended to apply in other |
|||
circumstances. |
|||
|
|||
It is not the purpose of this section to induce you to infringe any |
|||
patents or other property right claims or to contest validity of any |
|||
such claims; this section has the sole purpose of protecting the |
|||
integrity of the free software distribution system, which is |
|||
implemented by public license practices. Many people have made |
|||
generous contributions to the wide range of software distributed |
|||
through that system in reliance on consistent application of that |
|||
system; it is up to the author/donor to decide if he or she is willing |
|||
to distribute software through any other system and a licensee cannot |
|||
impose that choice. |
|||
|
|||
This section is intended to make thoroughly clear what is believed to |
|||
be a consequence of the rest of this License. |
|||
|
|||
8. If the distribution and/or use of the Program is restricted in |
|||
certain countries either by patents or by copyrighted interfaces, the |
|||
original copyright holder who places the Program under this License |
|||
may add an explicit geographical distribution limitation excluding |
|||
those countries, so that distribution is permitted only in or among |
|||
countries not thus excluded. In such case, this License incorporates |
|||
the limitation as if written in the body of this License. |
|||
|
|||
9. The Free Software Foundation may publish revised and/or new versions |
|||
of the General Public License from time to time. Such new versions will |
|||
be similar in spirit to the present version, but may differ in detail to |
|||
address new problems or concerns. |
|||
|
|||
Each version is given a distinguishing version number. If the Program |
|||
specifies a version number of this License which applies to it and "any |
|||
later version", you have the option of following the terms and conditions |
|||
either of that version or of any later version published by the Free |
|||
Software Foundation. If the Program does not specify a version number of |
|||
this License, you may choose any version ever published by the Free Software |
|||
Foundation. |
|||
|
|||
10. If you wish to incorporate parts of the Program into other free |
|||
programs whose distribution conditions are different, write to the author |
|||
to ask for permission. For software which is copyrighted by the Free |
|||
Software Foundation, write to the Free Software Foundation; we sometimes |
|||
make exceptions for this. Our decision will be guided by the two goals |
|||
of preserving the free status of all derivatives of our free software and |
|||
of promoting the sharing and reuse of software generally. |
|||
|
|||
NO WARRANTY |
|||
|
|||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
|||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
|||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
|||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
|||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
|||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
|||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
|||
REPAIR OR CORRECTION. |
|||
|
|||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
|||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
|||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
|||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
|||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
|||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
|||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
|||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
|||
POSSIBILITY OF SUCH DAMAGES. |
|||
|
|||
END OF TERMS AND CONDITIONS |
|||
@ -0,0 +1,18 @@ |
|||
Derek Foreman <derek@signalmarketing.com> and Ben Jansens <xor@orodu.net> |
|||
Copyright (C) 2002-2004 Derek Foreman and Ben Jansens |
|||
Mario ฤaniฤ <mario.danic@gmail.com>, Luke Biddell <luke.biddell@gmail.com>, Anant Narayanan <anant@kix.in> |
|||
Copyright (C) 2006 Mario ฤaniฤ, Luke Biddell, Anant Narayanan |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 2 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|||
@ -0,0 +1,192 @@ |
|||
pkgconfigdir=$(libdir)/pkgconfig |
|||
libincludedir=$(includedir)/libburn/@BURN_MAJOR_VERSION@/libburn |
|||
|
|||
lib_LTLIBRARIES = libburn/libburn.la libisofs/libisofs.la |
|||
|
|||
## ========================================================================= ##
|
|||
|
|||
# Build libraries
|
|||
libburn_libburn_la_LDFLAGS = \
|
|||
-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) |
|||
libburn_libburn_la_SOURCES = \
|
|||
libburn/async.c \
|
|||
libburn/async.h \
|
|||
libburn/crc.c \
|
|||
libburn/crc.h \
|
|||
libburn/debug.c \
|
|||
libburn/debug.h \
|
|||
libburn/drive.c \
|
|||
libburn/drive.h \
|
|||
libburn/error.h \
|
|||
libburn/file.c \
|
|||
libburn/file.h \
|
|||
libburn/init.c \
|
|||
libburn/init.h \
|
|||
libburn/lec.c \
|
|||
libburn/lec.h \
|
|||
libburn/libburn.h \
|
|||
libburn/message.c \
|
|||
libburn/message.h \
|
|||
libburn/mmc.c \
|
|||
libburn/mmc.h \
|
|||
libburn/null.c \
|
|||
libburn/null.h \
|
|||
libburn/options.c \
|
|||
libburn/options.h \
|
|||
libburn/read.c \
|
|||
libburn/read.h \
|
|||
libburn/sbc.c \
|
|||
libburn/sbc.h \
|
|||
libburn/sector.c \
|
|||
libburn/sector.h \
|
|||
libburn/sg.c \
|
|||
libburn/sg.h \
|
|||
libburn/source.h \
|
|||
libburn/source.c \
|
|||
libburn/spc.c \
|
|||
libburn/spc.h \
|
|||
libburn/structure.c \
|
|||
libburn/structure.h \
|
|||
libburn/toc.c \
|
|||
libburn/toc.h \
|
|||
libburn/transport.h \
|
|||
libburn/util.c \
|
|||
libburn/util.h \
|
|||
libburn/write.c \
|
|||
libburn/write.h \
|
|||
version.h |
|||
|
|||
libisofs_libisofs_la_LDFLAGS = \
|
|||
-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) |
|||
libisofs_libisofs_la_SOURCES = \
|
|||
libisofs/errors.h \
|
|||
libisofs/errors.c \
|
|||
libisofs/tree.h \
|
|||
libisofs/tree.c \
|
|||
libisofs/volume.h \
|
|||
libisofs/volume.c \
|
|||
libisofs/util.h \
|
|||
libisofs/util.c \
|
|||
libisofs/ecma119.c \
|
|||
libisofs/ecma119.h \
|
|||
libisofs/struct.h \
|
|||
libisofs/struct.c \
|
|||
libisofs/susp.h \
|
|||
libisofs/susp.c \
|
|||
libisofs/rockridge.h \
|
|||
libisofs/rockridge.c \
|
|||
libisofs/libisofs.h |
|||
|
|||
libinclude_HEADERS = \
|
|||
libburn/libburn.h \
|
|||
libisofs/libisofs.h |
|||
|
|||
## ========================================================================= ##
|
|||
|
|||
## Build test applications
|
|||
noinst_PROGRAMS = \
|
|||
test/blank \
|
|||
test/burn \
|
|||
test/burniso \
|
|||
test/devices \
|
|||
test/iso \
|
|||
test/master \
|
|||
test/poll \
|
|||
test/rip \
|
|||
test/toc \
|
|||
test/structest |
|||
|
|||
test_devices_CPPFLAGS = -Ilibburn |
|||
test_devices_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_devices_SOURCES = test/devices.c |
|||
test_poll_CPPFLAGS = -Ilibburn |
|||
test_poll_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_poll_SOURCES = test/poll.c |
|||
test_toc_CPPFLAGS = -Ilibburn |
|||
test_toc_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_toc_SOURCES = test/toc.c |
|||
test_rip_CPPFLAGS = -Ilibburn |
|||
test_rip_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_rip_SOURCES = test/rip.c |
|||
test_burn_CPPFLAGS = -Ilibburn |
|||
test_burn_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_burn_SOURCES = test/burn.c |
|||
test_burniso_CPPFLAGS = -Ilibburn |
|||
test_burniso_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_burniso_SOURCES = test/burniso.c |
|||
test_master_CPPFLAGS = -Ilibburn |
|||
test_master_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_master_SOURCES = test/master.c |
|||
test_structest_CPPFLAGS = -Ilibburn |
|||
test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_structest_SOURCES = test/structest.c |
|||
test_blank_CPPFLAGS = -Ilibburn |
|||
test_blank_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS) |
|||
test_blank_SOURCES = test/blank.c |
|||
test_iso_CPPFLAGS = -Ilibisofs |
|||
test_iso_LDADD = $(libisofs_libisofs_la_OBJECTS) $(THREAD_LIBS) |
|||
test_iso_SOURCES = test/iso.c |
|||
|
|||
## ========================================================================= ##
|
|||
|
|||
## Build documentation (You need Doxygen for this to work)
|
|||
webhost = http://libburn-api.pykix.org |
|||
webpath = / |
|||
|
|||
docdeps = \
|
|||
doc/doxygen.conf \
|
|||
doc/comments \
|
|||
libburn/libburn.h \
|
|||
libisofs/libisofs.h \
|
|||
test/burniso.c |
|||
|
|||
doc: doc/html |
|||
|
|||
doc/html: $(docdeps) |
|||
$(RM) -r $@ |
|||
doxygen doc/doxygen.conf |
|||
|
|||
doc-upload: doc/html |
|||
scp -r $</* $(webhost):$(webpath) |
|||
|
|||
.PHONY: doc |
|||
|
|||
## ========================================================================= ##
|
|||
|
|||
# Indent source files
|
|||
indent_files = \
|
|||
$(libisofs_libisofs_la_SOURCES) \
|
|||
$(libburn_libburn_la_SOURCES) \
|
|||
$(test_devices_SOURCES) \
|
|||
$(test_poll_SOURCES) \
|
|||
$(test_toc_SOURCES) \
|
|||
$(test_rip_SOURCES) \
|
|||
$(test_burn_SOURCES) \
|
|||
$(test_burniso_SOURCES) \
|
|||
$(test_master_SOURCES) \
|
|||
$(test_structest_SOURCES) \
|
|||
$(test_blank_SOURCES) |
|||
|
|||
indent: $(indent_files) |
|||
indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls \
|
|||
-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79 \
|
|||
-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
|
|||
-sbi0 -nsc -ts8 -npcs -ncdb -fca \
|
|||
$^ |
|||
|
|||
.PHONY: indent |
|||
|
|||
## ========================================================================= ##
|
|||
|
|||
# Extra things
|
|||
nodist_pkgconfig_DATA = \
|
|||
libburn-1.pc \
|
|||
libisofs-1.pc |
|||
|
|||
EXTRA_DIST = \
|
|||
libburn-1.pc.in \
|
|||
libisofs-1.pc.in \
|
|||
version.h.in \
|
|||
doc/doxygen.conf.in \
|
|||
README \
|
|||
COPYING |
|||
@ -0,0 +1,37 @@ |
|||
dnl Function to link an architecture specific file |
|||
dnl LINK_ARCH_SRC(source_dir, arch, source_file) |
|||
AC_DEFUN([COPY_ARCH_SRC], |
|||
[ |
|||
echo "copying $1/$2/$3 -> $1/$3" |
|||
old="$srcdir/$1/$2/$3" |
|||
new="$srcdir/$1/$3" |
|||
cat >$new <<__EOF__ |
|||
/* WARNING: This file was automatically generated! |
|||
* Original: $old |
|||
*/ |
|||
__EOF__ |
|||
cat >>$new <$old |
|||
]) |
|||
|
|||
AC_DEFUN([TARGET_SHIZZLE], |
|||
[ |
|||
ARCH="" |
|||
|
|||
AC_MSG_CHECKING([target operating system]) |
|||
|
|||
case $target in |
|||
*-*-linux*) |
|||
ARCH=linux |
|||
;; |
|||
*) |
|||
AC_ERROR([You are attempting to compile for an unsupported platform]) |
|||
;; |
|||
esac |
|||
|
|||
AC_MSG_RESULT([$ARCH]) |
|||
|
|||
# this doesn't actually do anything yet.. but it will someday when we port |
|||
# libburn |
|||
|
|||
#COPY_ARCH_SRC(libburn, $ARCH, transport.c) |
|||
]) |
|||
@ -0,0 +1,6 @@ |
|||
#!/bin/sh -x |
|||
|
|||
aclocal-1.7 |
|||
libtoolize --copy --force |
|||
autoconf |
|||
automake-1.7 --foreign --add-missing --copy --include-deps |
|||
@ -0,0 +1,103 @@ |
|||
AC_INIT([libburn], [0.2.1], [http://libburn.pykix.org]) |
|||
AC_PREREQ([2.50]) |
|||
dnl AC_CONFIG_HEADER([config.h]) |
|||
|
|||
AC_CANONICAL_HOST |
|||
AC_CANONICAL_TARGET |
|||
|
|||
AM_INIT_AUTOMAKE([subdir-objects]) |
|||
|
|||
dnl Making releases: |
|||
dnl BURN_MICRO_VERSION += 1; |
|||
dnl BURN_INTERFACE_AGE += 1; |
|||
dnl BURN_BINARY_AGE += 1; |
|||
dnl if any functions have been added, set BURN_INTERFACE_AGE to 0. |
|||
dnl if backwards compatibility has been broken, |
|||
dnl set BURN_BINARY_AGE and BURN_INTERFACE_AGE to 0. |
|||
dnl |
|||
dnl if MAJOR or MINOR version changes, be sure to change AC_INIT above to match |
|||
dnl |
|||
BURN_MAJOR_VERSION=0 |
|||
BURN_MINOR_VERSION=2 |
|||
BURN_MICRO_VERSION=1 |
|||
BURN_INTERFACE_AGE=0 |
|||
BURN_BINARY_AGE=0 |
|||
BURN_VERSION=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION |
|||
|
|||
AC_SUBST(BURN_MAJOR_VERSION) |
|||
AC_SUBST(BURN_MINOR_VERSION) |
|||
AC_SUBST(BURN_MICRO_VERSION) |
|||
AC_SUBST(BURN_INTERFACE_AGE) |
|||
AC_SUBST(BURN_BINARY_AGE) |
|||
AC_SUBST(BURN_VERSION) |
|||
|
|||
dnl Libtool versioning |
|||
LT_RELEASE=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION |
|||
LT_CURRENT=`expr $BURN_MICRO_VERSION - $BURN_INTERFACE_AGE` |
|||
LT_REVISION=$BURN_INTERFACE_AGE |
|||
LT_AGE=`expr $BURN_BINARY_AGE - $BURN_INTERFACE_AGE` |
|||
LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE` |
|||
|
|||
AC_SUBST(LT_RELEASE) |
|||
AC_SUBST(LT_CURRENT) |
|||
AC_SUBST(LT_REVISION) |
|||
AC_SUBST(LT_AGE) |
|||
AC_SUBST(LT_CURRENT_MINUS_AGE) |
|||
|
|||
AC_PREFIX_DEFAULT([/usr/local]) |
|||
test "$prefix" = "NONE" && prefix=$ac_default_prefix |
|||
|
|||
AM_MAINTAINER_MODE |
|||
|
|||
AM_PROG_CC_C_O |
|||
AC_C_CONST |
|||
AC_C_INLINE |
|||
AC_C_BIGENDIAN |
|||
|
|||
dnl Large file support |
|||
AC_SYS_LARGEFILE |
|||
AC_FUNC_FSEEKO |
|||
if test ! $ac_cv_func_fseeko; then |
|||
AC_ERROR([Libburn requires largefile support.]) |
|||
fi |
|||
|
|||
AC_PROG_LIBTOOL |
|||
AC_SUBST(LIBTOOL_DEPS) |
|||
LIBTOOL="$LIBTOOL --silent" |
|||
|
|||
AC_PROG_INSTALL |
|||
|
|||
AC_CHECK_HEADERS() |
|||
|
|||
THREAD_LIBS=-lpthread |
|||
AC_SUBST(THREAD_LIBS) |
|||
|
|||
TARGET_SHIZZLE |
|||
|
|||
dnl Add compiler-specific flags |
|||
|
|||
dnl See if the user wants aggressive optimizations of the code |
|||
AC_ARG_ENABLE(debug, |
|||
[ --enable-debug Disable aggressive optimizations [default=yes]], |
|||
, enable_debug=yes) |
|||
if test x$enable_debug != xyes; then |
|||
if test x$GCC = xyes; then |
|||
CFLAGS="$CFLAGS -O3" |
|||
CFLAGS="$CFLAGS -fexpensive-optimizations" |
|||
fi |
|||
CFLAGS="$CFLAGS -DNDEBUG" |
|||
else |
|||
if test x$GCC = xyes; then |
|||
CFLAGS="$CFLAGS -g -pedantic -Wall" |
|||
fi |
|||
CFLAGS="$CFLAGS -DDEBUG" |
|||
fi |
|||
|
|||
AC_CONFIG_FILES([ |
|||
Makefile |
|||
doc/doxygen.conf |
|||
version.h |
|||
libburn-1.pc |
|||
libisofs-1.pc |
|||
]) |
|||
AC_OUTPUT |
|||
@ -0,0 +1,4 @@ |
|||
all clean: |
|||
$(MAKE) -C .. -$(MAKEFLAGS) $@ |
|||
|
|||
.PHONY: all clean |
|||
@ -0,0 +1,52 @@ |
|||
/** |
|||
@author Dana Jansens, Derek Foreman |
|||
|
|||
@mainpage Libburn Documentation Index |
|||
|
|||
@section intro Introduction |
|||
|
|||
Libburn is an open source library suite for reading, mastering and writing |
|||
optical discs. |
|||
|
|||
@section using Using the library |
|||
|
|||
@subsection concepts Library concepts |
|||
|
|||
There are a few concepts to introduce in order for you to understand how to |
|||
use Libburn. So, lets start with them: |
|||
|
|||
<ol> |
|||
<li> Read - The process of reading the data on a disc for storage or |
|||
copying. |
|||
<li> Write - The process of writing data onto a disc to create a new |
|||
disc image or append to an existing one. |
|||
<li> Drive - A Drive is a hardware device used to reading and/or writing |
|||
discs. CD burners and CD-ROMs are examples of Drives. |
|||
</ol> |
|||
|
|||
@subsection working Working with the library |
|||
|
|||
Now that you understand the above @ref concepts, you're ready to look at the |
|||
actual use of the library. |
|||
|
|||
In general, using the library to perform a process consists of the following |
|||
steps: |
|||
|
|||
<ol> |
|||
<li> Initialize the library. (If not already done; a single instance of |
|||
the library can perform multiple operations simultaneously with |
|||
multiple drives.) |
|||
<li> Scan for available Drives. |
|||
<li> Choose and grab a Drive for reading/writing. |
|||
<li> Fill in the options for the operation. |
|||
<li> Wait for the operation to complete, displaying status along the way |
|||
if desired. |
|||
<li> Release the Drive. |
|||
<li> Destroy the library instance. (If you're done working with the |
|||
library.) |
|||
</ol> |
|||
|
|||
Here's a very simple example of burning an ISO file |
|||
|
|||
@include burniso.c |
|||
*/ |
|||
@ -0,0 +1,186 @@ |
|||
# Doxyfile 1.2.18 |
|||
|
|||
#--------------------------------------------------------------------------- |
|||
# General configuration options |
|||
#--------------------------------------------------------------------------- |
|||
PROJECT_NAME = @PACKAGE_NAME@ |
|||
PROJECT_NUMBER = @PACKAGE_VERSION@ |
|||
OUTPUT_DIRECTORY = |
|||
OUTPUT_LANGUAGE = English |
|||
EXTRACT_ALL = YES |
|||
EXTRACT_PRIVATE = YES |
|||
EXTRACT_STATIC = YES |
|||
EXTRACT_LOCAL_CLASSES = YES |
|||
HIDE_UNDOC_MEMBERS = NO |
|||
HIDE_UNDOC_CLASSES = NO |
|||
HIDE_FRIEND_COMPOUNDS = NO |
|||
BRIEF_MEMBER_DESC = YES |
|||
REPEAT_BRIEF = YES |
|||
ALWAYS_DETAILED_SEC = NO |
|||
INLINE_INHERITED_MEMB = NO |
|||
FULL_PATH_NAMES = YES |
|||
STRIP_FROM_PATH = @top_srcdir@ |
|||
INTERNAL_DOCS = NO |
|||
STRIP_CODE_COMMENTS = NO |
|||
CASE_SENSE_NAMES = NO |
|||
SHORT_NAMES = NO |
|||
HIDE_SCOPE_NAMES = NO |
|||
VERBATIM_HEADERS = YES |
|||
SHOW_INCLUDE_FILES = YES |
|||
JAVADOC_AUTOBRIEF = YES |
|||
MULTILINE_CPP_IS_BRIEF = YES |
|||
DETAILS_AT_TOP = YES |
|||
INHERIT_DOCS = YES |
|||
INLINE_INFO = YES |
|||
SORT_MEMBER_DOCS = YES |
|||
DISTRIBUTE_GROUP_DOC = NO |
|||
TAB_SIZE = 4 |
|||
GENERATE_TODOLIST = YES |
|||
GENERATE_TESTLIST = YES |
|||
GENERATE_BUGLIST = YES |
|||
GENERATE_DEPRECATEDLIST= YES |
|||
ALIASES = |
|||
ENABLED_SECTIONS = |
|||
MAX_INITIALIZER_LINES = 30 |
|||
OPTIMIZE_OUTPUT_FOR_C = YES |
|||
OPTIMIZE_OUTPUT_JAVA = NO |
|||
SHOW_USED_FILES = YES |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to warning and progress messages |
|||
#--------------------------------------------------------------------------- |
|||
QUIET = YES |
|||
WARNINGS = YES |
|||
WARN_IF_UNDOCUMENTED = YES |
|||
WARN_FORMAT = "$file:$line: $text" |
|||
WARN_LOGFILE = |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the input files |
|||
#--------------------------------------------------------------------------- |
|||
INPUT = libburn libisofs doc |
|||
FILE_PATTERNS = libburn.h libisofs.h comments |
|||
RECURSIVE = NO |
|||
EXCLUDE = |
|||
EXCLUDE_SYMLINKS = NO |
|||
EXCLUDE_PATTERNS = |
|||
EXAMPLE_PATH = test |
|||
EXAMPLE_PATTERNS = |
|||
EXAMPLE_RECURSIVE = NO |
|||
IMAGE_PATH = |
|||
INPUT_FILTER = |
|||
FILTER_SOURCE_FILES = NO |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to source browsing |
|||
#--------------------------------------------------------------------------- |
|||
SOURCE_BROWSER = YES |
|||
INLINE_SOURCES = YES |
|||
REFERENCED_BY_RELATION = YES |
|||
REFERENCES_RELATION = YES |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the alphabetical class index |
|||
#--------------------------------------------------------------------------- |
|||
ALPHABETICAL_INDEX = NO |
|||
COLS_IN_ALPHA_INDEX = 5 |
|||
IGNORE_PREFIX = OB OTK _ |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the HTML output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_HTML = YES |
|||
HTML_OUTPUT = doc/html |
|||
HTML_FILE_EXTENSION = .html |
|||
HTML_HEADER = |
|||
HTML_FOOTER = |
|||
HTML_STYLESHEET = |
|||
HTML_ALIGN_MEMBERS = YES |
|||
GENERATE_HTMLHELP = NO |
|||
CHM_FILE = |
|||
HHC_LOCATION = |
|||
GENERATE_CHI = NO |
|||
BINARY_TOC = NO |
|||
TOC_EXPAND = NO |
|||
DISABLE_INDEX = NO |
|||
ENUM_VALUES_PER_LINE = 4 |
|||
GENERATE_TREEVIEW = NO |
|||
TREEVIEW_WIDTH = 200 |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the LaTeX output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_LATEX = NO |
|||
LATEX_OUTPUT = latex |
|||
LATEX_CMD_NAME = latex |
|||
MAKEINDEX_CMD_NAME = makeindex |
|||
COMPACT_LATEX = NO |
|||
PAPER_TYPE = letter |
|||
EXTRA_PACKAGES = |
|||
LATEX_HEADER = |
|||
PDF_HYPERLINKS = YES |
|||
USE_PDFLATEX = NO |
|||
LATEX_BATCHMODE = NO |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the RTF output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_RTF = NO |
|||
RTF_OUTPUT = rtf |
|||
COMPACT_RTF = NO |
|||
RTF_HYPERLINKS = NO |
|||
RTF_STYLESHEET_FILE = |
|||
RTF_EXTENSIONS_FILE = |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the man page output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_MAN = NO |
|||
MAN_OUTPUT = man |
|||
MAN_EXTENSION = .3 |
|||
MAN_LINKS = NO |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options related to the XML output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_XML = NO |
|||
XML_SCHEMA = |
|||
XML_DTD = |
|||
#--------------------------------------------------------------------------- |
|||
# configuration options for the AutoGen Definitions output |
|||
#--------------------------------------------------------------------------- |
|||
GENERATE_AUTOGEN_DEF = NO |
|||
#--------------------------------------------------------------------------- |
|||
# Configuration options related to the preprocessor |
|||
#--------------------------------------------------------------------------- |
|||
ENABLE_PREPROCESSING = YES |
|||
MACRO_EXPANSION = NO |
|||
EXPAND_ONLY_PREDEF = NO |
|||
SEARCH_INCLUDES = YES |
|||
INCLUDE_PATH = |
|||
INCLUDE_FILE_PATTERNS = |
|||
PREDEFINED = DOXYGEN |
|||
EXPAND_AS_DEFINED = |
|||
SKIP_FUNCTION_MACROS = YES |
|||
#--------------------------------------------------------------------------- |
|||
# Configuration::addtions related to external references |
|||
#--------------------------------------------------------------------------- |
|||
TAGFILES = |
|||
GENERATE_TAGFILE = |
|||
ALLEXTERNALS = NO |
|||
EXTERNAL_GROUPS = YES |
|||
PERL_PATH = /usr/bin/perl |
|||
#--------------------------------------------------------------------------- |
|||
# Configuration options related to the dot tool |
|||
#--------------------------------------------------------------------------- |
|||
CLASS_DIAGRAMS = YES |
|||
HIDE_UNDOC_RELATIONS = YES |
|||
HAVE_DOT = YES |
|||
CLASS_GRAPH = YES |
|||
COLLABORATION_GRAPH = YES |
|||
TEMPLATE_RELATIONS = YES |
|||
INCLUDE_GRAPH = YES |
|||
INCLUDED_BY_GRAPH = YES |
|||
GRAPHICAL_HIERARCHY = NO |
|||
DOT_IMAGE_FORMAT = png |
|||
DOT_PATH = |
|||
DOTFILE_DIRS = |
|||
MAX_DOT_GRAPH_WIDTH = 1024 |
|||
MAX_DOT_GRAPH_HEIGHT = 1024 |
|||
GENERATE_LEGEND = YES |
|||
DOT_CLEANUP = YES |
|||
#--------------------------------------------------------------------------- |
|||
# Configuration::addtions related to the search engine |
|||
#--------------------------------------------------------------------------- |
|||
SEARCHENGINE = NO |
|||
@ -0,0 +1,11 @@ |
|||
prefix=@prefix@ |
|||
exec_prefix=@exec_prefix@ |
|||
libdir=@libdir@ |
|||
includedir=@includedir@ |
|||
|
|||
Name: libburn |
|||
Description: Disc reading/writing library |
|||
Version: @VERSION@ |
|||
Requires: |
|||
Libs: -L${libdir} -lburn @THREAD_LIBS@ |
|||
Cflags: -I${includedir}/libburn/@BURN_MAJOR_VERSION@ |
|||
@ -0,0 +1,4 @@ |
|||
all clean: |
|||
$(MAKE) -C .. -$(MAKEFLAGS) $@ |
|||
|
|||
.PHONY: all clean |
|||
@ -0,0 +1,65 @@ |
|||
pkgconfigdir=$(libdir)/pkgconfig |
|||
libincludedir=$(includedir)/libburn/@BURN_MAJOR_VERSION@ |
|||
|
|||
lib_LTLIBRARIES = libburn.la |
|||
|
|||
libburn_la_SOURCES = \
|
|||
async.c \
|
|||
async.h \
|
|||
crc.c \
|
|||
crc.h \
|
|||
debug.c \
|
|||
debug.h \
|
|||
drive.c \
|
|||
drive.h \
|
|||
file.c \
|
|||
file.h \
|
|||
init.c \
|
|||
init.h \
|
|||
lec.c \
|
|||
lec.h \
|
|||
message.c \
|
|||
message.h \
|
|||
mmc.c \
|
|||
mmc.h \
|
|||
null.c \
|
|||
null.h \
|
|||
options.c \
|
|||
options.h \
|
|||
read.c \
|
|||
read.h \
|
|||
sbc.c \
|
|||
sbc.h \
|
|||
sector.c \
|
|||
sector.h \
|
|||
sg.c \
|
|||
sg.h \
|
|||
spc.c \
|
|||
spc.h \
|
|||
source.h \
|
|||
source.c \
|
|||
structure.c \
|
|||
structure.h \
|
|||
toc.c \
|
|||
toc.h \
|
|||
transport.h \
|
|||
util.c \
|
|||
util.h \
|
|||
write.c \
|
|||
write.h |
|||
|
|||
libinclude_HEADERS = libburn.h |
|||
|
|||
## ========================================================================= ##
|
|||
indent_files = $(libburn_la_SOURCES) |
|||
|
|||
indent: $(indent_files) |
|||
indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls \
|
|||
-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79 \
|
|||
-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
|
|||
-sbi0 -nsc -ts8 -npcs -ncdb -fca \
|
|||
$^ |
|||
|
|||
.PHONY: indent |
|||
|
|||
## ========================================================================= ##
|
|||
@ -0,0 +1,191 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#include "libburn.h" |
|||
#include "transport.h" |
|||
#include "drive.h" |
|||
#include "write.h" |
|||
#include "options.h" |
|||
#include "async.h" |
|||
|
|||
#include <pthread.h> |
|||
#include <assert.h> |
|||
#include <stdlib.h> |
|||
|
|||
#define SCAN_GOING() (workers && !workers->drive) |
|||
|
|||
typedef void *(*WorkerFunc) (void *); |
|||
|
|||
struct scan_opts |
|||
{ |
|||
struct burn_drive_info **drives; |
|||
unsigned int *n_drives; |
|||
|
|||
int done; |
|||
}; |
|||
|
|||
struct erase_opts |
|||
{ |
|||
struct burn_drive *drive; |
|||
int fast; |
|||
}; |
|||
|
|||
struct write_opts |
|||
{ |
|||
struct burn_drive *drive; |
|||
struct burn_write_opts *opts; |
|||
struct burn_disc *disc; |
|||
}; |
|||
|
|||
struct w_list |
|||
{ |
|||
struct burn_drive *drive; |
|||
pthread_t thread; |
|||
|
|||
struct w_list *next; |
|||
|
|||
union w_list_data |
|||
{ |
|||
struct scan_opts scan; |
|||
struct erase_opts erase; |
|||
struct write_opts write; |
|||
} u; |
|||
}; |
|||
|
|||
static struct w_list *workers; |
|||
|
|||
static struct w_list *find_worker(struct burn_drive *d) |
|||
{ |
|||
struct w_list *a; |
|||
|
|||
for (a = workers; a; a = a->next) |
|||
if (a->drive == d) |
|||
return a; |
|||
return NULL; |
|||
} |
|||
|
|||
static void add_worker(struct burn_drive *d, WorkerFunc f, void *data) |
|||
{ |
|||
struct w_list *a; |
|||
struct w_list *tmp; |
|||
|
|||
a = malloc(sizeof(struct w_list)); |
|||
a->drive = d; |
|||
a->u = *(union w_list_data *)data; |
|||
|
|||
/* insert at front of the list */ |
|||
a->next = workers; |
|||
tmp = workers; |
|||
workers = a; |
|||
|
|||
if (d) |
|||
d->busy = BURN_DRIVE_SPAWNING; |
|||
|
|||
if (pthread_create(&a->thread, NULL, f, a)) { |
|||
free(a); |
|||
workers = tmp; |
|||
return; |
|||
} |
|||
} |
|||
|
|||
static void remove_worker(pthread_t th) |
|||
{ |
|||
struct w_list *a, *l = NULL; |
|||
|
|||
for (a = workers; a; l = a, a = a->next) |
|||
if (a->thread == th) { |
|||
if (l) |
|||
l->next = a->next; |
|||
else |
|||
workers = a->next; |
|||
free(a); |
|||
break; |
|||
} |
|||
assert(a != NULL); /* wasn't found.. this should not be possible */ |
|||
} |
|||
|
|||
static void *scan_worker_func(struct w_list *w) |
|||
{ |
|||
burn_drive_scan_sync(w->u.scan.drives, w->u.scan.n_drives); |
|||
w->u.scan.done = 1; |
|||
return NULL; |
|||
} |
|||
|
|||
int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives) |
|||
{ |
|||
struct scan_opts o; |
|||
int ret = 0; |
|||
|
|||
/* cant be anything working! */ |
|||
assert(!(workers && workers->drive)); |
|||
|
|||
if (!workers) { |
|||
/* start it */ |
|||
o.drives = drives; |
|||
o.n_drives = n_drives; |
|||
o.done = 0; |
|||
add_worker(NULL, (WorkerFunc) scan_worker_func, &o); |
|||
} else if (workers->u.scan.done) { |
|||
/* its done */ |
|||
ret = workers->u.scan.done; |
|||
remove_worker(workers->thread); |
|||
assert(workers == NULL); |
|||
} else { |
|||
/* still going */ |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
static void *erase_worker_func(struct w_list *w) |
|||
{ |
|||
burn_disc_erase_sync(w->u.erase.drive, w->u.erase.fast); |
|||
remove_worker(pthread_self()); |
|||
return NULL; |
|||
} |
|||
|
|||
void burn_disc_erase(struct burn_drive *drive, int fast) |
|||
{ |
|||
struct erase_opts o; |
|||
|
|||
assert(drive); |
|||
assert(!SCAN_GOING()); |
|||
assert(!find_worker(drive)); |
|||
|
|||
o.drive = drive; |
|||
o.fast = fast; |
|||
add_worker(drive, (WorkerFunc) erase_worker_func, &o); |
|||
} |
|||
|
|||
static void *write_disc_worker_func(struct w_list *w) |
|||
{ |
|||
burn_disc_write_sync(w->u.write.opts, w->u.write.disc); |
|||
|
|||
/* the options are refcounted, free out ref count which we added below
|
|||
*/ |
|||
burn_write_opts_free(w->u.write.opts); |
|||
|
|||
remove_worker(pthread_self()); |
|||
return NULL; |
|||
} |
|||
|
|||
void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc) |
|||
{ |
|||
struct write_opts o; |
|||
|
|||
assert(!SCAN_GOING()); |
|||
assert(!find_worker(opts->drive)); |
|||
o.drive = opts->drive; |
|||
o.opts = opts; |
|||
o.disc = disc; |
|||
|
|||
opts->refcount++; |
|||
|
|||
add_worker(opts->drive, (WorkerFunc) write_disc_worker_func, &o); |
|||
} |
|||
|
|||
void burn_async_join_all(void) |
|||
{ |
|||
void *ret; |
|||
|
|||
while (workers) |
|||
pthread_join(workers->thread, &ret); |
|||
} |
|||
@ -0,0 +1,8 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#ifndef BURN__ASYNC_H |
|||
#define BURN__ASYNC_H |
|||
|
|||
void burn_async_join_all(void); |
|||
struct burn_write_opts; |
|||
#endif /* BURN__ASYNC_H */ |
|||
@ -0,0 +1,122 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#include "crc.h" |
|||
|
|||
static unsigned short ccitt_table[256] = { |
|||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, |
|||
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, |
|||
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, |
|||
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, |
|||
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, |
|||
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, |
|||
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, |
|||
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, |
|||
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, |
|||
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, |
|||
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, |
|||
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, |
|||
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, |
|||
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, |
|||
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, |
|||
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, |
|||
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, |
|||
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, |
|||
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, |
|||
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, |
|||
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, |
|||
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, |
|||
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, |
|||
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, |
|||
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, |
|||
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, |
|||
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, |
|||
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, |
|||
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, |
|||
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, |
|||
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, |
|||
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 |
|||
}; |
|||
|
|||
unsigned long crc32_table[256] = { |
|||
0x00000000L, 0x90910101L, 0x91210201L, 0x01B00300L, |
|||
0x92410401L, 0x02D00500L, 0x03600600L, 0x93F10701L, |
|||
0x94810801L, 0x04100900L, 0x05A00A00L, 0x95310B01L, |
|||
0x06C00C00L, 0x96510D01L, 0x97E10E01L, 0x07700F00L, |
|||
0x99011001L, 0x09901100L, 0x08201200L, 0x98B11301L, |
|||
0x0B401400L, 0x9BD11501L, 0x9A611601L, 0x0AF01700L, |
|||
0x0D801800L, 0x9D111901L, 0x9CA11A01L, 0x0C301B00L, |
|||
0x9FC11C01L, 0x0F501D00L, 0x0EE01E00L, 0x9E711F01L, |
|||
0x82012001L, 0x12902100L, 0x13202200L, 0x83B12301L, |
|||
0x10402400L, 0x80D12501L, 0x81612601L, 0x11F02700L, |
|||
0x16802800L, 0x86112901L, 0x87A12A01L, 0x17302B00L, |
|||
0x84C12C01L, 0x14502D00L, 0x15E02E00L, 0x85712F01L, |
|||
0x1B003000L, 0x8B913101L, 0x8A213201L, 0x1AB03300L, |
|||
0x89413401L, 0x19D03500L, 0x18603600L, 0x88F13701L, |
|||
0x8F813801L, 0x1F103900L, 0x1EA03A00L, 0x8E313B01L, |
|||
0x1DC03C00L, 0x8D513D01L, 0x8CE13E01L, 0x1C703F00L, |
|||
0xB4014001L, 0x24904100L, 0x25204200L, 0xB5B14301L, |
|||
0x26404400L, 0xB6D14501L, 0xB7614601L, 0x27F04700L, |
|||
0x20804800L, 0xB0114901L, 0xB1A14A01L, 0x21304B00L, |
|||
0xB2C14C01L, 0x22504D00L, 0x23E04E00L, 0xB3714F01L, |
|||
0x2D005000L, 0xBD915101L, 0xBC215201L, 0x2CB05300L, |
|||
0xBF415401L, 0x2FD05500L, 0x2E605600L, 0xBEF15701L, |
|||
0xB9815801L, 0x29105900L, 0x28A05A00L, 0xB8315B01L, |
|||
0x2BC05C00L, 0xBB515D01L, 0xBAE15E01L, 0x2A705F00L, |
|||
0x36006000L, 0xA6916101L, 0xA7216201L, 0x37B06300L, |
|||
0xA4416401L, 0x34D06500L, 0x35606600L, 0xA5F16701L, |
|||
0xA2816801L, 0x32106900L, 0x33A06A00L, 0xA3316B01L, |
|||
0x30C06C00L, 0xA0516D01L, 0xA1E16E01L, 0x31706F00L, |
|||
0xAF017001L, 0x3F907100L, 0x3E207200L, 0xAEB17301L, |
|||
0x3D407400L, 0xADD17501L, 0xAC617601L, 0x3CF07700L, |
|||
0x3B807800L, 0xAB117901L, 0xAAA17A01L, 0x3A307B00L, |
|||
0xA9C17C01L, 0x39507D00L, 0x38E07E00L, 0xA8717F01L, |
|||
0xD8018001L, 0x48908100L, 0x49208200L, 0xD9B18301L, |
|||
0x4A408400L, 0xDAD18501L, 0xDB618601L, 0x4BF08700L, |
|||
0x4C808800L, 0xDC118901L, 0xDDA18A01L, 0x4D308B00L, |
|||
0xDEC18C01L, 0x4E508D00L, 0x4FE08E00L, 0xDF718F01L, |
|||
0x41009000L, 0xD1919101L, 0xD0219201L, 0x40B09300L, |
|||
0xD3419401L, 0x43D09500L, 0x42609600L, 0xD2F19701L, |
|||
0xD5819801L, 0x45109900L, 0x44A09A00L, 0xD4319B01L, |
|||
0x47C09C00L, 0xD7519D01L, 0xD6E19E01L, 0x46709F00L, |
|||
0x5A00A000L, 0xCA91A101L, 0xCB21A201L, 0x5BB0A300L, |
|||
0xC841A401L, 0x58D0A500L, 0x5960A600L, 0xC9F1A701L, |
|||
0xCE81A801L, 0x5E10A900L, 0x5FA0AA00L, 0xCF31AB01L, |
|||
0x5CC0AC00L, 0xCC51AD01L, 0xCDE1AE01L, 0x5D70AF00L, |
|||
0xC301B001L, 0x5390B100L, 0x5220B200L, 0xC2B1B301L, |
|||
0x5140B400L, 0xC1D1B501L, 0xC061B601L, 0x50F0B700L, |
|||
0x5780B800L, 0xC711B901L, 0xC6A1BA01L, 0x5630BB00L, |
|||
0xC5C1BC01L, 0x5550BD00L, 0x54E0BE00L, 0xC471BF01L, |
|||
0x6C00C000L, 0xFC91C101L, 0xFD21C201L, 0x6DB0C300L, |
|||
0xFE41C401L, 0x6ED0C500L, 0x6F60C600L, 0xFFF1C701L, |
|||
0xF881C801L, 0x6810C900L, 0x69A0CA00L, 0xF931CB01L, |
|||
0x6AC0CC00L, 0xFA51CD01L, 0xFBE1CE01L, 0x6B70CF00L, |
|||
0xF501D001L, 0x6590D100L, 0x6420D200L, 0xF4B1D301L, |
|||
0x6740D400L, 0xF7D1D501L, 0xF661D601L, 0x66F0D700L, |
|||
0x6180D800L, 0xF111D901L, 0xF0A1DA01L, 0x6030DB00L, |
|||
0xF3C1DC01L, 0x6350DD00L, 0x62E0DE00L, 0xF271DF01L, |
|||
0xEE01E001L, 0x7E90E100L, 0x7F20E200L, 0xEFB1E301L, |
|||
0x7C40E400L, 0xECD1E501L, 0xED61E601L, 0x7DF0E700L, |
|||
0x7A80E800L, 0xEA11E901L, 0xEBA1EA01L, 0x7B30EB00L, |
|||
0xE8C1EC01L, 0x7850ED00L, 0x79E0EE00L, 0xE971EF01L, |
|||
0x7700F000L, 0xE791F101L, 0xE621F201L, 0x76B0F300L, |
|||
0xE541F401L, 0x75D0F500L, 0x7460F600L, 0xE4F1F701L, |
|||
0xE381F801L, 0x7310F900L, 0x72A0FA00L, 0xE231FB01L, |
|||
0x71C0FC00L, 0xE151FD01L, 0xE0E1FE01L, 0x7070FF00L |
|||
}; |
|||
|
|||
unsigned short crc_ccitt(unsigned char *q, int len) |
|||
{ |
|||
unsigned short crc = 0; |
|||
|
|||
while (len-- > 0) |
|||
crc = ccitt_table[(crc >> 8 ^ *q++) & 0xff] ^ (crc << 8); |
|||
return ~crc; |
|||
} |
|||
unsigned int crc_32(unsigned char *data, int len) |
|||
{ |
|||
unsigned int crc = 0; |
|||
|
|||
while (len-- > 0) |
|||
crc = crc32_table[(crc ^ *data++) & 0xffL] ^ (crc >> 8); |
|||
return crc; |
|||
} |
|||
@ -0,0 +1,9 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#ifndef BURN__CRC_H |
|||
#define BURN__CRC_H |
|||
|
|||
unsigned short crc_ccitt(unsigned char *, int len); |
|||
unsigned int crc_32(unsigned char *, int len); |
|||
|
|||
#endif /* BURN__CRC_H */ |
|||
@ -0,0 +1,35 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#ifdef WIN32 |
|||
#include <windows.h> |
|||
#endif |
|||
|
|||
#include <stdarg.h> |
|||
#include <stdio.h> |
|||
#include "libburn.h" |
|||
#include "debug.h" |
|||
|
|||
static int burn_verbosity = 0; |
|||
|
|||
void burn_set_verbosity(int v) |
|||
{ |
|||
burn_verbosity = v; |
|||
} |
|||
|
|||
void burn_print(int level, const char *a, ...) |
|||
{ |
|||
#ifdef WIN32 |
|||
char debug_string_data[256]; |
|||
#endif |
|||
va_list vl; |
|||
|
|||
if (level <= burn_verbosity) { |
|||
va_start(vl, a); |
|||
#ifdef WIN32 |
|||
vsprintf(debug_string_data, a, vl); |
|||
OutputDebugString(debug_string_data); |
|||
#else |
|||
vfprintf(stderr, a, vl); |
|||
#endif |
|||
} |
|||
} |
|||
@ -0,0 +1,8 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#ifndef BURN__DEBUG_H |
|||
#define BURN__DEBUG_H |
|||
|
|||
void burn_print(int level, const char *a, ...); |
|||
|
|||
#endif /* BURN__DEBUG_H */ |
|||
@ -0,0 +1,369 @@ |
|||
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|||
|
|||
#include <malloc.h> |
|||
#include <unistd.h> |
|||
#include <signal.h> |
|||
#include <assert.h> |
|||
#include <stdio.h> |
|||
#include <string.h> |
|||
#include <ctype.h> |
|||
#include <pthread.h> |
|||
#include "libburn.h" |
|||
#include "drive.h" |
|||
#include "transport.h" |
|||
#include "message.h" |
|||
#include "debug.h" |
|||
#include "init.h" |
|||
#include "toc.h" |
|||
#include "util.h" |
|||
#include "sg.h" |
|||
#include "structure.h" |
|||
|
|||
static struct burn_drive drive_array[255]; |
|||
static int drivetop = -1; |
|||
|
|||
void burn_drive_free(void) |
|||
{ |
|||
int i; |
|||
struct burn_drive *d; |
|||
|
|||
for (i = 0; i < drivetop + 1; i++) { |
|||
d = &drive_array[i]; |
|||
free((void *)d->idata); |
|||
free((void *)d->mdata); |
|||
free((void *)d->toc_entry); |
|||
free(d->devname); |
|||
} |
|||
drivetop = -1; |
|||
memset(drive_array, 0, sizeof(drive_array)); |
|||
} |
|||
|
|||
/*
|
|||
void drive_read_lead_in(int dnum) |
|||
{ |
|||
mmc_read_lead_in(&drive_array[dnum], get_4k()); |
|||
} |
|||
*/ |
|||
unsigned int burn_drive_count(void) |
|||
{ |
|||
return drivetop + 1; |
|||
} |
|||
|
|||
int burn_drive_grab(struct burn_drive *d, int le) |
|||
{ |
|||
int errcode; |
|||
|
|||
if (!d->released) { |
|||
burn_print(1, "can't grab - already grabbed\n"); |
|||
return 0; |
|||
} |
|||
errcode = d->grab(d); |
|||
|
|||
if (errcode == 0) { |
|||
burn_print(1, "low level drive grab failed\n"); |
|||
return 0; |
|||
} |
|||
d->busy = BURN_DRIVE_GRABBING; |
|||
|
|||
if (le) |
|||
d->load(d); |
|||
|
|||
d->lock(d); |
|||
d->status = BURN_DISC_BLANK; |
|||
if (d->mdata->cdr_write || d->mdata->cdrw_write || |
|||
d->mdata->dvdr_write || d->mdata->dvdram_write) { |
|||
d->read_disc_info(d); |
|||
} else |
|||
d->read_toc(d); |
|||
d->busy = BURN_DRIVE_IDLE; |
|||
return 1; |
|||
} |
|||
|
|||
struct burn_drive *burn_drive_register(struct burn_drive *d) |
|||
{ |
|||
d->block_types[0] = 0; |
|||
d->block_types[1] = 0; |
|||
d->block_types[2] = 0; |
|||
d->block_types[3] = 0; |
|||
d->toc_temp = 0; |
|||
d->nwa = 0; |
|||
d->alba = 0; |
|||
d->rlba = 0; |
|||
d->cancel = 0; |
|||
d->busy = BURN_DRIVE_IDLE; |
|||
d->toc_entries = 0; |
|||
d->toc_entry = NULL; |
|||
d->disc = NULL; |
|||
d->erasable = 0; |
|||
memcpy(&drive_array[drivetop + 1], d, sizeof(struct burn_drive)); |
|||
pthread_mutex_init(&drive_array[drivetop + 1].access_lock, NULL); |
|||
return &drive_array[++drivetop]; |
|||
} |
|||
|
|||
void burn_drive_release(struct burn_drive *d, int le) |
|||
{ |
|||
if (d->released) |
|||
burn_print(1, "second release on drive!\n"); |
|||
assert(!d->busy); |
|||
if (le) |
|||
d->eject(d); |
|||
d->unlock(d); |
|||
|
|||
d->release(d); |
|||
|
|||
d->status = BURN_DISC_UNREADY; |
|||
d->released = 1; |
|||
if (d->toc_entry) |
|||
free(d->toc_entry); |
|||
d->toc_entry = NULL; |
|||
d->toc_entries = 0; |
|||
if (d->disc != NULL) { |
|||
burn_disc_free(d->disc); |
|||
d->disc = NULL; |
|||
} |
|||
} |
|||
|
|||
void burn_wait_all(void) |
|||
{ |
|||
unsigned int i; |
|||
int finished = 0; |
|||
struct burn_drive *d; |
|||
|
|||
while (!finished) { |
|||
finished = 1; |
|||
d = drive_array; |
|||
for (i = burn_drive_count(); i > 0; --i, ++d) { |
|||
assert(d->released); |
|||
} |
|||
if (!finished) |
|||
sleep(1); |
|||
} |
|||
} |
|||
|
|||
void burn_disc_erase_sync(struct burn_drive *d, int fast) |
|||
{ |
|||
burn_message_clear_queue(); |
|||
|
|||
burn_print(1, "erasing drive %s %s\n", d->idata->vendor, |
|||
d->idata->product); |
|||
|
|||
if (d->status != BURN_DISC_FULL) |
|||
return; |
|||
d->cancel = 0; |
|||
d->busy = BURN_DRIVE_ERASING; |
|||
d->erase(d, fast); |
|||
/* reset the progress */ |
|||
d->progress.session = 0; |
|||
d->progress.sessions = 1; |
|||
d->progress.track = 0; |
|||
d->progress.tracks = 1; |
|||
d->progress.index = 0; |
|||
d->progress.indices = 1; |
|||
d->progress.start_sector = 0; |
|||
d->progress.sectors = 0x10000; |
|||
d->progress.sector = 0; |
|||
/* read the initial 0 stage */ |
|||
while (!d->test_unit_ready(d) && d->get_erase_progress(d) == 0) |
|||
sleep(1); |
|||
while (!d->test_unit_ready(d) && |
|||
(d->progress.sector = d->get_erase_progress(d)) > 0) |
|||
sleep(1); |
|||
d->progress.sector = 0x10000; |
|||
d->busy = BURN_DRIVE_IDLE; |
|||
} |
|||
|
|||
enum burn_disc_status burn_disc_get_status(struct burn_drive *d) |
|||
{ |
|||
assert(!d->released); |
|||
return d->status; |
|||
} |
|||
|
|||
int burn_disc_erasable(struct burn_drive *d) |
|||
{ |
|||
return d->erasable; |
|||
} |
|||
enum burn_drive_status burn_drive_get_status(struct burn_drive *d, |
|||
struct burn_progress *p) |
|||
{ |
|||
if (p) { |
|||
memcpy(p, &(d->progress), sizeof(struct burn_progress)); |
|||
/* TODO: add mutex */ |
|||
} |
|||
return d->busy; |
|||
} |
|||
|
|||
void burn_drive_cancel(struct burn_drive *d) |
|||
{ |
|||
pthread_mutex_lock(&d->access_lock); |
|||
d->cancel = 1; |
|||
pthread_mutex_unlock(&d->access_lock); |
|||
} |
|||
|
|||
int burn_drive_get_block_types(struct burn_drive *d, |
|||
enum burn_write_types write_type) |
|||
{ |
|||
burn_print(12, "write type: %d\n", write_type); |
|||
assert( /* (write_type >= BURN_WRITE_PACKET) && */ |
|||
(write_type <= BURN_WRITE_RAW)); |
|||
return d->block_types[write_type]; |
|||
} |
|||
|
|||
static void strip_spaces(char *str) |
|||
{ |
|||
char *tmp; |
|||
|
|||
tmp = str + strlen(str) - 1; |
|||
while (isspace(*tmp)) |
|||
*(tmp--) = '\0'; |
|||
|
|||
tmp = str; |
|||
while (*tmp) { |
|||
if (isspace(*tmp) && isspace(*(tmp + 1))) { |
|||
char *tmp2; |
|||
|
|||
for (tmp2 = tmp + 1; *tmp2; ++tmp2) |
|||
*(tmp2 - 1) = *tmp2; |
|||
*(tmp2 - 1) = '\0'; |
|||
} else |
|||
++tmp; |
|||
} |
|||
} |
|||
|
|||
static int drive_getcaps(struct burn_drive *d, struct burn_drive_info *out) |
|||
{ |
|||
struct scsi_inquiry_data *id; |
|||
|
|||
assert(d->idata); |
|||
assert(d->mdata); |
|||
if (!d->idata->valid || !d->mdata->valid) |
|||
return 0; |
|||
|
|||
id = (struct scsi_inquiry_data *)d->idata; |
|||
|
|||
memcpy(out->vendor, id->vendor, sizeof(id->vendor)); |
|||
strip_spaces(out->vendor); |
|||
memcpy(out->product, id->product, sizeof(id->product)); |
|||
strip_spaces(out->product); |
|||
memcpy(out->revision, id->revision, sizeof(id->revision)); |
|||
strip_spaces(out->revision); |
|||
strncpy(out->location, d->devname, 16); |
|||
out->location[16] = '\0'; |
|||
out->buffer_size = d->mdata->buffer_size; |
|||
out->read_dvdram = !!d->mdata->dvdram_read; |
|||
out->read_dvdr = !!d->mdata->dvdr_read; |
|||
out->read_dvdrom = !!d->mdata->dvdrom_read; |
|||
out->read_cdr = !!d->mdata->cdr_read; |
|||
out->read_cdrw = !!d->mdata->cdrw_read; |
|||
out->write_dvdram = !!d->mdata->dvdram_write; |
|||
out->write_dvdr = !!d->mdata->dvdr_write; |
|||
out->write_cdr = !!d->mdata->cdr_write; |
|||
out->write_cdrw = !!d->mdata->cdrw_write; |
|||
out->write_simulate = !!d->mdata->simulate; |
|||
out->c2_errors = !!d->mdata->c2_pointers; |
|||
out->drive = d; |
|||
/* update available block types for burners */ |
|||
if (out->write_dvdram || out->write_dvdr || |
|||
out->write_cdrw || out->write_cdr) |
|||
d->probe_write_modes(d); |
|||
out->tao_block_types = d->block_types[BURN_WRITE_TAO]; |
|||
out->sao_block_types = d->block_types[BURN_WRITE_SAO]; |
|||
out->raw_block_types = d->block_types[BURN_WRITE_RAW]; |
|||
out->packet_block_types = d->block_types[BURN_WRITE_PACKET]; |
|||
return 1; |
|||
} |
|||
|
|||
int burn_drive_scan_sync(struct burn_drive_info *drives[], |
|||
unsigned int *n_drives) |
|||
{ |
|||
/* state vars for the scan process */ |
|||
static int scanning = 0, scanned, found; |
|||
static unsigned num_scanned, count; |
|||
unsigned int i; |
|||
struct burn_drive *d; |
|||
|
|||
assert(burn_running); |
|||
|
|||
if (!scanning) { |
|||
scanning = 1; |
|||
/* make sure the drives aren't in use */ |
|||
burn_wait_all(); /* make sure the queue cleans up
|
|||
before checking for the released |
|||
state */ |
|||
|
|||
d = drive_array; |
|||
count = burn_drive_count(); |
|||
for (i = 0; i < count; ++i, ++d) |
|||
assert(d->released == 1); |
|||
|
|||
/* refresh the lib's drives */ |
|||
sg_enumerate(); |
|||
ata_enumerate(); |
|||
count = burn_drive_count(); |
|||
if (count) |
|||
*drives = |
|||
malloc(sizeof(struct | |||