@ -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 burn_drive_info) * count); | |||
else | |||
*drives = NULL; | |||
*n_drives = scanned = found = num_scanned = 0; | |||
} | |||
for (i = 0; i < count; ++i) { | |||
if (scanned & (1 << i)) | |||
continue; /* already scanned the device */ | |||
while (!drive_getcaps(&drive_array[i], | |||
&(*drives)[num_scanned])) { | |||
sleep(1); | |||
} | |||
scanned |= 1 << i; | |||
found |= 1 << i; | |||
num_scanned++; | |||
(*n_drives)++; | |||
} | |||
if (num_scanned == count) { | |||
/* done scanning */ | |||
scanning = 0; | |||
return 1; | |||
} | |||
return 0; | |||
} | |||
void burn_drive_info_free(struct burn_drive_info *info) | |||
{ | |||
free(info); | |||
burn_drive_free(); | |||
} | |||
struct burn_disc *burn_drive_get_disc(struct burn_drive *d) | |||
{ | |||
d->disc->refcnt++; | |||
return d->disc; | |||
} | |||
void burn_drive_set_speed(struct burn_drive *d, int r, int w) | |||
{ | |||
d->set_speed(d, r, w); | |||
} | |||
int burn_msf_to_sectors(int m, int s, int f) | |||
{ | |||
return (m * 60 + s) * 75 + f; | |||
} | |||
void burn_sectors_to_msf(int sectors, int *m, int *s, int *f) | |||
{ | |||
*m = sectors / (60 * 75); | |||
*s = (sectors - *m * 60 * 75) / 75; | |||
*f = sectors - *m * 60 * 75 - *s * 75; | |||
} | |||
int burn_drive_get_read_speed(struct burn_drive *d) | |||
{ | |||
return d->mdata->max_read_speed; | |||
} | |||
int burn_drive_get_write_speed(struct burn_drive *d) | |||