PyObject *
_VGA_Init(void)
{
PyObject *mod, *dict;
mod = Py_InitModule4("vga", NULL,
NULL/*doc*/, (PyObject *)NULL,
PYTHON_API_VERSION);
dict = PyModule_GetDict(mod);
#define SETBUILTIN(NAME, OBJECT) \
if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
return NULL;
SETBUILTIN("framebuffer",
PyBuffer_FromReadWriteMemory((void *)0xa0000, 0x10000));
SETBUILTIN("textbuffer",
PyBuffer_FromReadWriteMemory((void *)0xb8000, 80*25*2));
SETBUILTIN("savebuffer",
PyBuffer_FromReadWriteMemory((void *)savebuffer, 80*25*2));
SETBUILTIN("splashscreen",
PyBuffer_FromMemory(bootscreen, 0x10000));
SETBUILTIN("font0",
PyBuffer_FromReadWriteMemory((void *)font0, 8192));
init_screen();
return mod;
}
static PyObject *
image_fate_buffer(PyObject *self, PyObject *args)
{
PyObject *pyim;
PyObject *pybuf;
int x=0,y=0;
if(!PyArg_ParseTuple(args,"O|ii",&pyim,&x,&y))
{
return NULL;
}
image *i = (image *)PyCObject_AsVoidPtr(pyim);
#ifdef DEBUG_CREATION
printf("%p : IM : BUF\n",i);
#endif
if(x < 0 || x >= i->Xres() || y < 0 || y >= i->Yres())
{
PyErr_SetString(PyExc_ValueError,"request for buffer outside image bounds");
return NULL;
}
int index = i->index_of_subpixel(x,y,0);
int last_index = i->index_of_sentinel_subpixel();
assert(index > -1 && index < last_index);
pybuf = PyBuffer_FromReadWriteMemory(
i->getFateBuffer()+index,
(last_index - index) * sizeof(fate_t));
Py_XINCREF(pybuf);
return pybuf;
}
static PyObject *PyRendererAgg_buffer_rgba(PyRendererAgg *self, PyObject *args, PyObject *kwds)
{
#if PY3K
return PyBytes_FromStringAndSize((const char *)self->x->pixBuffer,
self->x->get_width() * self->x->get_height() * 4);
#else
return PyBuffer_FromReadWriteMemory(self->x->pixBuffer,
self->x->get_width() * self->x->get_height() * 4);
#endif
}
PyObject *engine_buffer_setup(Evas_PyObject *o, PyObject *kwargs)
{
Evas_Engine_Info_Buffer *einfo;
int buflen, w, h;
PyObject *value, *buffer;
BENCH_START
evas_output_method_set(o->evas, evas_render_method_lookup("buffer"));
BENCH_END
einfo = (Evas_Engine_Info_Buffer *) evas_engine_info_get(o->evas);
if (!einfo) {
PyErr_Format(PyExc_SystemError, "Evas is not built with buffer engine support.");
return NULL;
}
einfo->info.func.new_update_region = NULL;
einfo->info.func.free_update_region = NULL;
einfo->info.use_color_key = 0;
einfo->info.alpha_threshold = 0;
// Class wrapper ensures these kwargs exist.
if (!PyArg_ParseTuple(PyDict_GetItemString(kwargs, "size"), "ii", &w, &h))
return 0;
einfo->info.depth_type = PyLong_AsLong(PyDict_GetItemString(kwargs, "depth"));
einfo->info.dest_buffer_row_bytes = PyLong_AsLong(PyDict_GetItemString(kwargs, "stride"));
einfo->info.dest_buffer = 0;
value = PyDict_GetItemString(kwargs, "buffer");
if (!value || value == Py_None) {
buffer = PyBuffer_New(einfo->info.dest_buffer_row_bytes * h);
if (PyObject_AsWriteBuffer(buffer, &einfo->info.dest_buffer, &buflen) == -1)
return 0;
} else {
if (PyNumber_Check(value)) {
einfo->info.dest_buffer = (void *) PyLong_AsLong(value);
buffer = PyBuffer_FromReadWriteMemory(einfo->info.dest_buffer,
einfo->info.dest_buffer_row_bytes * h);
} else {
if (PyObject_AsWriteBuffer(value, &einfo->info.dest_buffer, &buflen) == -1)
return 0;
if (buflen < einfo->info.dest_buffer_row_bytes * h) {
PyErr_SetString(PyExc_AttributeError, "Buffer not big enough");
return 0;
}
buffer = value;
Py_INCREF(buffer);
}
}
BENCH_START
evas_engine_info_set(o->evas, (Evas_Engine_Info *) einfo);
BENCH_END
return buffer;
}
static PyObject *
builtin_textbuffer(PyObject *self, PyObject *args)
{
static PyObject *tb = NULL;
if(!tb) {
tb = PyBuffer_FromReadWriteMemory((void *)0xb8000, 80*25*2);
}
Py_INCREF(tb);
return tb;
}
static int callback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
double streamTime, RtAudioStreamStatus status, void *data )
{
PyRtAudio* self = (PyRtAudio*) data;
if (status == RTAUDIO_OUTPUT_UNDERFLOW)
printf("underflow.\n");
if (self == NULL) return -1;
float* in = (float *) inputBuffer;
float* out = (float *) outputBuffer;
PyObject *py_callback_func = self->callback_func;
int retval = 0;
if (py_callback_func) {
PyGILState_STATE gstate = PyGILState_Ensure();
PyObject* iBuffer = PyBuffer_FromMemory(in, sizeof(float) * self->inputChannels * nBufferFrames);
PyObject* oBuffer = PyBuffer_FromReadWriteMemory(out, sizeof(float) * nBufferFrames);
PyObject *arglist = Py_BuildValue("(O,O)", oBuffer, iBuffer);
if (arglist == NULL) {
printf("error.\n");
PyErr_Print();
PyGILState_Release(gstate);
return 2;
}
// Calling the callback
PyObject *result = PyEval_CallObject(py_callback_func, arglist);
if (PyErr_Occurred() != NULL) {
PyErr_Print();
}
else if PyInt_Check(result) {
retval = PyInt_AsLong(result);
}
Py_DECREF(arglist);
Py_DECREF(oBuffer);
Py_DECREF(iBuffer);
Py_XDECREF(result);
PyGILState_Release(gstate);
}
return retval;
}
static PyObject *
metalmem_membuf(PyObject *self, PyObject *args)
{
unsigned addr;
Py_ssize_t len;
int writable = 0;
if (!PyArg_ParseTuple(args, "In|i", &addr, &len, &writable))
return NULL;
if (writable)
return PyBuffer_FromReadWriteMemory((void*)addr, len);
else
return PyBuffer_FromMemory((void*)addr, len);
}
static PyObject *
buf_bss(PyObject *self, PyObject *args)
{
PyObject *olen;
int len;
if(!PyArg_UnpackTuple(args, "bss", 1, 1, &olen))
return NULL;
if(!PyInt_CheckExact(olen))
return NULL;
len = PyInt_AS_LONG(olen);
return PyBuffer_FromReadWriteMemory(malloc(len), len);
}
bool exec( const void* in, size_t in_sz, void* out, size_t out_sz ){
if (!func){
//std::cerr << "Error state" << std::endl;
return false;
}
PyObject* args = PyTuple_New( 2 );
if (!args){
//PyErr_Print();
//std::cerr << "Error building args tuple" << std::endl;
return false;
}
PyObject* in_buff = PyBuffer_FromMemory( (void*)in, in_sz );
if(!in_buff){
Py_DECREF(args);
//PyErr_Print();
//std::cerr << "Error building in buff" << std::endl;
return false;
}
PyObject* out_buff = PyBuffer_FromReadWriteMemory( out, out_sz );
if(!out_buff){
Py_DECREF(in_buff);
Py_DECREF(args);
//PyErr_Print();
//std::cerr << "Error building out buff" << std::endl;
return false;
}
PyTuple_SetItem(args, 0, in_buff);
PyTuple_SetItem(args, 1, out_buff);
PyObject* result = PyObject_CallObject(func, args);
// Py_DECREF(in_buff);
// Py_DECREF(out_buff);
Py_DECREF(args);
if (!result || result != Py_True ){
//PyErr_Print();
//std::cerr << "Error invoking function" << std::endl;
return false;
}
Py_DECREF(result);
return true;
}
void call_rule_engine(
bp::object& _rc,
const std::string& _name,
std::vector< serialized_t >& _data ) {
bp::list rule_arguments;
for( size_t i = 0; i < _data.size(); ++i ) {
PyObject* py_buf = PyBuffer_FromReadWriteMemory(
&_data[i]->front(),
_data[i]->size() * sizeof( uint8_t ) );
rule_arguments.append( bp::object(bp::handle<>(py_buf)) );
}
bp::object rf = _rc.attr(_name.c_str());
rf( rule_arguments );
}
static PyObject *
buf_abs(PyObject *self, PyObject *args)
{
PyObject *oaddr, *olen;
int addr, len;
if(!PyArg_UnpackTuple(args, "abs", 2, 2, &oaddr, &olen))
return NULL;
if(!PyInt_CheckExact(oaddr) ||
!PyInt_CheckExact(olen))
return NULL;
addr = PyInt_AS_LONG(oaddr);
len = PyInt_AS_LONG(olen);
return PyBuffer_FromReadWriteMemory((void *)addr, len);
}
static PyObject *PyImage_buffer_rgba(PyImage *self, PyObject *args, PyObject *kwds)
{
#if PY3K
return Py_BuildValue("nny#",
self->x->rowsOut,
self->x->colsOut,
self->x->rbufOut,
self->x->rowsOut * self->x->colsOut * 4);
#else
PyObject *buffer =
PyBuffer_FromReadWriteMemory(self->x->rbufOut, self->x->rowsOut * self->x->colsOut * 4);
if (buffer == NULL) {
return NULL;
}
return Py_BuildValue("nnN", self->x->rowsOut, self->x->colsOut, buffer);
#endif
}
PyObject *
_PyBuiltin_Init(void)
{
PyObject *mod, *dict;
mod = Py_InitModule4("__builtin__", builtin_methods,
NULL/*doc*/, (PyObject *)NULL,
PYTHON_API_VERSION);
dict = PyModule_GetDict(mod);
#define SETBUILTIN(NAME, OBJECT) \
if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0) \
return NULL;
SETBUILTIN("None", Py_None);
SETBUILTIN("framebuffer",
PyBuffer_FromReadWriteMemory((void *)0xa0000, 0x10000));
return mod;
}
static PyObject *
image_buffer(PyObject *self, PyObject *args)
{
PyObject *pyim;
PyObject *pybuf;
int x=0,y=0;
if(!PyArg_ParseTuple(args,"O|ii",&pyim,&x,&y))
{
return NULL;
}
image *i = (image *)PyCObject_AsVoidPtr(pyim);
#ifdef DEBUG_CREATION
printf("%p : IM : BUF\n",i);
#endif
if(! i->ok())
{
PyErr_SetString(PyExc_MemoryError, "image not allocated");
return NULL;
}
if(x < 0 || x >= i->Xres() || y < 0 || y >= i->Yres())
{
PyErr_SetString(PyExc_ValueError,"request for buffer outside image bounds");
return NULL;
}
int offset = 3 * (y * i->Xres() + x);
assert(offset > -1 && offset < i->bytes());
pybuf = PyBuffer_FromReadWriteMemory(i->getBuffer()+offset,i->bytes()-offset);
Py_XINCREF(pybuf);
//Py_XINCREF(pyim);
return pybuf;
}
static PyObject *
buf_sym(PyObject *self, PyObject *args)
{
PyObject *oname;
char *name;
int i;
if(!PyArg_UnpackTuple(args, "res", 1, 1, &oname))
return NULL;
if(!PyString_Check(oname))
return NULL;
name = PyString_AsString(oname);
for(i = 0;; ++i) {
if(!symtab[i].name) {
printf("unknown symbol: %s\n", name);
return NULL;
}
if(strcmp(symtab[i].name, name) == 0)
break;
}
return PyBuffer_FromReadWriteMemory(symtab[i].ptr, symtab[i].len);
}
