1709 lines
44 KiB
C
1709 lines
44 KiB
C
#include "Python.h"
|
|
#include "libburn/libburn.h"
|
|
|
|
static PyObject *ErrorObject;
|
|
|
|
|
|
/* Declarations for objects of type toc_entry */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_toc_entry *toc;
|
|
} b_toc_entryobject;
|
|
|
|
static PyTypeObject B_toc_entrytype;
|
|
|
|
|
|
/* Declarations for objects of type source */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_source *source;
|
|
} b_sourceobject;
|
|
|
|
static PyTypeObject B_sourcetype;
|
|
|
|
|
|
/* Declarations for objects of type drive_info */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_drive_info *info;
|
|
} b_drive_infoobject;
|
|
|
|
static PyTypeObject B_drive_infotype;
|
|
|
|
|
|
/* Declarations for objects of type message */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_message *message;
|
|
} b_messageobject;
|
|
|
|
static PyTypeObject B_messagetype;
|
|
|
|
|
|
/* Declarations for objects of type progress */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_progress *progress;
|
|
} b_progressobject;
|
|
|
|
static PyTypeObject B_progresstype;
|
|
|
|
/* These are virtual types */
|
|
|
|
/* Declarations for objects of type drive */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_drive *drive;
|
|
} b_driveobject;
|
|
|
|
static PyTypeObject B_drivetype;
|
|
|
|
|
|
/* Declarations for objects of type disc */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_disc *disc;
|
|
} b_discobject;
|
|
|
|
static PyTypeObject B_disctype;
|
|
|
|
|
|
/* Declarations for objects of type session */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_session *session;
|
|
} b_sessionobject;
|
|
|
|
static PyTypeObject B_sessiontype;
|
|
|
|
|
|
/* Declarations for objects of type track */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_track *track;
|
|
} b_trackobject;
|
|
|
|
static PyTypeObject B_tracktype;
|
|
|
|
|
|
/* Declarations for objects of type write_options */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_write_opts *options;
|
|
} b_write_optsobject;
|
|
|
|
static PyTypeObject B_write_optstype;
|
|
|
|
|
|
/* Declarations for objects of type read_options */
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
struct burn_read_opts *options;
|
|
} b_read_optsobject;
|
|
|
|
static PyTypeObject B_read_optstype;
|
|
|
|
|
|
/* BEGIN burn_toc_entry */
|
|
static struct PyMethodDef b_toc_entry_methods[] = {
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static b_toc_entryobject *
|
|
newb_toc_entryobject()
|
|
{
|
|
b_toc_entryobject *self;
|
|
|
|
self = PyObject_NEW(b_toc_entryobject, &B_toc_entrytype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_toc_entry_dealloc(b_toc_entryobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_toc_entrytype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_toc_entrytype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
.tp_name = "burn.toc_entry",
|
|
.tp_basicsize = sizeof(b_toc_entryobject),
|
|
.tp_dealloc = (destructor)b_toc_entry_dealloc,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT,
|
|
.tp_doc = B_toc_entrytype__doc__,
|
|
};
|
|
/* END burn_toc_entry */
|
|
|
|
|
|
/* BEGIN burn_source */
|
|
static char b_source_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_source_free(b_sourceobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_source_file_new__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_source_file_new(b_sourceobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_source_fd_new__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_source_fd_new(b_sourceobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_source_methods[] = {
|
|
{"free", (PyCFunction)b_source_free, METH_VARARGS, b_source_free__doc__},
|
|
{"file_new", (PyCFunction)b_source_file_new, METH_VARARGS, b_source_file_new__doc__},
|
|
{"fd_new", (PyCFunction)b_source_fd_new, METH_VARARGS, b_source_fd_new__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_source_getattr(b_sourceobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_source_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_sourceobject *
|
|
newb_sourceobject()
|
|
{
|
|
b_sourceobject *self;
|
|
|
|
self = PyObject_NEW(b_sourceobject, &B_sourcetype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_source_dealloc(b_sourceobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_sourcetype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_sourcetype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.source", /*tp_name*/
|
|
sizeof(b_sourceobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_source_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_source_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_sourcetype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_source */
|
|
|
|
|
|
/* BEGIN burn_drive_info */
|
|
static char b_drive_info_forget__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_info_forget(b_drive_infoobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_info_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_info_free(b_drive_infoobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_drive_info_methods[] = {
|
|
{"forget", (PyCFunction)b_drive_info_forget, METH_VARARGS, b_drive_info_forget__doc__},
|
|
{"free", (PyCFunction)b_drive_info_free, METH_VARARGS, b_drive_info_free__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_drive_info_getattr(b_drive_infoobject *self, char *name)
|
|
{
|
|
if (!strcmp (name, "vendor"))
|
|
return PyString_FromString(self->info->vendor);
|
|
else if (!strcmp (name, "product"))
|
|
return PyString_FromString(self->info->product);
|
|
else if (!strcmp (name, "revision"))
|
|
return PyString_FromString(self->info->revision);
|
|
else if (!strcmp (name, "location"))
|
|
return PyString_FromString(self->info->location);
|
|
else if (!strcmp (name, "buffer_size"))
|
|
return PyInt_FromLong(self->info->buffer_size);
|
|
}
|
|
|
|
static b_drive_infoobject *
|
|
newb_drive_infoobject(struct burn_drive_info *obj)
|
|
{
|
|
b_drive_infoobject *self;
|
|
|
|
self = PyObject_NEW(b_drive_infoobject, &B_drive_infotype);
|
|
self->info = obj;
|
|
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_drive_info_dealloc(b_drive_infoobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_drive_infotype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_drive_infotype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
.tp_name = "burn.drive_info",
|
|
.tp_basicsize = sizeof(b_drive_infoobject),
|
|
.tp_dealloc = (destructor)b_drive_info_dealloc,
|
|
.tp_getattr = (getattrfunc)b_drive_info_getattr,
|
|
.tp_methods = b_drive_info_methods,
|
|
.tp_new = PyType_GenericNew,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_BASETYPE,
|
|
.tp_doc = B_drive_infotype__doc__,
|
|
};
|
|
|
|
/* END burn_drive_info */
|
|
|
|
|
|
/* BEGIN burn_drive */
|
|
static char b_drive_grab__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_grab(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_release__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_release(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_disc_get_status__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_get_status(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_cancel__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_cancel(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_get_disc__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_get_disc(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_set_speed__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_set_speed(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_get_write_speed__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_get_write_speed(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_drive_get_read_speed__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_drive_get_read_speed(b_driveobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_drive_methods[] = {
|
|
{"grab", (PyCFunction)b_drive_grab, METH_VARARGS, b_drive_grab__doc__},
|
|
{"release", (PyCFunction)b_drive_release, METH_VARARGS, b_drive_release__doc__},
|
|
{"get_status", (PyCFunction)b_drive_get_status, METH_VARARGS, b_drive_disc_get_status__doc__},
|
|
{"cancel", (PyCFunction)b_drive_cancel, METH_VARARGS, b_drive_cancel__doc__},
|
|
{"get_disc", (PyCFunction)b_drive_get_disc, METH_VARARGS, b_drive_get_disc__doc__},
|
|
{"set_speed", (PyCFunction)b_drive_set_speed, METH_VARARGS, b_drive_set_speed__doc__},
|
|
{"get_write_speed", (PyCFunction)b_drive_get_write_speed, METH_VARARGS, b_drive_get_write_speed__doc__},
|
|
{"get_read_speed", (PyCFunction)b_drive_get_read_speed, METH_VARARGS, b_drive_get_read_speed__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_drive_getattr(b_driveobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_drive_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_driveobject *
|
|
newb_driveobject()
|
|
{
|
|
b_driveobject *self;
|
|
|
|
self = PyObject_NEW(b_driveobject, &B_drivetype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_drive_dealloc(b_driveobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_drivetype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_drivetype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.drive", /*tp_name*/
|
|
sizeof(b_driveobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_drive_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_drive_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_drivetype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_drive */
|
|
|
|
|
|
/* BEGIN burn_message */
|
|
static char b_message_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_message_free(b_messageobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_message_methods[] = {
|
|
{"free", (PyCFunction)b_message_free, METH_VARARGS, b_message_free__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_message_getattr(b_messageobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_message_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_messageobject *
|
|
newb_messageobject()
|
|
{
|
|
b_messageobject *self;
|
|
|
|
self = PyObject_NEW(b_messageobject, &B_messagetype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_message_dealloc(b_messageobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_messagetype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_messagetype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.message", /*tp_name*/
|
|
sizeof(b_messageobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_message_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_message_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_messagetype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_message */
|
|
|
|
|
|
/* BEGIN burn_progress */
|
|
static struct PyMethodDef b_progress_methods[] = {
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static b_progressobject *
|
|
newb_progressobject()
|
|
{
|
|
b_progressobject *self;
|
|
|
|
self = PyObject_NEW(b_progressobject, &B_progresstype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_progress_dealloc(b_progressobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_progresstype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_progresstype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.progress", /*tp_name*/
|
|
sizeof(b_progressobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_progress_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)0, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_progresstype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_progress */
|
|
|
|
|
|
/* BEGIN burn_write_opts */
|
|
static char b_write_opts_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_free(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char b_write_opts_set_write_type__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_write_type(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_toc_entries__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_toc_entries(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_format__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_format(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_simulate__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_simulate(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char b_write_opts_set_underrun_proof__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_underrun_proof(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_perform_opc__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_perform_opc(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_has_mediacatalog__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_has_mediacatalog(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_write_opts_set_mediacatalog__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_write_opts_set_mediacatalog(b_write_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_write_opts_methods[] = {
|
|
{"free", (PyCFunction)b_write_opts_free, METH_VARARGS, b_write_opts_free__doc__},
|
|
{"set_write_type", (PyCFunction)b_write_opts_set_write_type, METH_VARARGS, b_write_opts_set_write_type__doc__},
|
|
{"set_toc_entries", (PyCFunction)b_write_opts_set_toc_entries, METH_VARARGS, b_write_opts_set_toc_entries__doc__},
|
|
{"set_format", (PyCFunction)b_write_opts_set_format, METH_VARARGS, b_write_opts_set_format__doc__},
|
|
{"set_simulate", (PyCFunction)b_write_opts_set_simulate, METH_VARARGS, b_write_opts_set_simulate__doc__},
|
|
{"set_underrun_proof", (PyCFunction)b_write_opts_set_underrun_proof, METH_VARARGS, b_write_opts_set_underrun_proof__doc__},
|
|
{"set_perform_opc", (PyCFunction)b_write_opts_set_perform_opc, METH_VARARGS, b_write_opts_set_perform_opc__doc__},
|
|
{"set_has_mediacatalog", (PyCFunction)b_write_opts_set_has_mediacatalog, METH_VARARGS, b_write_opts_set_has_mediacatalog__doc__},
|
|
{"set_has_mediacatalog", (PyCFunction)b_write_opts_set_has_mediacatalog, METH_VARARGS, b_write_opts_set_has_mediacatalog__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_write_opts_getattr(b_write_optsobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_write_opts_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_write_optsobject *
|
|
newb_write_optsobject()
|
|
{
|
|
b_write_optsobject *self;
|
|
|
|
self = PyObject_NEW(b_write_optsobject, &B_write_optstype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_write_opts_dealloc(b_write_optsobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_write_optstype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_write_optstype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.write_opts", /*tp_name*/
|
|
sizeof(b_write_optsobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_write_opts_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_write_opts_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_write_optstype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_write_opts */
|
|
|
|
|
|
/* BEGIN burn_read_opts */
|
|
static char b_read_opts_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_free(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_set_raw__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_set_raw(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_set_c2errors__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_set_c2errors(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_read_subcodes_audio__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_read_subcodes_audio(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_read_subcodes_data__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_read_subcodes_data(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_set_hardware_error_recovery__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_set_hardware_error_recovery(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_report_recovered_errors__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_report_recovered_errors(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_transfer_damaged_blocks__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_transfer_damaged_blocks(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_read_opts_set_hardware_error_retries__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_read_opts_set_hardware_error_retries(b_read_optsobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_read_opts_methods[] = {
|
|
{"free", (PyCFunction)b_read_opts_free, METH_VARARGS, b_read_opts_free__doc__},
|
|
{"set_raw", (PyCFunction)b_read_opts_set_raw, METH_VARARGS, b_read_opts_set_raw__doc__},
|
|
{"set_c2errors", (PyCFunction)b_read_opts_set_c2errors, METH_VARARGS, b_read_opts_set_c2errors__doc__},
|
|
{"read_subcodes_audio", (PyCFunction)b_read_opts_read_subcodes_audio, METH_VARARGS, b_read_opts_read_subcodes_audio__doc__},
|
|
{"read_subcodes_data", (PyCFunction)b_read_opts_read_subcodes_data, METH_VARARGS, b_read_opts_read_subcodes_data__doc__},
|
|
{"set_hardware_error_recovery", (PyCFunction)b_read_opts_set_hardware_error_recovery, METH_VARARGS, b_read_opts_set_hardware_error_recovery__doc__},
|
|
{"report_recovered_errors", (PyCFunction)b_read_opts_report_recovered_errors, METH_VARARGS, b_read_opts_report_recovered_errors__doc__},
|
|
{"transfer_damaged_blocks", (PyCFunction)b_read_opts_transfer_damaged_blocks, METH_VARARGS, b_read_opts_transfer_damaged_blocks__doc__},
|
|
{"set_hardware_error_retries", (PyCFunction)b_read_opts_set_hardware_error_retries, METH_VARARGS, b_read_opts_set_hardware_error_retries__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_read_opts_getattr(b_read_optsobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_read_opts_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_read_optsobject *
|
|
newb_read_optsobject()
|
|
{
|
|
b_read_optsobject *self;
|
|
|
|
self = PyObject_NEW(b_read_optsobject, &B_read_optstype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_read_opts_dealloc(b_read_optsobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_read_optstype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_read_optstype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.read_opts", /*tp_name*/
|
|
sizeof(b_read_optsobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_read_opts_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_read_opts_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_read_optstype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_read_opts */
|
|
|
|
|
|
/* BEGIN burn_disc */
|
|
static char b_disc_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_free(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_disc_write__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_write(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_disc_add_session__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_add_session(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_disc_remove_session__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_remove_session(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_disc_get_sessions__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_get_sessions(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_disc_get_sectors__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_disc_get_sectors(b_discobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_disc_methods[] = {
|
|
{"free", (PyCFunction)b_disc_free, METH_VARARGS, b_disc_free__doc__},
|
|
{"write", (PyCFunction)b_disc_write, METH_VARARGS, b_disc_write__doc__},
|
|
{"add_session", (PyCFunction)b_disc_add_session, METH_VARARGS, b_disc_add_session__doc__},
|
|
{"remove_session", (PyCFunction)b_disc_remove_session, METH_VARARGS, b_disc_remove_session__doc__},
|
|
{"get_sessions", (PyCFunction)b_disc_get_sessions, METH_VARARGS, b_disc_get_sessions__doc__},
|
|
{"get_sectors", (PyCFunction)b_disc_get_sectors, METH_VARARGS, b_disc_get_sectors__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_disc_getattr(b_discobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_disc_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_discobject *
|
|
newb_discobject()
|
|
{
|
|
b_discobject *self;
|
|
|
|
self = PyObject_NEW(b_discobject, &B_disctype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_disc_dealloc(b_discobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_disctype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_disctype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.disc", /*tp_name*/
|
|
sizeof(b_discobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_disc_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_disc_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_disctype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_disc */
|
|
|
|
|
|
/* BEGIN burn_session */
|
|
static char b_session_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_free(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_add_track__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_add_track(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_remove_track__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_remove_track(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_hide_first_track__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_hide_first_track(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_get_leadout_entry__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_get_leadout_entry(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_get_tracks__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_get_tracks(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_get_sectors__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_get_sectors(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_session_get_hidefirst__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_session_get_hidefirst(b_sessionobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_session_methods[] = {
|
|
{"free", (PyCFunction)b_session_free, METH_VARARGS, b_session_free__doc__},
|
|
{"add_track", (PyCFunction)b_session_add_track, METH_VARARGS, b_session_add_track__doc__},
|
|
{"remove_track", (PyCFunction)b_session_remove_track, METH_VARARGS, b_session_remove_track__doc__},
|
|
{"hide_first_track", (PyCFunction)b_session_hide_first_track, METH_VARARGS, b_session_hide_first_track__doc__},
|
|
{"get_leadout_entry", (PyCFunction)b_session_get_leadout_entry, METH_VARARGS, b_session_get_leadout_entry__doc__},
|
|
{"get_tracks", (PyCFunction)b_session_get_tracks, METH_VARARGS, b_session_get_tracks__doc__},
|
|
{"get_sectors", (PyCFunction)b_session_get_sectors, METH_VARARGS, b_session_get_sectors__doc__},
|
|
{"get_hidefirst", (PyCFunction)b_session_get_hidefirst, METH_VARARGS, b_session_get_hidefirst__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_session_getattr(b_sessionobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_session_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_sessionobject *
|
|
newb_sessionobject()
|
|
{
|
|
b_sessionobject *self;
|
|
|
|
self = PyObject_NEW(b_sessionobject, &B_sessiontype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_session_dealloc(b_sessionobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_sessiontype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_sessiontype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.session", /*tp_name*/
|
|
sizeof(b_sessionobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_session_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_session_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_sessiontype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_session */
|
|
|
|
|
|
/* BEGIN burn_track */
|
|
static char b_track_free__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_free(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char b_track_define_data__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_define_data(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_track_set_isrc__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_set_isrc(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_track_clear_isrc__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_clear_isrc(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char b_track_set_source__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_set_source(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char b_track_get_sectors__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_get_sectors(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_track_get_entry__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_get_entry(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_track_get_mode__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_track_get_mode(b_trackobject *self, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static struct PyMethodDef b_track_methods[] = {
|
|
{"free", (PyCFunction)b_track_free, METH_VARARGS, b_track_free__doc__},
|
|
{"define_data", (PyCFunction)b_track_define_data, METH_VARARGS, b_track_define_data__doc__},
|
|
{"set_isrc", (PyCFunction)b_track_set_isrc, METH_VARARGS, b_track_set_isrc__doc__},
|
|
{"clear_isrc", (PyCFunction)b_track_clear_isrc, METH_VARARGS, b_track_clear_isrc__doc__},
|
|
{"set_source", (PyCFunction)b_track_set_source, METH_VARARGS, b_track_set_source__doc__},
|
|
{"get_sectors", (PyCFunction)b_track_get_sectors, METH_VARARGS, b_track_get_sectors__doc__},
|
|
{"get_entry", (PyCFunction)b_track_get_entry, METH_VARARGS, b_track_get_entry__doc__},
|
|
{"get_mode", (PyCFunction)b_track_get_mode, METH_VARARGS, b_track_get_mode__doc__},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static PyObject *
|
|
b_track_getattr(b_trackobject *self, char *name)
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(b_track_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static b_trackobject *
|
|
newb_trackobject()
|
|
{
|
|
b_trackobject *self;
|
|
|
|
self = PyObject_NEW(b_trackobject, &B_tracktype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
return self;
|
|
}
|
|
|
|
static void
|
|
b_track_dealloc(b_trackobject *self)
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static char B_tracktype__doc__[] =
|
|
""
|
|
;
|
|
static PyTypeObject B_tracktype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"burn.track", /*tp_name*/
|
|
sizeof(b_trackobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
|
|
/* methods */
|
|
(destructor)b_track_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)b_track_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
B_tracktype__doc__ /* Documentation string */
|
|
};
|
|
/* END burn_track */
|
|
|
|
|
|
/* Main burn Module */
|
|
static char b_main_init__doc__[] =
|
|
"Initializes the burn module. You _MUST_ call this before you start!"
|
|
;
|
|
static PyObject *
|
|
b_main_init(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
if (burn_initialize()) {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static char b_main_finish__doc__[] =
|
|
"Closes the burn module. You _MUST_ call this when you are done!"
|
|
;
|
|
static PyObject *
|
|
b_main_finish(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
burn_finish();
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_set_verbosity__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_set_verbosity(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_preset_device_open__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_preset_device_open(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_get_message__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_get_message(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_drive_add_whitelist__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_drive_add_whitelist(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_drive_clear_whitelist__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_drive_clear_whitelist(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char b_main_drive_scan__doc__[] =
|
|
""
|
|
;
|
|
static PyObject *
|
|
b_main_drive_scan(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
struct burn_drive_info *drives;
|
|
unsigned int n_drives;
|
|
int i;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
while (!burn_drive_scan(&drives, &n_drives));
|
|
|
|
if (!drives)
|
|
return NULL;
|
|
|
|
/*
|
|
PyObject *infos = PyList_New(n_drives);
|
|
for (i=0; i < n_drives; i++) {
|
|
struct burn_drive_info *current = &drives[i];
|
|
PyObject *obj = newb_drive_infoobject(current);
|
|
PyList_SetItem(infos, i, obj);
|
|
}
|
|
|
|
return infos;
|
|
*/
|
|
|
|
struct burn_drive_info curr = drives[0];
|
|
PyObject *obj = (PyObject *)newb_drive_infoobject(&curr);
|
|
Py_INCREF(obj);
|
|
return obj;
|
|
}
|
|
|
|
static char b_main_msf_to_sectors__doc__[] =
|
|
"Convert a Minute-Second-Frame (MSF) tuple value to its sector count"
|
|
;
|
|
static PyObject *
|
|
b_main_msf_to_sectors(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
int sectors, min, sec, frame;
|
|
|
|
if (!PyArg_ParseTuple(args, "(iii)", &min, &sec, &frame))
|
|
return NULL;
|
|
|
|
sectors = burn_msf_to_sectors(min, sec, frame);
|
|
|
|
return PyInt_FromLong(sectors);
|
|
}
|
|
|
|
static char b_main_sectors_to_msf__doc__[] =
|
|
"Convert a sector count to its Minute-Second-Frame (MSF) tuple value"
|
|
;
|
|
static PyObject *
|
|
b_main_sectors_to_msf(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
int sectors, min, sec, frame;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", §ors))
|
|
return NULL;
|
|
|
|
burn_sectors_to_msf(sectors, &min, &sec, &frame);
|
|
|
|
return PyTuple_Pack(3, PyInt_FromLong(min),
|
|
PyInt_FromLong(sec),
|
|
PyInt_FromLong(frame));
|
|
}
|
|
|
|
static char b_main_msf_to_lba__doc__[] =
|
|
"Convert a Minute-Second-Frame (MSF) tuple value to its corresponding LBA"
|
|
;
|
|
static PyObject *
|
|
b_main_msf_to_lba(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
int lba, min, sec, frame;
|
|
if (!PyArg_ParseTuple(args, "(iii)", &min, &sec, &frame))
|
|
return NULL;
|
|
|
|
lba = burn_msf_to_lba(min, sec, frame);
|
|
|
|
return PyInt_FromLong(lba);
|
|
}
|
|
|
|
static char b_main_version__doc__[] =
|
|
"Return a tuple containing the major, minor and micro versions of libburn"
|
|
;
|
|
static PyObject *
|
|
b_main_version(PyObject *self /* Not used */, PyObject *args)
|
|
{
|
|
int maj, min, mic;
|
|
burn_version(&maj, &min, &mic);
|
|
|
|
return PyTuple_Pack(3, PyInt_FromLong(maj),
|
|
PyInt_FromLong(min),
|
|
PyInt_FromLong(mic));
|
|
}
|
|
|
|
/* List of methods defined in the module */
|
|
static struct PyMethodDef b_main_methods[] = {
|
|
{"init", (PyCFunction)b_main_init, METH_VARARGS, b_main_init__doc__},
|
|
{"finish", (PyCFunction)b_main_finish, METH_VARARGS, b_main_finish__doc__},
|
|
{"set_verbosity", (PyCFunction)b_main_set_verbosity, METH_VARARGS, b_main_set_verbosity__doc__},
|
|
{"preset_device_open", (PyCFunction)b_main_preset_device_open, METH_VARARGS, b_main_preset_device_open__doc__},
|
|
{"get_message", (PyCFunction)b_main_get_message, METH_VARARGS, b_main_get_message__doc__},
|
|
{"drive_add_whitelist", (PyCFunction)b_main_drive_add_whitelist, METH_VARARGS, b_main_drive_add_whitelist__doc__},
|
|
{"drive_clear_whitelist", (PyCFunction)b_main_drive_clear_whitelist, METH_VARARGS, b_main_drive_clear_whitelist__doc__},
|
|
{"drive_scan", (PyCFunction)b_main_drive_scan, METH_VARARGS, b_main_drive_scan__doc__},
|
|
{"msf_to_sectors", (PyCFunction)b_main_msf_to_sectors, METH_VARARGS, b_main_msf_to_sectors__doc__},
|
|
{"sectors_to_msf", (PyCFunction)b_main_sectors_to_msf, METH_VARARGS, b_main_sectors_to_msf__doc__},
|
|
{"msf_to_lba", (PyCFunction)b_main_msf_to_lba, METH_VARARGS, b_main_msf_to_lba__doc__},
|
|
{"version", (PyCFunction)b_main_version, METH_VARARGS, b_main_version__doc__},
|
|
{NULL, (PyCFunction)NULL, 0, NULL}
|
|
};
|
|
|
|
|
|
/* Initialization function for the module (*must* be called initburn) */
|
|
static char burn_module_documentation[] =
|
|
""
|
|
;
|
|
void
|
|
initburn()
|
|
{
|
|
PyObject *m, *d;
|
|
|
|
/* Create the module and add the functions */
|
|
m = Py_InitModule4("burn", b_main_methods,
|
|
burn_module_documentation,
|
|
(PyObject*)NULL,PYTHON_API_VERSION);
|
|
|
|
/* Add objects */
|
|
PyModule_AddObject(m, "toc_entry", (PyObject *)&B_toc_entrytype);
|
|
PyModule_AddObject(m, "source", (PyObject *)&B_sourcetype);
|
|
|
|
if (PyType_Ready(&B_drive_infotype) < 0)
|
|
return;
|
|
Py_INCREF(&B_drive_infotype);
|
|
PyModule_AddObject(m, "drive_info", (PyObject *)&B_drive_infotype);
|
|
|
|
PyModule_AddObject(m, "drive", (PyObject *)&B_drivetype);
|
|
PyModule_AddObject(m, "message", (PyObject *)&B_messagetype);
|
|
PyModule_AddObject(m, "progress", (PyObject *)&B_progresstype);
|
|
PyModule_AddObject(m, "write_opts", (PyObject *)&B_write_optstype);
|
|
PyModule_AddObject(m, "read_opts", (PyObject *)&B_read_optstype);
|
|
PyModule_AddObject(m, "disc", (PyObject *)&B_disctype);
|
|
PyModule_AddObject(m, "session", (PyObject *)&B_sessiontype);
|
|
PyModule_AddObject(m, "track", (PyObject *)&B_tracktype);
|
|
|
|
/* Add some symbolic constants to the module */
|
|
d = PyModule_GetDict(m);
|
|
ErrorObject = PyString_FromString("burn.error");
|
|
PyDict_SetItemString(d, "error", ErrorObject);
|
|
|
|
/* XXXX Add constants here */
|
|
|
|
/* Check for errors */
|
|
if (PyErr_Occurred())
|
|
Py_FatalError("can't initialize module burn");
|
|
}
|
|
|