/* Loop over all child structs in the children list and free them */
static void free_children(struct tracy_ll *children)
{
struct tracy_child *tc;
struct tracy_ll_item *cur = children->head;
/* Walk over all items in the list */
while(cur) {
tc = cur->data;
/* Detach or kill */
if (tc->attached) {
fprintf(stderr, _b("Detaching from child %d")"\n", tc->pid);
PTRACE_CHECK_NORETURN(PTRACE_DETACH, tc->pid, NULL, NULL);
/* TODO: What can we do in case of failure? */
} else {
fprintf(stderr, _b("Killing child %d")"\n", tc->pid);
tracy_kill_child(tc);
}
/* Free data and fetch next item */
cur = cur->next;
}
return;
}
/* the key schedule routine */
void keySched(BYTE M[], int N, u32 **S, u32 K[40], int *k)
{
u32 Mo[4], Me[4];
int i, j;
BYTE vector[8];
u32 A, B;
*k = (N + 63) / 64;
*S = (u32*)malloc(sizeof(u32) * (*k));
for (i = 0; i < *k; i++)
{
Me[i] = BSWAP(((u32*)M)[2*i]);
Mo[i] = BSWAP(((u32*)M)[2*i+1]);
}
for (i = 0; i < *k; i++)
{
for (j = 0; j < 4; j++) vector[j] = _b(Me[i], j);
for (j = 0; j < 4; j++) vector[j+4] = _b(Mo[i], j);
(*S)[(*k)-i-1] = RSMatrixMultiply(vector);
}
for (i = 0; i < 20; i++)
{
A = h(2*i*RHO, Me, *k);
B = ROL(h(2*i*RHO + RHO, Mo, *k), 8);
K[2*i] = A+B;
K[2*i+1] = ROL(A + 2*B, 9);
}
}
XMFLOAT4 TransferFunction::operator()(int isoValue) {
float alp = _a(isoValue) < 0 ? 0 : (_a(isoValue) > 1 ? 1 : _a(isoValue));
float red = _r(isoValue) < 0 ? 0 : (_r(isoValue) > 1 ? 1 : _r(isoValue));
float gre = _g(isoValue) < 0 ? 0 : (_g(isoValue) > 1 ? 1 : _g(isoValue));
float blu = _b(isoValue) < 0 ? 0 : (_b(isoValue) > 1 ? 1 : _b(isoValue));
return XMFLOAT4(red, gre, blu, alp);
}
Matrix<double> Triangle::B()
{
Matrix<double> Result(3);
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
Result[i][j]=_b(i)*_b(j);
return Result;
}
static gboolean app_bus_callback(GstBus *bus, GstMessage *message, gpointer data)
{
app_data_t *app = data;
GMainLoop *loop = app->loop;
switch (GST_MESSAGE_TYPE(message))
{
case GST_MESSAGE_ERROR:
{
GError *err;
gchar *debug;
/* ...dump error-message reported by the GStreamer */
gst_message_parse_error (message, &err, &debug);
TRACE(ERROR, _b("execution failed: %s"), err->message);
g_error_free(err);
g_free(debug);
/* ...right now this is a fatal error */
BUG(1, _x("breakpoint"));
/* ...and terminate the loop */
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_EOS:
{
/* ...end-of-stream encountered; break the loop */
TRACE(INFO, _b("execution completed"));
g_main_loop_quit(loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
{
/* ...state has changed; test if it is start or stop */
if (GST_MESSAGE_SRC(message) == GST_OBJECT_CAST(app->pipe))
{
GstState old, new, pending;
/* ...parse state message */
gst_message_parse_state_changed(message, &old, &new, &pending);
TRACE(INFO, _b("transition from %d to %d"), old, new);
}
break;
}
default:
/* ...ignore message */
TRACE(0, _b("ignore message: %s"), gst_message_type_get_name(GST_MESSAGE_TYPE(message)));
}
static long
_b(Engine *engine, long min, long max) {
if (max <= min) return max;
if (max == min + 1) return max;
long middle = (max + min) / 2;
if(engine_get_document(engine, middle)) {
return _b(engine, min, middle);
} else {
return _b(engine, middle, max);
}
}
static void blend_single(image_t * frame, ASS_Image *img)
{
int x, y;
unsigned char opacity = 255 - _a(img->color);
unsigned char r = _r(img->color);
unsigned char g = _g(img->color);
unsigned char b = _b(img->color);
unsigned char *src;
unsigned char *dst;
src = img->bitmap;
dst = frame->buffer + img->dst_y * frame->stride + img->dst_x * 3;
for (y = 0; y < img->h; ++y) {
for (x = 0; x < img->w; ++x) {
unsigned k = ((unsigned) src[x]) * opacity / 255;
// possible endianness problems
dst[x * 3] = (k * b + (255 - k) * dst[x * 3]) / 255;
dst[x * 3 + 1] = (k * g + (255 - k) * dst[x * 3 + 1]) / 255;
dst[x * 3 + 2] = (k * r + (255 - k) * dst[x * 3 + 2]) / 255;
}
src += img->stride;
dst += frame->stride;
}
}
/* ...create display data */
display_data_t * display_create(void)
{
display_data_t *display = &__display;
pthread_attr_t attr;
int r;
/* ...reset display data */
memset(display, 0, sizeof(*display));
XInitThreads();
/* ...connect to X server display */
display->display = XOpenDisplay(NULL);
if (display->display == NULL)
{
goto error;
}
/* ...initialize thread attributes (joinable, default stack size) */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
/* ...wait until display thread starts? */
TRACE(INIT, _b("X11 display interface initialized"));
return display;
error_epoll:
error_disp:
error:
return NULL;
}
DjinniBinary * cw__test_helpers_id_binary(DjinniBinary * b) {
std::unique_ptr<DjinniBinary> _b(b);
try {
return DjinniBinary::fromCpp(::testsuite::TestHelpers::id_binary(DjinniBinary::toCpp(std::move(_b)))).release();
}
CW_TRANSLATE_EXCEPTIONS_RETURN(0);
}
long
engine_min_document_id(Engine *engine) {
long drs = sizeof(DocRef);
long bound = (engine->docs->written - engine->docs->capacity) / drs - 1;
if(bound < 0) bound = -1;
return _b(engine, bound, engine_last_document_id(engine));
}
void opengl_scene::draw( const CView& v ) {
opengl_static_scene::draw( );
RECT r;
v.GetClientRect(&r);
gl_point a(0.0f, 0.0f);
gl_point b(((GLfloat)r.right)/2.0f, (GLfloat)r.bottom/2.0f);
gl_point c((GLfloat)r.right, 0.0f);
color.purple( );
if(rand( ) % 2) s1.draw(gl_triangle(a,b,c));
gl_point _a(0.0f, (GLfloat)r.bottom);
gl_point _b(((GLfloat)r.right)/2.0f, (GLfloat)r.bottom/2.0f);
gl_point _c((GLfloat)r.right, (GLfloat)r.bottom);
color.red( );
if(rand( ) % 2) s2.draw( gl_triangle(_a, _b, _c));
gl_point A(((GLfloat)r.right)/2.0f, (GLfloat)r.bottom/2.0f);
gl_point B(((GLfloat)r.right), (GLfloat)r.bottom);
gl_point C((GLfloat)r.right, 0.0f);
color.lime( );
if(rand( ) % 2) s3.draw( gl_triangle(A, B, C));
}
int ZMatQRSolver_NR3::solve( double *b, double *x ) {
// solve Ax = b, must call decompose() first.
VecDoub _b( rows, b, 1 );
VecDoub _x( cols, x, 1 );
pNRqr->solve( _b, _x );
return 1;
}
int
main(int argc, char **argv)
{
int errflag = 0;
int sts;
int c;
__pmSetProgname(argv[0]);
indomp = (__pmInDom_int *)&indom;
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
fprintf(stderr, "Usage: %s [-D...] [a|b|c|d|...|i 1|2|3}\n", pmProgname);
exit(1);
}
while (optind < argc) {
if (strcmp(argv[optind], "a") == 0) _a(0, 1, 1);
else if (strcmp(argv[optind], "b") == 0) _b();
else if (strcmp(argv[optind], "c") == 0) _c();
else if (strcmp(argv[optind], "d") == 0) _a(1, 0, 1);
else if (strcmp(argv[optind], "e") == 0) _e(0);
else if (strcmp(argv[optind], "f") == 0) _e(3600);
else if (strcmp(argv[optind], "g") == 0) _g();
else if (strcmp(argv[optind], "h") == 0) _h();
else if (strcmp(argv[optind], "i") == 0) {
optind++;
_i(atoi(argv[optind]));
}
else if (strcmp(argv[optind], "j") == 0) _j();
else
fprintf(stderr, "torture_cache: no idea what to do with option \"%s\"\n", argv[optind]);
optind++;
}
exit(0);
}
static void blend_single(SDL_Surface * frame, ASS_Image *img)
{
int x, y;
unsigned char opacity = 255 - _a(img->color);
unsigned char r = _r(img->color);
unsigned char g = _g(img->color);
unsigned char b = _b(img->color);
unsigned char *src;
unsigned char *dst;
src = img->bitmap;
dst = frame->pixels;
for (y = 0; y < img->h; ++y) {
for (x = 0; x < img->w; ++x) {
unsigned k = ((unsigned) src[x]) * opacity / 255;
// possible endianness problems
dst[x * 4] = (k * b + (255 - k) * dst[x * 4]) / 255;
dst[x * 4 + 1] = (k * g + (255 - k) * dst[x * 4 + 1]) / 255;
dst[x * 4 + 2] = (k * r + (255 - k) * dst[x * 4 + 2]) / 255;
dst[x * 4 + 3] = k;
}
src += img->stride;
dst += frame->pitch;
}
}
/*!
Create a vpMbScanLineEdge from two points while ordering them.
\param a : First point of the line.
\param b : Second point of the line.
\return Resulting vpMbScanLineEdge.
*/
vpMbScanLine::vpMbScanLineEdge
vpMbScanLine::makeMbScanLineEdge(const vpPoint &a, const vpPoint &b)
{
vpColVector _a(3);
vpColVector _b(3);
_a[0] = std::ceil((a.get_X() * 1e8) * 1e-6);
_a[1] = std::ceil((a.get_Y() * 1e8) * 1e-6);
_a[2] = std::ceil((a.get_Z() * 1e8) * 1e-6);
_b[0] = std::ceil((b.get_X() * 1e8) * 1e-6);
_b[1] = std::ceil((b.get_Y() * 1e8) * 1e-6);
_b[2] = std::ceil((b.get_Z() * 1e8) * 1e-6);
bool b_comp = false;
for(unsigned int i = 0 ; i < 3 ; ++i)
if (_a[i] < _b[i])
{
b_comp = true;
break;
}
else if(_a[i] > _b[i])
break;
if (b_comp)
return std::make_pair(_a, _b);
return std::make_pair(_b, _a);
}
static void assRender(VSFrameRef *dst, VSFrameRef *alpha, const VSAPI *vsapi,
ASS_Image *img)
{
uint8_t *planes[4];
int strides[4], p;
for(p = 0; p < 4; p++) {
VSFrameRef *fr = p == 3 ? alpha : dst;
planes[p] = vsapi->getWritePtr(fr, p % 3);
strides[p] = vsapi->getStride(fr, p % 3);
memset(planes[p], 0, strides[p] * vsapi->getFrameHeight(fr, p % 3));
}
while(img) {
uint8_t *dstp[4], *alphap, *sp, color[4];
uint16_t outa;
int x, y, k;
if(img->w == 0 || img->h == 0) {
img = img->next;
continue;
}
color[0] = _r(img->color);
color[1] = _g(img->color);
color[2] = _b(img->color);
color[3] = _a(img->color);
dstp[0] = planes[0] + (strides[0] * img->dst_y) + img->dst_x;
dstp[1] = planes[1] + (strides[1] * img->dst_y) + img->dst_x;
dstp[2] = planes[2] + (strides[2] * img->dst_y) + img->dst_x;
dstp[3] = planes[3] + (strides[3] * img->dst_y) + img->dst_x;
alphap = dstp[3];
sp = img->bitmap;
for(y = 0; y < img->h; y++) {
for(x = 0; x < img->w; x++) {
k = div255(sp[x] * color[3]);
outa = k * 255 + (alphap[x] * (255 - k));
if(outa != 0) {
dstp[0][x] = blend(k, color[0], alphap[x], dstp[0][x], outa);
dstp[1][x] = blend(k, color[1], alphap[x], dstp[1][x], outa);
dstp[2][x] = blend(k, color[2], alphap[x], dstp[2][x], outa);
dstp[3][x] = div255(outa);
}
}
dstp[0] += strides[0];
dstp[1] += strides[1];
dstp[2] += strides[2];
dstp[3] += strides[3];
alphap += strides[3];
sp += img->stride;
}
img = img->next;
}
}
/* ...initialize GL-processing context */
static int app_context_init(widget_data_t *widget, void *data)
{
app_data_t *app = data;
window_data_t *window = (window_data_t *)widget;
int W = widget_get_width(widget);
int H = widget_get_height(widget);
/* ...initialize surround-view engine (dimensions are fixed?) */
CHK_ERR(app->sv = sview_engine_init(app->sv_cfg, 1280, 800), -errno);
/* ...create UI layer */
CHK_ERR(app->gui = gui_create(window, app), -errno);
// /* ...display context is shared with all windows; context is surfaceless */
// eglMakeCurrent(display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, display->egl.ctx);
// BUG(eglGetCurrentContext() == EGL_NO_CONTEXT, _x("invalid egl context"));
//
// sview_engine_destroy(app->sv);
// app->sv = sview_engine_init(app->sv_cfg, 1280, 800);
//
// sview_engine_destroy(app->sv);
// app->sv = sview_engine_init(app->sv_cfg, 1280, 800);
//
// sview_bv_reinit(app->sv,app->sv_cfg, 1280, 800);
TRACE(INIT, _b("run-time initialized: %u*%u"), W, H);
return 0;
}
/* ...keyboard event processing */
static inline widget_data_t * app_key_event(app_data_t *app, widget_data_t *widget, widget_key_event_t *event)
{
pthread_mutex_lock(&app->access);
if (app->flags & APP_FLAG_SVIEW)
{
if (event->type == WIDGET_EVENT_KEY_PRESS)
{
TRACE(DEBUG, _b("Key pressed: %i"), event->code);
sview_engine_keyboard_key(app->sv, event->code, event->state);
}
}
else
{
#ifdef ENABLE_OBJDET
if (event->type == WIDGET_EVENT_KEY_PRESS)
{
objdet_engine_keyboard_key(app->od, event->code, event->state);
}
#endif
}
pthread_mutex_unlock(&app->access);
return widget;
}
/* ...draw multiline string - hmm; need to put that stuff into display */
static inline void draw_string(cairo_t *cr, const char *fmt, ...)
{
char buffer[4096], *p, *end;
cairo_text_extents_t text_extents;
cairo_font_extents_t font_extents;
va_list argp;
cairo_save(cr);
cairo_select_font_face(cr, "sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size(cr, 40);
cairo_font_extents(cr, &font_extents);
va_start(argp, fmt);
vsnprintf(buffer, sizeof(buffer), fmt, argp);
va_end(argp);
for (p = buffer; *p; p = end + 1)
{
/* ...output single line */
((end = strchr(p, '\n')) != NULL ? *end = 0 : 0);
cairo_show_text(cr, p);
cairo_text_extents (cr, p, &text_extents);
cairo_rel_move_to (cr, -text_extents.x_advance, font_extents.height);
TRACE(0, _b("print text-line: <%f,%f>"), text_extents.x_advance, font_extents.height);
/* ...stop when last line processes */
if (!end) break;
}
/* ...restore drawing context */
cairo_restore(cr);
}
void _rseek_head(void) const
noexcept {
assert(_pos != nullptr);
while(!mbs::is_valid_head_byte(_b())) {
--_pos;
}
}
int main()
{
__block int var = 0;
int shouldbe = 0;
void (^b)(void) = ^{ var++; /*printf("var is at %p with value %d\n", &var, var);*/ };
__typeof(b) _b;
//printf("before copy...\n");
b(); ++shouldbe;
size_t i;
for (i = 0; i < 10; i++) {
_b = Block_copy(b); // make a new copy each time
assert(_b);
++shouldbe;
_b(); // should still update the stack
Block_release(_b);
}
//printf("after...\n");
b(); ++shouldbe;
if (var != shouldbe) {
fail("var is %d but should be %d", var, shouldbe);
}
succeed(__FILE__);
}
/* ...process new input buffer submitted from camera */
static int sview_input_process(void *data, int i, GstBuffer *buffer)
{
app_data_t *app = data;
BUG(i >= CAMERAS_NUMBER, _x("invalid camera index: %d"), i);
TRACE(DEBUG, _b("camera-%d: input buffer received"), i);
/* ...get queue access lock */
pthread_mutex_lock(&app->lock);
/* ...check if playback is enabled */
if ((app->flags & APP_FLAG_EOS) == 0)
{
/* ...place buffer into main rendering queue (take ownership) */
g_queue_push_tail(&app->render[i], buffer), gst_buffer_ref(buffer);
/* ...indicate buffer is available */
app->frames &= ~(1 << i);
/* ...schedule processing if all buffers are ready */
if ((app->frames & ((1 << CAMERAS_NUMBER) - 1)) == 0)
{
/* ...all buffers available; trigger surround-view scene processing */
window_schedule_redraw(app->window);
}
}
/* ...release queue access lock */
pthread_mutex_unlock(&app->lock);
return 0;
}
static void tst6() {
params_ref ps;
reslimit rlim;
nlsat::solver s(rlim, ps);
anum_manager & am = s.am();
nlsat::pmanager & pm = s.pm();
nlsat::assignment as(am);
nlsat::explain& ex = s.get_explain();
nlsat::var x0, x1, x2, a, b, c, d;
a = s.mk_var(false);
b = s.mk_var(false);
c = s.mk_var(false);
d = s.mk_var(false);
x0 = s.mk_var(false);
x1 = s.mk_var(false);
x2 = s.mk_var(false);
polynomial_ref p1(pm), p2(pm), p3(pm), p4(pm), p5(pm);
polynomial_ref _x0(pm), _x1(pm), _x2(pm);
polynomial_ref _a(pm), _b(pm), _c(pm), _d(pm);
_x0 = pm.mk_polynomial(x0);
_x1 = pm.mk_polynomial(x1);
_x2 = pm.mk_polynomial(x2);
_a = pm.mk_polynomial(a);
_b = pm.mk_polynomial(b);
_c = pm.mk_polynomial(c);
_d = pm.mk_polynomial(d);
p1 = (_a*(_x0^2)) + _x2 + 2;
p2 = (_b*_x1) - (2*_x2) - _x0 + 8;
nlsat::scoped_literal_vector lits(s);
lits.push_back(mk_gt(s, p1));
lits.push_back(mk_gt(s, p2));
lits.push_back(mk_gt(s, (_c*_x0) + _x2 + 1));
lits.push_back(mk_gt(s, (_d*_x0) - _x1 + 5*_x2));
scoped_anum zero(am), one(am), two(am);
am.set(zero, 0);
am.set(one, 1);
am.set(two, 2);
as.set(0, one);
as.set(1, one);
as.set(2, two);
as.set(3, two);
as.set(4, two);
as.set(5, one);
as.set(6, one);
s.set_rvalues(as);
project(s, ex, x0, 2, lits.c_ptr());
project(s, ex, x1, 3, lits.c_ptr());
project(s, ex, x2, 3, lits.c_ptr());
project(s, ex, x2, 2, lits.c_ptr());
project(s, ex, x2, 4, lits.c_ptr());
project(s, ex, x2, 3, lits.c_ptr()+1);
}
const bool XG_TextBox::Load(XG_Container* handle){
XG_Component::Load(handle);
this->Set_Size(this->w,this->h);
Texture _b(1,this->data.Get_Font()->Get_H_Font());
Image _render(_b);
this->cursore=_render;
return this->UpDate_Render();
}
/**
* set Bathymetry b in all grid cells (incl. ghost/boundary layers)
* using the specified bathymetry function;
* bathymetry source terms are re-computed
*/
void SWE_Block::setBathymetry(float (*_b)(float, float)) {
for(int i=0; i<nx+2*nghosts; i++)
for(int j=0; j<ny+2*nghosts; j++)
b[i][j] = _b(offsetX + (i-nghosts+0.5f)*dx, offsetY + (j-nghosts+0.5f)*dy);
synchBathymetryAfterWrite();
}
/**
* set Bathymetry b in all grid cells (incl. ghost/boundary layers)
* using the specified bathymetry function;
* bathymetry source terms are re-computed
*/
void SWE_Block::setBathymetry(float (*_b)(float, float)) {
for(int i=0; i<=nx+1; i++)
for(int j=0; j<=ny+1; j++)
b[i][j] = _b(offsetX + (i-0.5f)*dx, offsetY + (j-0.5f)*dy);
synchBathymetryAfterWrite();
}
void SWE::setBathymetry(float(*_b)(float, float))
{
#pragma omp parallel for
for (int i = 0; i < nx + 2; i++)
for (int j = 0; j < nx + 2; j++)
b[li(nx + 2, i, j)] = _b((i - 0.5f) * dx, (j - 0.5f) * dy);
computeBathymetrySources();
}
/// @brief Draw subtitles
/// @param frame
/// @param time
/// @return
///
void LibassSubtitlesProvider::DrawSubtitles(AegiVideoFrame &frame,double time) {
// Set size
ass_set_frame_size(ass_renderer, frame.w, frame.h);
// Get frame
ASS_Image* img = ass_render_frame(ass_renderer, ass_track, int(time * 1000), NULL);
// libass actually returns several alpha-masked monochrome images.
// Here, we loop through their linked list, get the colour of the current, and blend into the frame.
// This is repeated for all of them.
while (img) {
// Get colours
unsigned int opacity = 255 - ((unsigned int)_a(img->color));
unsigned int r = (unsigned int)_r(img->color);
unsigned int g = (unsigned int)_g(img->color);
unsigned int b = (unsigned int) _b(img->color);
// Prepare copy
int src_stride = img->stride;
int dst_stride = frame.pitch;
const unsigned char *src = img->bitmap;
unsigned char *dst = frame.data;
if (frame.flipped) {
dst += dst_stride * (frame.h - 1);
dst_stride *= -1;
}
dst += (img->dst_y * dst_stride + img->dst_x * 4);
// Copy image to destination frame
for (int y = 0; y < img->h; y++) {
unsigned char *dstp = dst;
for (int x = 0; x < img->w; ++x) {
unsigned int k = ((unsigned)src[x]) * opacity / 255;
unsigned int ck = 255 - k;
*dstp = (k * b + ck * *dstp) / 255;
++dstp;
*dstp = (k * g + ck * *dstp) / 255;
++dstp;
*dstp = (k * r + ck * *dstp) / 255;
++dstp;
++dstp;
}
dst += dst_stride;
src += src_stride;
}
// Next image
img = img->next;
}
}
/* ...buffer completion hook (tbd - need that at all?) */
static void __objdet_buffer_release(void *cdata, void *cookie)
{
GstBuffer *buffer = cookie;
TRACE(DEBUG, _b("buffer %p released by engine (count=%d)"), buffer, GST_MINI_OBJECT_REFCOUNT(buffer));
/* ...release buffer handle */
gst_buffer_unref(buffer);
}
/* ...buffer allocation from frontal camera (object detection engine) */
static int objdet_input_alloc(void *data, GstBuffer *buffer)
{
app_data_t *app = data;
vsink_meta_t *vmeta = gst_buffer_get_vsink_meta(buffer);
int w = vmeta->width, h = vmeta->height;
objdet_meta_t *ometa;
if (app->f_width)
{
/* ...verify buffer dimensions are valid */
CHK_ERR(w == app->f_width && h == app->f_height, -EINVAL);
}
else
{
int W = window_get_width(app->window);
int H = window_get_height(app->window);
/* ...check dimensions are valid */
CHK_ERR(w && h, -EINVAL);
/* ...set buffer dimensions */
app->f_width = w, app->f_height = h;
/* ...initialize object detection engine */
CHK_ERR(app->od = objdet_engine_init(&objdet_callback, app, w, h, __pixfmt_yuv_bpp(vmeta->format), app->od_cfg), -errno);
/* ...create a viewport for data visualization */
texture_scale_to_window(&app->view, app->window, w, h, &app->matrix);
//texture_set_view_scale(&app->view, 0, 0, W, H, W, H, w, h);
/* ...create transformation matrix */
if (0)
{
cairo_matrix_t *m = &app->matrix;
m->xx = (double) W / w, m->xy = 0, m->x0 = 0;
m->yx = 0, m->yy = (double) H / h, m->y0 = 0;
}
}
/* ...allocate texture to wrap the buffer */
CHK_ERR(vmeta->priv = texture_create(w, h, vmeta->plane, vmeta->format), -errno);
/* ...add custom buffer metadata */
CHK_ERR(ometa = gst_buffer_add_objdet_meta(buffer), -(errno = ENOMEM));
CHK_ERR(ometa->buf = texture_map(vmeta->priv, CL_MEM_READ_ONLY), -errno);
GST_META_FLAG_SET(ometa, GST_META_FLAG_POOLED);
/* ...add custom destructor to the buffer */
gst_mini_object_weak_ref(GST_MINI_OBJECT(buffer), __destroy_od_texture, app);
TRACE(INFO, _b("front-camera input buffer %p allocated (%p)"), buffer, ometa->buf);
return 0;
}
