From 3c90c638af2685ac489f20ca483e9f2c09d052d7 Mon Sep 17 00:00:00 2001 From: Anant Narayanan Date: Tue, 19 Sep 2006 19:31:20 +0000 Subject: [PATCH] Initial import of Python Bindings for libburn --- branches/python/libburn/burnmodule.c | 1943 ++++++++++++++++++++++++++ branches/python/libburn/setup.py | 19 + 2 files changed, 1962 insertions(+) create mode 100644 branches/python/libburn/burnmodule.c create mode 100644 branches/python/libburn/setup.py diff --git a/branches/python/libburn/burnmodule.c b/branches/python/libburn/burnmodule.c new file mode 100644 index 00000000..0154a1dc --- /dev/null +++ b/branches/python/libburn/burnmodule.c @@ -0,0 +1,1943 @@ +#include "Python.h" +#include "libburn/libburn.h" + +static PyObject *ErrorObject; + +/* ----------------------------------------------------- */ + +/* Declarations for objects of type toc_entry */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_toc_entryobject; + +static PyTypeObject B_toc_entrytype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type source */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_sourceobject; + +static PyTypeObject B_sourcetype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type drive_info */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_drive_infoobject; + +static PyTypeObject B_drive_infotype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type drive */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_driveobject; + +static PyTypeObject B_drivetype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type message */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_messageobject; + +static PyTypeObject B_messagetype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type progress */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_progressobject; + +static PyTypeObject B_progresstype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type write_options */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_write_optsobject; + +static PyTypeObject B_write_optstype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type read_options */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_read_optsobject; + +static PyTypeObject B_read_optstype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type disc */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_discobject; + +static PyTypeObject B_disctype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type session */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_sessionobject; + +static PyTypeObject B_sessiontype; + + + +/* ---------------------------------------------------------------- */ + +/* Declarations for objects of type track */ + +typedef struct { + PyObject_HEAD + /* XXXX Add your own stuff here */ +} b_trackobject; + +static PyTypeObject B_tracktype; + + + +/* ---------------------------------------------------------------- */ + +static struct PyMethodDef b_toc_entry_methods[] = { + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +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; + /* XXXX Add your own initializers here */ + 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) + 0, /*ob_size*/ + "toc_entry", /*tp_name*/ + sizeof(b_toc_entryobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)b_toc_entry_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_toc_entrytype__doc__ /* Documentation string */ +}; + +/* End of code for toc_entry objects */ +/* -------------------------------------------------------- */ + + +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_define_data__doc__[] = +"" +; + +static PyObject * +b_source_define_data(b_sourceobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_source_set_isrc__doc__[] = +"" +; + +static PyObject * +b_source_set_isrc(b_sourceobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_source_clear_isrc__doc__[] = +"" +; + +static PyObject * +b_source_clear_isrc(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__}, + {"define_data", (PyCFunction)b_source_define_data, METH_VARARGS, b_source_define_data__doc__}, + {"set_isrc", (PyCFunction)b_source_set_isrc, METH_VARARGS, b_source_set_isrc__doc__}, + {"clear_isrc", (PyCFunction)b_source_clear_isrc, METH_VARARGS, b_source_clear_isrc__doc__}, + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for source objects */ +/* -------------------------------------------------------- */ + + +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[] = { + {"free", (PyCFunction)b_drive_info_free, METH_VARARGS, b_drive_info_free__doc__}, + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +static PyObject * +b_drive_info_getattr(b_drive_infoobject *self, char *name) +{ + /* XXXX Add your own getattr code here */ + return Py_FindMethod(b_drive_info_methods, (PyObject *)self, name); +} + +static b_drive_infoobject * +newb_drive_infoobject() +{ + b_drive_infoobject *self; + + self = PyObject_NEW(b_drive_infoobject, &B_drive_infotype); + if (self == NULL) + return NULL; + /* XXXX Add your own initializers here */ + 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) + 0, /*ob_size*/ + "drive_info", /*tp_name*/ + sizeof(b_drive_infoobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)b_drive_info_dealloc, /*tp_dealloc*/ + (printfunc)0, /*tp_print*/ + (getattrfunc)b_drive_info_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_drive_infotype__doc__ /* Documentation string */ +}; + +/* End of code for drive_info objects */ +/* -------------------------------------------------------- */ + + +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_disc_get_status(b_driveobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_drive_erasable__doc__[] = +"" +; + +static PyObject * +b_drive_erasable(b_driveobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_drive_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_disc_erase__doc__[] = +"" +; + +static PyObject * +b_drive_disc_erase(b_driveobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_drive_disc_read__doc__[] = +"" +; + +static PyObject * +b_drive_disc_read(b_driveobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + + +static char b_drive_drive_cancel__doc__[] = +"" +; + +static PyObject * +b_drive_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__}, + {"disc_get_status", (PyCFunction)b_drive_disc_get_status, METH_VARARGS, b_drive_disc_get_status__doc__}, + {"erasable", (PyCFunction)b_drive_erasable, METH_VARARGS, b_drive_erasable__doc__}, + {"get_status", (PyCFunction)b_drive_get_status, METH_VARARGS, b_drive_get_status__doc__}, + {"disc_erase", (PyCFunction)b_drive_disc_erase, METH_VARARGS, b_drive_disc_erase__doc__}, + {"disc_read", (PyCFunction)b_drive_disc_read, METH_VARARGS, b_drive_disc_read__doc__}, + {"drive_cancel", (PyCFunction)b_drive_drive_cancel, METH_VARARGS, b_drive_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} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for drive objects */ +/* -------------------------------------------------------- */ + + +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} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for message objects */ +/* -------------------------------------------------------- */ + + +static struct PyMethodDef b_progress_methods[] = { + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for progress objects */ +/* -------------------------------------------------------- */ + + +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_mediacatalogset_mediacatalaog__doc__[] = +"" +; + +static PyObject * +b_write_opts_set_has_mediacatalogset_mediacatalaog(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_mediacatalogset_mediacatalaog", (PyCFunction)b_write_opts_set_has_mediacatalogset_mediacatalaog, METH_VARARGS, b_write_opts_set_has_mediacatalogset_mediacatalaog__doc__}, + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "write_options", /*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 of code for write_options objects */ +/* -------------------------------------------------------- */ + + +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} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "read_options", /*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 of code for read_options objects */ +/* -------------------------------------------------------- */ + + +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} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for disc objects */ +/* -------------------------------------------------------- */ + + +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_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_hidefirst", (PyCFunction)b_session_get_hidefirst, METH_VARARGS, b_session_get_hidefirst__doc__}, + + {NULL, NULL} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for session objects */ +/* -------------------------------------------------------- */ + + +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} /* sentinel */ +}; + +/* ---------- */ + + +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*/ + "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 of code for track objects */ +/* -------------------------------------------------------- */ + + +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) +{ + + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + +static char b_main_msf_to_sectors__doc__[] = +"" +; + +static PyObject * +b_main_msf_to_sectors(PyObject *self /* Not used */, PyObject *args) +{ + + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + +static char b_main_sectors_to_msf__doc__[] = +"" +; + +static PyObject * +b_main_sectors_to_msf(PyObject *self /* Not used */, PyObject *args) +{ + + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + +static char b_main_msf_to_lba__doc__[] = +"" +; + +static PyObject * +b_main_msf_to_lba(PyObject *self /* Not used */, PyObject *args) +{ + + if (!PyArg_ParseTuple(args, "")) + return NULL; + Py_INCREF(Py_None); + return Py_None; +} + +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) +{ + PyObject *version; + int maj, min, mic; + burn_version(&maj, &min, &mic); + + version = PyTuple_Pack(3, PyInt_FromLong(maj), + PyInt_FromLong(min), + PyInt_FromLong(mic)); + return version; +} + +/* 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} /* sentinel */ +}; + + +/* 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 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"); +} + diff --git a/branches/python/libburn/setup.py b/branches/python/libburn/setup.py new file mode 100644 index 00000000..cd551303 --- /dev/null +++ b/branches/python/libburn/setup.py @@ -0,0 +1,19 @@ +from distutils.core import setup, Extension + +module = Extension('burn', + define_macros = [('MAJOR_VERSION', '0'), + ('MINOR_VERSION', '1')], + include_dirs = ['/usr/local/include'], + libraries = ['burn', 'pthread'], + sources = ['burnmodule.c']) + +setup (name = 'burn', + version = '0.1', + description = 'Python Bindings for libburn', + author = 'Anant Narayanan', + author_email = 'anant@kix.in', + url = 'http://libburn.pykix.org/', + long_description = ''' + Really stupid bindings for libburn-SVN + ''', + ext_modules = [module])