Blender V5.3
gpu_py_buffer.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
13
14#include <Python.h>
15
16#include <algorithm>
17
18#include "BLI_utildefines.hh"
19
20#include "MEM_guardedalloc.h"
21
22#include "GPU_texture.hh"
23
25
26#include "gpu_py.hh"
27
28#include "gpu_py_buffer.hh"
29
30namespace blender {
31
32#define PYGPU_BUFFER_PROTOCOL
33#define MAX_DIMENSIONS 64
34
35/* -------------------------------------------------------------------- */
38
39static Py_ssize_t pygpu_buffer_dimensions_tot_elem(const Py_ssize_t *shape, Py_ssize_t shape_len)
40{
41 Py_ssize_t tot = shape[0];
42 for (int i = 1; i < shape_len; i++) {
43 tot *= shape[i];
44 }
45
46 return tot;
47}
48
49static bool pygpu_buffer_dimensions_tot_len_compare(const Py_ssize_t *shape_a,
50 const Py_ssize_t shape_a_len,
51 const Py_ssize_t *shape_b,
52 const Py_ssize_t shape_b_len)
53{
54 if (pygpu_buffer_dimensions_tot_elem(shape_a, shape_a_len) !=
55 pygpu_buffer_dimensions_tot_elem(shape_b, shape_b_len))
56 {
57 PyErr_SetString(PyExc_BufferError, "array size does not match");
58 return false;
59 }
60
61 return true;
62}
63
64static bool pygpu_buffer_pyobj_as_shape(PyObject *shape_obj,
65 Py_ssize_t r_shape[MAX_DIMENSIONS],
66 Py_ssize_t *r_shape_len)
67{
68 Py_ssize_t shape_len = 0;
69 if (PyLong_Check(shape_obj)) {
70 shape_len = 1;
71 if ((r_shape[0] = PyLong_AsSsize_t(shape_obj)) < 1) {
72 PyErr_SetString(PyExc_AttributeError, "dimension must be greater than or equal to 1");
73 return false;
74 }
75 }
76 else if (PySequence_Check(shape_obj)) {
77 shape_len = PySequence_Size(shape_obj);
78 if (shape_len > MAX_DIMENSIONS) {
79 PyErr_SetString(PyExc_AttributeError,
80 "too many dimensions, max is " STRINGIFY(MAX_DIMENSIONS));
81 return false;
82 }
83 if (shape_len < 1) {
84 PyErr_SetString(PyExc_AttributeError, "sequence must have at least one dimension");
85 return false;
86 }
87
88 for (int i = 0; i < shape_len; i++) {
89 PyObject *ob = PySequence_GetItem(shape_obj, i);
90 if (!PyLong_Check(ob)) {
91 PyErr_Format(PyExc_TypeError,
92 "invalid dimension %i, expected an int, not a %.200s",
93 i,
94 Py_TYPE(ob)->tp_name);
95 Py_DECREF(ob);
96 return false;
97 }
98
99 r_shape[i] = PyLong_AsSsize_t(ob);
100 Py_DECREF(ob);
101
102 if (r_shape[i] < 1) {
103 PyErr_SetString(PyExc_AttributeError, "dimension must be greater than or equal to 1");
104 return false;
105 }
106 }
107 }
108 else {
109 PyErr_Format(PyExc_TypeError,
110 "invalid second argument expected a sequence "
111 "or an int, not a %.200s",
112 Py_TYPE(shape_obj)->tp_name);
113 }
114
115 *r_shape_len = shape_len;
116 return true;
117}
118
119static const char *pygpu_buffer_formatstr(eGPUDataFormat data_format)
120{
121 switch (data_format) {
122 case GPU_DATA_FLOAT:
123 return "f";
124 case GPU_DATA_INT:
125 return "i";
126 case GPU_DATA_UINT:
127 return "I";
128 case GPU_DATA_UBYTE:
129 return "B";
132 return "I";
133 default:
134 break;
135 }
136 return nullptr;
137}
138
140
141/* -------------------------------------------------------------------- */
144
146 const eGPUDataFormat format,
147 const int shape_len,
148 const Py_ssize_t *shape,
149 void *buf)
150{
151 BPyGPUBuffer *buffer = reinterpret_cast<BPyGPUBuffer *>(_PyObject_GC_New(&BPyGPU_BufferType));
152
153 buffer->parent = nullptr;
154 buffer->format = format;
155 buffer->shape_len = shape_len;
156 buffer->shape = MEM_new_array_uninitialized<Py_ssize_t>(size_t(shape_len), "BPyGPUBuffer shape");
157 memcpy(buffer->shape, shape, sizeof(*buffer->shape) * size_t(shape_len));
158 buffer->buf.as_void = buf;
159
160 if (parent) {
161 Py_INCREF(parent);
162 buffer->parent = parent;
163 BLI_assert(!PyObject_GC_IsTracked((PyObject *)buffer));
164 PyObject_GC_Track(buffer);
165 }
166 return buffer;
167}
168
169static PyObject *pygpu_buffer__sq_item(BPyGPUBuffer *self, Py_ssize_t i)
170{
171 if (i >= self->shape[0] || i < 0) {
172 PyErr_SetString(PyExc_IndexError, "array index out of range");
173 return nullptr;
174 }
175
176 const char *formatstr = pygpu_buffer_formatstr(eGPUDataFormat(self->format));
177
178 if (self->shape_len == 1) {
179 switch (self->format) {
180 case GPU_DATA_FLOAT:
181 return Py_BuildValue(formatstr, self->buf.as_float[i]);
182 case GPU_DATA_INT:
183 return Py_BuildValue(formatstr, self->buf.as_int[i]);
184 case GPU_DATA_UBYTE:
185 return Py_BuildValue(formatstr, self->buf.as_byte[i]);
186 case GPU_DATA_UINT:
189 return Py_BuildValue(formatstr, self->buf.as_uint[i]);
190 }
191 }
192 else {
193 int offset = i * GPU_texture_dataformat_size(eGPUDataFormat(self->format));
194 for (int j = 1; j < self->shape_len; j++) {
195 offset *= self->shape[j];
196 }
197
198 return reinterpret_cast<PyObject *>(
199 pygpu_buffer_make_from_data(reinterpret_cast<PyObject *>(self),
200 eGPUDataFormat(self->format),
201 self->shape_len - 1,
202 self->shape + 1,
203 self->buf.as_byte + offset));
204 }
205
206 return nullptr;
207}
208
209static PyObject *pygpu_buffer_to_list(BPyGPUBuffer *self)
210{
211 const Py_ssize_t len = self->shape[0];
212 PyObject *list = PyList_New(len);
213
214 for (Py_ssize_t i = 0; i < len; i++) {
215 PyList_SET_ITEM(list, i, pygpu_buffer__sq_item(self, i));
216 }
217
218 return list;
219}
220
222 /* Wrap. */
223 pygpu_buffer_to_list_doc,
224 ".. method:: to_list()\n"
225 "\n"
226 " Return the buffer as a list.\n"
227 "\n"
228 " :return: The buffer as a list.\n"
229 " :rtype: list\n");
231{
232 PyObject *list;
233
234 if (self->shape_len > 1) {
235 int i, len = self->shape[0];
236 list = PyList_New(len);
237
238 for (i = 0; i < len; i++) {
239 /* "BPyGPUBuffer *sub_tmp" is a temporary object created just to be read for nested lists.
240 * That is why it is decremented/freed soon after.
241 * TODO: For efficiency, avoid creating #BPyGPUBuffer when creating nested lists. */
242 BPyGPUBuffer *sub_tmp = reinterpret_cast<BPyGPUBuffer *>(pygpu_buffer__sq_item(self, i));
243 PyList_SET_ITEM(list, i, pygpu_buffer_to_list_recursive(sub_tmp));
244 Py_DECREF(sub_tmp);
245 }
246 }
247 else {
249 }
250
251 return list;
252}
253
255 /* Wrap. */
256 pygpu_buffer_dimensions_doc,
257 "The size of the buffer for each dimension.\n"
258 "\n"
259 "Setting the dimensions is supported when the total number of elements is unchanged.\n"
260 "\n"
261 ":type: list[int]\n");
262static PyObject *pygpu_buffer_dimensions_get(BPyGPUBuffer *self, void * /*arg*/)
263{
264 PyObject *list = PyList_New(self->shape_len);
265 int i;
266
267 for (i = 0; i < self->shape_len; i++) {
268 PyList_SET_ITEM(list, i, PyLong_FromLong(self->shape[i]));
269 }
270
271 return list;
272}
273
274static int pygpu_buffer_dimensions_set(BPyGPUBuffer *self, PyObject *value, void * /*type*/)
275{
276 Py_ssize_t shape[MAX_DIMENSIONS];
277 Py_ssize_t shape_len = 0;
278
279 if (!pygpu_buffer_pyobj_as_shape(value, shape, &shape_len)) {
280 return -1;
281 }
282
283 if (!pygpu_buffer_dimensions_tot_len_compare(shape, shape_len, self->shape, self->shape_len)) {
284 return -1;
285 }
286
287 if (shape_len != self->shape_len) {
288 MEM_delete(self->shape);
289 self->shape = MEM_new_array_uninitialized<Py_ssize_t>(size_t(shape_len), __func__);
290 }
291
292 self->shape_len = shape_len;
293 memcpy(self->shape, shape, sizeof(*self->shape) * size_t(shape_len));
294 return 0;
295}
296
297static int pygpu_buffer__tp_traverse(BPyGPUBuffer *self, visitproc visit, void *arg)
298{
299 Py_VISIT(self->parent);
300 return 0;
301}
302
304{
305 if (self->parent) {
306 Py_CLEAR(self->parent);
307 self->buf.as_void = nullptr;
308 }
309 return 0;
310}
311
313{
314 if (self->parent) {
315 PyObject_GC_UnTrack(self);
316 Py_CLEAR(self->parent);
317 }
318 else if (self->buf.as_void) {
319 MEM_delete_void(self->buf.as_void);
320 }
321
322 MEM_delete(self->shape);
323
324 PyObject_GC_Del(self);
325}
326
327static PyObject *pygpu_buffer__tp_repr(BPyGPUBuffer *self)
328{
329 PyObject *repr;
330
331 PyObject *list = pygpu_buffer_to_list_recursive(self);
333
334 repr = PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list);
335 Py_DECREF(list);
336
337 return repr;
338}
339
340static int pygpu_buffer__sq_ass_item(BPyGPUBuffer *self, Py_ssize_t i, PyObject *v);
341
343 Py_ssize_t begin,
344 Py_ssize_t end,
345 PyObject *seq)
346{
347 PyObject *item;
348 int count, err = 0;
349
350 begin = std::max<Py_ssize_t>(begin, 0);
351 end = std::min(end, self->shape[0]);
352 begin = std::min(begin, end);
353
354 if (!PySequence_Check(seq)) {
355 PyErr_Format(PyExc_TypeError,
356 "buffer[:] = value, invalid assignment. "
357 "Expected a sequence, not an %.200s type",
358 Py_TYPE(seq)->tp_name);
359 return -1;
360 }
361
362 /* re-use count var */
363 if ((count = PySequence_Size(seq)) != (end - begin)) {
364 PyErr_Format(PyExc_TypeError,
365 "buffer[:] = value, size mismatch in assignment. "
366 "Expected: %d (given: %d)",
367 count,
368 end - begin);
369 return -1;
370 }
371
372 for (count = begin; count < end; count++) {
373 item = PySequence_GetItem(seq, count - begin);
374 if (item) {
375 err = pygpu_buffer__sq_ass_item(self, count, item);
376 Py_DECREF(item);
377 }
378 else {
379 err = -1;
380 }
381 if (err) {
382 break;
383 }
384 }
385 return err;
386}
387
388static PyObject *pygpu_buffer__tp_new(PyTypeObject * /*type*/, PyObject *args, PyObject *kwds)
389{
391
392 PyObject *length_ob, *init = nullptr;
393 BPyGPUBuffer *buffer = nullptr;
394 Py_ssize_t shape[MAX_DIMENSIONS];
395
396 Py_ssize_t shape_len = 0;
397
398 if (kwds && PyDict_Size(kwds)) {
399 PyErr_SetString(PyExc_TypeError, "Buffer(): takes no keyword args");
400 return nullptr;
401 }
402
404 if (!PyArg_ParseTuple(args,
405 "O&" /* `format` */
406 "O" /* `dimensions` */
407 "|" /* Optional arguments. */
408 "O" /* `data` */
409 ": Buffer",
411 &pygpu_dataformat,
412 &length_ob,
413 &init))
414 {
415 return nullptr;
416 }
417 if (pygpu_dataformat.value_found == GPU_DATA_UINT_24_8_DEPRECATED) {
418 PyErr_WarnEx(PyExc_DeprecationWarning, "`UINT_24_8` is deprecated, use `FLOAT` instead", 1);
419 }
420
421 if (!pygpu_buffer_pyobj_as_shape(length_ob, shape, &shape_len)) {
422 return nullptr;
423 }
424
425 if (init && PyObject_CheckBuffer(init)) {
426 Py_buffer pybuffer;
427
428 if (PyObject_GetBuffer(init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) {
429 /* PyObject_GetBuffer raise a PyExc_BufferError */
430 return nullptr;
431 }
432
433 Py_ssize_t *pybuffer_shape = pybuffer.shape;
434 Py_ssize_t pybuffer_ndim = pybuffer.ndim;
435 if (!pybuffer_shape) {
436 pybuffer_shape = &pybuffer.len;
437 pybuffer_ndim = 1;
438 }
439
440 if (pygpu_buffer_dimensions_tot_len_compare(shape, shape_len, pybuffer_shape, pybuffer_ndim)) {
442 init, eGPUDataFormat(pygpu_dataformat.value_found), shape_len, shape, pybuffer.buf);
443 }
444
445 PyBuffer_Release(&pybuffer);
446 }
447 else {
448 buffer = BPyGPU_Buffer_CreatePyObject(pygpu_dataformat.value_found, shape, shape_len, nullptr);
449 if (init && pygpu_buffer_ass_slice(buffer, 0, shape[0], init)) {
450 Py_DECREF(buffer);
451 return nullptr;
452 }
453 }
454
455 return reinterpret_cast<PyObject *>(buffer);
456}
457
459{
460 return self->parent != nullptr;
461}
462
463/* BPyGPUBuffer sequence methods */
464
465static Py_ssize_t pygpu_buffer__sq_length(BPyGPUBuffer *self)
466{
467 return self->shape[0];
468}
469
470static PyObject *pygpu_buffer_slice(BPyGPUBuffer *self, Py_ssize_t begin, Py_ssize_t end)
471{
472 PyObject *list;
473 Py_ssize_t count;
474
475 begin = std::max<Py_ssize_t>(begin, 0);
476 end = std::min(end, self->shape[0]);
477 begin = std::min(begin, end);
478
479 list = PyList_New(end - begin);
480
481 for (count = begin; count < end; count++) {
482 PyList_SET_ITEM(list, count - begin, pygpu_buffer__sq_item(self, count));
483 }
484 return list;
485}
486
487static int pygpu_buffer__sq_ass_item(BPyGPUBuffer *self, Py_ssize_t i, PyObject *v)
488{
489 if (i >= self->shape[0] || i < 0) {
490 PyErr_SetString(PyExc_IndexError, "array assignment index out of range");
491 return -1;
492 }
493
494 if (self->shape_len != 1) {
495 BPyGPUBuffer *row = reinterpret_cast<BPyGPUBuffer *>(pygpu_buffer__sq_item(self, i));
496
497 if (row) {
498 const int ret = pygpu_buffer_ass_slice(row, 0, self->shape[1], v);
499 Py_DECREF(row);
500 return ret;
501 }
502
503 return -1;
504 }
505
506 switch (self->format) {
507 case GPU_DATA_FLOAT:
508 return PyArg_Parse(v,
509 "f" /* `value` */
510 ":Expected floats",
511 &self->buf.as_float[i]) ?
512 0 :
513 -1;
514 case GPU_DATA_INT:
515 return PyArg_Parse(v,
516 "i" /* `value` */
517 ":Expected ints",
518 &self->buf.as_int[i]) ?
519 0 :
520 -1;
521 case GPU_DATA_UBYTE:
522 return PyArg_Parse(v,
523 "b" /* `value` */
524 ":Expected ints",
525 &self->buf.as_byte[i]) ?
526 0 :
527 -1;
528 case GPU_DATA_UINT:
531 return PyArg_Parse(v,
532 "I" /* `value` */
533 ":Expected unsigned ints",
534 &self->buf.as_uint[i]) ?
535 0 :
536 -1;
537 default:
538 return 0; /* should never happen */
539 }
540}
541
542static PyObject *pygpu_buffer__mp_subscript(BPyGPUBuffer *self, PyObject *item)
543{
544 if (PyIndex_Check(item)) {
545 Py_ssize_t i;
546 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
547 if (i == -1 && PyErr_Occurred()) {
548 return nullptr;
549 }
550 if (i < 0) {
551 i += self->shape[0];
552 }
553 return pygpu_buffer__sq_item(self, i);
554 }
555 if (PySlice_Check(item)) {
556 Py_ssize_t start, stop, step, slicelength;
557
558 if (PySlice_GetIndicesEx(item, self->shape[0], &start, &stop, &step, &slicelength) < 0) {
559 return nullptr;
560 }
561
562 if (slicelength <= 0) {
563 return PyTuple_New(0);
564 }
565 if (step == 1) {
566 return pygpu_buffer_slice(self, start, stop);
567 }
568
569 PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
570 return nullptr;
571 }
572
573 PyErr_Format(
574 PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
575 return nullptr;
576}
577
578static int pygpu_buffer__mp_ass_subscript(BPyGPUBuffer *self, PyObject *item, PyObject *value)
579{
580 if (PyIndex_Check(item)) {
581 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
582 if (i == -1 && PyErr_Occurred()) {
583 return -1;
584 }
585 if (i < 0) {
586 i += self->shape[0];
587 }
588 return pygpu_buffer__sq_ass_item(self, i, value);
589 }
590 if (PySlice_Check(item)) {
591 Py_ssize_t start, stop, step, slicelength;
592
593 if (PySlice_GetIndicesEx(item, self->shape[0], &start, &stop, &step, &slicelength) < 0) {
594 return -1;
595 }
596
597 if (step == 1) {
598 return pygpu_buffer_ass_slice(self, start, stop, value);
599 }
600
601 PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors");
602 return -1;
603 }
604
605 PyErr_Format(
606 PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
607 return -1;
608}
609
610#ifdef __GNUC__
611# ifdef __clang__
612# pragma clang diagnostic push
613# pragma clang diagnostic ignored "-Wcast-function-type"
614# else
615# pragma GCC diagnostic push
616# pragma GCC diagnostic ignored "-Wcast-function-type"
617# endif
618#endif
619
620static PyMethodDef pygpu_buffer__tp_methods[] = {
621 {"to_list",
622 reinterpret_cast<PyCFunction>(pygpu_buffer_to_list_recursive),
623 METH_NOARGS,
624 pygpu_buffer_to_list_doc},
625 {nullptr, nullptr, 0, nullptr},
626};
627
628#ifdef __GNUC__
629# ifdef __clang__
630# pragma clang diagnostic pop
631# else
632# pragma GCC diagnostic pop
633# endif
634#endif
635
636static PyGetSetDef pygpu_buffer_getseters[] = {
637 {"dimensions",
638 reinterpret_cast<getter>(pygpu_buffer_dimensions_get),
639 reinterpret_cast<setter>(pygpu_buffer_dimensions_set),
640 pygpu_buffer_dimensions_doc,
641 nullptr},
642 {nullptr, nullptr, nullptr, nullptr, nullptr},
643};
644
645static PySequenceMethods pygpu_buffer__tp_as_sequence = {
646 /*sq_length*/ reinterpret_cast<lenfunc>(pygpu_buffer__sq_length),
647 /*sq_concat*/ nullptr,
648 /*sq_repeat*/ nullptr,
649 /*sq_item*/ reinterpret_cast<ssizeargfunc>(pygpu_buffer__sq_item),
650 /*was_sq_slice*/ nullptr, /* DEPRECATED. Handled by #pygpu_buffer__sq_item. */
651 /*sq_ass_item*/ reinterpret_cast<ssizeobjargproc>(pygpu_buffer__sq_ass_item),
652 /*was_sq_ass_slice*/ nullptr, /* DEPRECATED. Handled by #pygpu_buffer__sq_ass_item. */
653 /*sq_contains*/ nullptr,
654 /*sq_inplace_concat*/ nullptr,
655 /*sq_inplace_repeat*/ nullptr,
656};
657
658static PyMappingMethods pygpu_buffer__tp_as_mapping = {
659 /*mp_length*/ reinterpret_cast<lenfunc>(pygpu_buffer__sq_length),
660 /*mp_subscript*/ reinterpret_cast<binaryfunc>(pygpu_buffer__mp_subscript),
661 /*mp_ass_subscript*/ reinterpret_cast<objobjargproc>(pygpu_buffer__mp_ass_subscript),
662};
663
664#ifdef PYGPU_BUFFER_PROTOCOL
666 const int shape_len,
667 const Py_ssize_t *shape,
668 Py_ssize_t *r_strides)
669{
670 Py_ssize_t stride = GPU_texture_dataformat_size(format);
671 for (int i = shape_len; i-- > 0;) {
672 r_strides[i] = stride;
673 stride *= shape[i];
674 }
675}
676
677/* Here is the buffer interface function */
678static int pygpu_buffer__bf_getbuffer(BPyGPUBuffer *self, Py_buffer *view, int flags)
679{
680 if (view == nullptr) [[unlikely]] {
681 PyErr_SetString(PyExc_ValueError, "null view in get-buffer is obsolete");
682 return -1;
683 }
684
685 memset(view, 0, sizeof(*view));
686
687 view->obj = reinterpret_cast<PyObject *>(self);
688 view->buf = self->buf.as_void;
689 view->len = bpygpu_Buffer_size(self);
690 view->readonly = 0;
691 view->itemsize = GPU_texture_dataformat_size(eGPUDataFormat(self->format));
692 if (flags & PyBUF_FORMAT) {
693 view->format = const_cast<char *>(pygpu_buffer_formatstr(eGPUDataFormat(self->format)));
694 }
695 if (flags & PyBUF_ND) {
696 view->ndim = self->shape_len;
697 view->shape = self->shape;
698 }
699 if (flags & PyBUF_STRIDES) {
700 view->strides = MEM_new_array_uninitialized<Py_ssize_t>(size_t(view->ndim),
701 "BPyGPUBuffer strides");
703 eGPUDataFormat(self->format), view->ndim, view->shape, view->strides);
704 }
705 view->suboffsets = nullptr;
706 view->internal = nullptr;
707
708 Py_INCREF(self);
709 return 0;
710}
711
712static void pygpu_buffer__bf_releasebuffer(PyObject * /*exporter*/, Py_buffer *view)
713{
714 MEM_SAFE_DELETE(view->strides);
715}
716
717static PyBufferProcs pygpu_buffer__tp_as_buffer = {
718 /*bf_getbuffer*/ reinterpret_cast<getbufferproc>(pygpu_buffer__bf_getbuffer),
719 /*bf_releasebuffer*/ static_cast<releasebufferproc>(pygpu_buffer__bf_releasebuffer),
720};
721#endif
722
724 /* Wrap. */
725 pygpu_buffer__tp_doc,
726 ".. class:: Buffer\n"
727 "\n"
728 " For Python access to GPU functions requiring a pointer.\n"
729 "\n"
730 " .. method:: __init__(format, dimensions, data)\n"
731 "\n"
732 " :param format: Format type to interpret the buffer.\n"
733 " ``UINT_24_8`` is deprecated, use ``FLOAT`` instead.\n"
734 " :type format: " PYDOC_DATAFORMAT_LITERAL
735 "\n"
736 " :param dimensions: Array describing the dimensions.\n"
737 " :type dimensions: int | Sequence[int]\n"
738 " :param data: Optional data array.\n"
739 " :type data: Buffer | Sequence[float] | Sequence[int]\n");
740PyTypeObject BPyGPU_BufferType = {
741 /*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)
742 /*tp_name*/ "Buffer",
743 /*tp_basicsize*/ sizeof(BPyGPUBuffer),
744 /*tp_itemsize*/ 0,
745 /*tp_dealloc*/ reinterpret_cast<destructor>(pygpu_buffer__tp_dealloc),
746 /*tp_vectorcall_offset*/ 0,
747 /*tp_getattr*/ nullptr,
748 /*tp_setattr*/ nullptr,
749 /*tp_compare*/ nullptr,
750 /*tp_repr*/ reinterpret_cast<reprfunc>(pygpu_buffer__tp_repr),
751 /*tp_as_number*/ nullptr,
752 /*tp_as_sequence*/ &pygpu_buffer__tp_as_sequence,
753 /*tp_as_mapping*/ &pygpu_buffer__tp_as_mapping,
754 /*tp_hash*/ nullptr,
755 /*tp_call*/ nullptr,
756 /*tp_str*/ nullptr,
757 /*tp_getattro*/ nullptr,
758 /*tp_setattro*/ nullptr,
760 /*tp_as_buffer*/ &pygpu_buffer__tp_as_buffer,
761#else
762 /*tp_as_buffer*/ nullptr,
763#endif
764 /*tp_flags*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
765 /*tp_doc*/ pygpu_buffer__tp_doc,
766 /*tp_traverse*/ reinterpret_cast<traverseproc>(pygpu_buffer__tp_traverse),
767 /*tp_clear*/ reinterpret_cast<inquiry>(pygpu_buffer__tp_clear),
768 /*tp_richcompare*/ nullptr,
769 /*tp_weaklistoffset*/ 0,
770 /*tp_iter*/ nullptr,
771 /*tp_iternext*/ nullptr,
772 /*tp_methods*/ pygpu_buffer__tp_methods,
773 /*tp_members*/ nullptr,
774 /*tp_getset*/ pygpu_buffer_getseters,
775 /*tp_base*/ nullptr,
776 /*tp_dict*/ nullptr,
777 /*tp_descr_get*/ nullptr,
778 /*tp_descr_set*/ nullptr,
779 /*tp_dictoffset*/ 0,
780 /*tp_init*/ nullptr,
781 /*tp_alloc*/ nullptr,
782 /*tp_new*/ pygpu_buffer__tp_new,
783 /*tp_free*/ nullptr,
784 /*tp_is_gc*/ reinterpret_cast<inquiry>(pygpu_buffer__tp_is_gc),
785 /*tp_bases*/ nullptr,
786 /*tp_mro*/ nullptr,
787 /*tp_cache*/ nullptr,
788 /*tp_subclasses*/ nullptr,
789 /*tp_weaklist*/ nullptr,
790 /*tp_del*/ nullptr,
791 /*tp_version_tag*/ 0,
792 /*tp_finalize*/ nullptr,
793 /*tp_vectorcall*/ nullptr,
794};
795
796static size_t pygpu_buffer_calc_size(const int format,
797 const int shape_len,
798 const Py_ssize_t *shape)
799{
800 return pygpu_buffer_dimensions_tot_elem(shape, shape_len) *
802}
803
805{
806 return pygpu_buffer_calc_size(buffer->format, buffer->shape_len, buffer->shape);
807}
808
810 const Py_ssize_t *shape,
811 const int shape_len,
812 void *buffer)
813{
814 if (buffer == nullptr) {
815 size_t size = pygpu_buffer_calc_size(format, shape_len, shape);
816 buffer = MEM_new_zeroed(size, "BPyGPUBuffer buffer");
817 }
818
819 return pygpu_buffer_make_from_data(nullptr, eGPUDataFormat(format), shape_len, shape, buffer);
820}
821
823
824} // namespace blender
Read Blender memory allocation and freeing.
#define STRINGIFY(x)
#define BPYGPU_IS_INIT_OR_ERROR_OBJ
Definition gpu_py.hh:45
#define PYDOC_DATAFORMAT_LITERAL
Definition gpu_py.hh:34
#define MAX_DIMENSIONS
#define PYGPU_BUFFER_PROTOCOL
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
PyTypeObject BPyGPU_BufferType
PyC_StringEnumItems bpygpu_dataformat_items[]
Definition gpu_py.cc:42
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static PyObject * pygpu_buffer_to_list_recursive(BPyGPUBuffer *self)
static bool pygpu_buffer_dimensions_tot_len_compare(const Py_ssize_t *shape_a, const Py_ssize_t shape_a_len, const Py_ssize_t *shape_b, const Py_ssize_t shape_b_len)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static void pygpu_buffer__bf_releasebuffer(PyObject *, Py_buffer *view)
static int pygpu_buffer__tp_clear(BPyGPUBuffer *self)
@ GPU_DATA_10_11_11_REV
@ GPU_DATA_UINT_24_8_DEPRECATED
PyDoc_STRVAR(bpy_bm_new_doc, ".. function:: new(*, use_operators=True)\n" "\n" " :param use_operators: Support calling operators in :mod:`bmesh.ops` (uses some " "extra memory per vert/edge/face).\n" " :type use_operators: bool\n" " :return: Return a new, empty BMesh.\n" " :rtype: :class:`bmesh.types.BMesh`\n")
static int pygpu_buffer__mp_ass_subscript(BPyGPUBuffer *self, PyObject *item, PyObject *value)
static BPyGPUBuffer * pygpu_buffer_make_from_data(PyObject *parent, const eGPUDataFormat format, const int shape_len, const Py_ssize_t *shape, void *buf)
ATTR_WARN_UNUSED_RESULT const BMVert * v
static PyBufferProcs pygpu_buffer__tp_as_buffer
static Py_ssize_t pygpu_buffer_dimensions_tot_elem(const Py_ssize_t *shape, Py_ssize_t shape_len)
static void pygpu_buffer__tp_dealloc(BPyGPUBuffer *self)
void MEM_delete_void(void *vmemh)
static PyObject * pygpu_buffer__mp_subscript(BPyGPUBuffer *self, PyObject *item)
static PyObject * pygpu_buffer__tp_repr(BPyGPUBuffer *self)
static PyObject * pygpu_buffer_slice(BPyGPUBuffer *self, Py_ssize_t begin, Py_ssize_t end)
static size_t pygpu_buffer_calc_size(const int format, const int shape_len, const Py_ssize_t *shape)
static PyGetSetDef pygpu_buffer_getseters[]
static int pygpu_buffer__tp_traverse(BPyGPUBuffer *self, visitproc visit, void *arg)
static int pygpu_buffer__bf_getbuffer(BPyGPUBuffer *self, Py_buffer *view, int flags)
static PyMethodDef pygpu_buffer__tp_methods[]
static int pygpu_buffer__sq_ass_item(BPyGPUBuffer *self, Py_ssize_t i, PyObject *v)
size_t bpygpu_Buffer_size(BPyGPUBuffer *buffer)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
size_t GPU_texture_dataformat_size(eGPUDataFormat data_format)
static PyObject * pygpu_buffer_dimensions_get(BPyGPUBuffer *self, void *)
static const char * pygpu_buffer_formatstr(eGPUDataFormat data_format)
static int pygpu_buffer_dimensions_set(BPyGPUBuffer *self, PyObject *value, void *)
const char * PyC_StringEnum_FindIDFromValue(const PyC_StringEnumItems *items, const int value)
static PySequenceMethods pygpu_buffer__tp_as_sequence
static PyObject * pygpu_buffer__tp_new(PyTypeObject *, PyObject *args, PyObject *kwds)
static void pygpu_buffer_strides_calc(const eGPUDataFormat format, const int shape_len, const Py_ssize_t *shape, Py_ssize_t *r_strides)
static Py_ssize_t pygpu_buffer__sq_length(BPyGPUBuffer *self)
BPyGPUBuffer * BPyGPU_Buffer_CreatePyObject(const int format, const Py_ssize_t *shape, const int shape_len, void *buffer)
static int pygpu_buffer__tp_is_gc(BPyGPUBuffer *self)
iter begin(iter)
static PyObject * pygpu_buffer_to_list(BPyGPUBuffer *self)
static int pygpu_buffer_ass_slice(BPyGPUBuffer *self, Py_ssize_t begin, Py_ssize_t end, PyObject *seq)
int PyC_ParseStringEnum(PyObject *o, void *p)
static PyObject * pygpu_buffer__sq_item(BPyGPUBuffer *self, Py_ssize_t i)
static bool pygpu_buffer_pyobj_as_shape(PyObject *shape_obj, Py_ssize_t r_shape[MAX_DIMENSIONS], Py_ssize_t *r_shape_len)
static PyMappingMethods pygpu_buffer__tp_as_mapping
union blender::BPyGPUBuffer::@121160014351146313222050217274041240110051113162 buf
PyObject_HEAD PyObject * parent