自学教程：C++ vcos_log_trace函数代码示例

void platform_get_dimensions(EGLDisplay dpy, EGLNativeWindowType win,      uint32_t *width, uint32_t *height, uint32_t *swapchain_count){   Window w = (Window) win;   XWindowAttributes attr;   GC gc;   Status rc = XGetWindowAttributes(hacky_display, w, &attr);   // check rc is OK and if it is (vcos_assert(rc == 0);?????)   *width = attr.width;   *height = attr.height;   *swapchain_count = 0;	 /* Hackily assume if this function is called then they want to fill with GL stuff. So fill window with chromakey. */   vcos_log_trace("Calling XCreateGC %d",(int)w);	 gc = XCreateGC(hacky_display, w, 0, NULL);	 XSetForeground(hacky_display, gc, CHROMA_KEY_565);   vcos_log_trace("Calling XFillRectangle %d %dx%d",(int)w,attr.width, attr.height);	 XFillRectangle(hacky_display, w, gc, 0, 0, attr.width, attr.height);   vcos_log_trace("Calling XFreeGC");	 XFreeGC(hacky_display, gc);   vcos_log_trace("Done platform_get_dimensions");    //debugging    dump_hierarchy(attr.root, w, 0, 0);}

/** Create a new vidtex instance */static VIDTEX_T *vidtex_create(EGLNativeWindowType win){   VIDTEX_T *vt;   VCOS_STATUS_T st;   vt = vcos_calloc(1, sizeof(*vt), "vidtex");   if (vt == NULL)   {      vcos_log_trace("Memory allocation failure");      return NULL;   }   st = vcos_semaphore_create(&vt->sem_decoded, "vidtex-dec", 0);   if (st != VCOS_SUCCESS)   {      vcos_log_trace("Error creating semaphore");      goto error_ctx;   }   st = vcos_semaphore_create(&vt->sem_drawn, "vidtex-drw", 0);   if (st != VCOS_SUCCESS)   {      vcos_log_trace("Error creating semaphore");      goto error_sem1;   }   st = vcos_mutex_create(&vt->mutex, "vidtex");   if (st != VCOS_SUCCESS)   {      vcos_log_trace("Error creating semaphore");      goto error_sem2;   }   if (vidtex_gl_init(vt, win) != 0)   {      vcos_log_trace("Error initialising EGL");      goto error_mutex;   }   vt->quit = false;   vt->stop_reason = 0;   return vt;error_mutex:   vcos_mutex_delete(&vt->mutex);error_sem2:   vcos_semaphore_delete(&vt->sem_drawn);error_sem1:   vcos_semaphore_delete(&vt->sem_decoded);error_ctx:   vcos_free(vt);   return NULL;}

void *vcos_generic_blockpool_elem_from_handle(      VCOS_BLOCKPOOL_T *pool, uint32_t handle){   VCOS_BLOCKPOOL_SUBPOOL_T *subpool;   uint32_t subpool_id;   uint32_t index;   void *ret = NULL;   ASSERT_POOL(pool);   vcos_mutex_lock(&pool->mutex);   subpool_id = VCOS_BLOCKPOOL_HANDLE_GET_SUBPOOL(handle);   if (subpool_id < pool->num_subpools)   {      index = VCOS_BLOCKPOOL_HANDLE_GET_INDEX(handle);      subpool = &pool->subpools[subpool_id];      if (pool->subpools[subpool_id].magic == VCOS_BLOCKPOOL_SUBPOOL_MAGIC &&            pool->subpools[subpool_id].mem && index < subpool->num_blocks)      {         VCOS_BLOCKPOOL_HEADER_T *hdr = (VCOS_BLOCKPOOL_HEADER_T*)            ((size_t) subpool->start + (index * pool->block_size));         if (hdr->owner.subpool == subpool) /* Check block is allocated */            ret = hdr + 1;      }   }   vcos_mutex_unlock(&pool->mutex);   vcos_log_trace("%s: pool %p handle 0x%08x elem %p", VCOS_FUNCTION, pool,         handle, ret);   return ret;}

VCOS_STATUS_T vcos_generic_blockpool_extend(VCOS_BLOCKPOOL_T *pool,      VCOS_UNSIGNED num_extensions, VCOS_UNSIGNED num_blocks){   VCOS_UNSIGNED i;   ASSERT_POOL(pool);   vcos_log_trace("%s: pool %p num_extensions %d num_blocks %d",         VCOS_FUNCTION, pool, num_extensions, num_blocks);   /* Extend may only be called once */   if (pool->num_subpools > 1)      return VCOS_EACCESS;   if (num_extensions < 1 ||         num_extensions > VCOS_BLOCKPOOL_MAX_SUBPOOLS - 1)      return VCOS_EINVAL;   if (num_blocks < 1)      return VCOS_EINVAL;   pool->num_subpools += num_extensions;   pool->num_extension_blocks = num_blocks;   /* Mark these subpools as valid but unallocated */   for (i = 1; i < pool->num_subpools; ++i)   {      pool->subpools[i].magic = VCOS_BLOCKPOOL_SUBPOOL_MAGIC;      pool->subpools[i].start = NULL;      pool->subpools[i].mem = NULL;   }   return VCOS_SUCCESS;}

static voidfree_pagelist(PAGELIST_T *pagelist, int actual){	vm_page_t *pages;	unsigned int num_pages, i;	vcos_log_trace("free_pagelist - %x, %d", (unsigned int)pagelist, actual);	num_pages =		 (pagelist->length + pagelist->offset + PAGE_SIZE - 1) / PAGE_SIZE;	pages = (vm_page_t *)(pagelist->addrs + num_pages);	/* Deal with any partial cache lines (fragments) */	if (pagelist->type >= PAGELIST_READ_WITH_FRAGMENTS) {		FRAGMENTS_T *fragments =			 g_fragments_base + (pagelist->type -					PAGELIST_READ_WITH_FRAGMENTS);		int head_bytes, tail_bytes;		if (actual >= 0)		{			/* XXXBSD: might be inefficient */			void *page_address = pmap_mapdev(VM_PAGE_TO_PHYS(pages[0]), PAGE_SIZE*num_pages);			if ((head_bytes = (CACHE_LINE_SIZE - pagelist->offset) & (CACHE_LINE_SIZE - 1)) != 0) {				if (head_bytes > actual)					head_bytes = actual;				memcpy((char *)page_address +						 pagelist->offset, fragments->headbuf,						 head_bytes);			}			if ((head_bytes < actual) &&				(tail_bytes =				(pagelist->offset + actual) & (CACHE_LINE_SIZE -										1)) != 0) {				memcpy((char *)page_address + PAGE_SIZE*(num_pages - 1) +						 ((pagelist->offset + actual) & (PAGE_SIZE -									1) & ~(CACHE_LINE_SIZE - 1)),						 fragments->tailbuf, tail_bytes);			}			pmap_qremove((vm_offset_t)page_address, PAGE_SIZE*num_pages);		}		mtx_lock(&g_free_fragments_mutex);		*(FRAGMENTS_T **) fragments = g_free_fragments;		g_free_fragments = fragments;		mtx_unlock(&g_free_fragments_mutex);		sema_post(&g_free_fragments_sema);	}	for (i = 0; i < num_pages; i++) {		if (pagelist->type != PAGELIST_WRITE)			vm_page_dirty(pages[i]);	}	vm_page_unhold_pages(pages, num_pages);	free(pagelist, M_VCPAGELIST);}

void vcos_generic_blockpool_delete(VCOS_BLOCKPOOL_T *pool){   vcos_log_trace("%s: pool %p", VCOS_FUNCTION, pool);   if (pool)   {      VCOS_UNSIGNED i;      ASSERT_POOL(pool);      for (i = 0; i < pool->num_subpools; ++i)      {         VCOS_BLOCKPOOL_SUBPOOL_T *subpool = &pool->subpools[i];         ASSERT_SUBPOOL(subpool);         if (subpool->mem)         {            /* For debugging */            memset(subpool->mem,                  0xBE,                  VCOS_BLOCKPOOL_SIZE(subpool->num_blocks,                     pool->block_data_size, pool->align));            if (subpool->flags & VCOS_BLOCKPOOL_SUBPOOL_FLAG_OWNS_MEM)               vcos_free(subpool->mem);            subpool->mem = NULL;            subpool->start = NULL;         }      }      vcos_mutex_delete(&pool->mutex);      memset(pool, 0xBE, sizeof(VCOS_BLOCKPOOL_T)); /* For debugging */   }}

/** * Creates an OpenGL ES 2.X context. * @param raspitex_state A pointer to the GL preview state. * @return Zero if successful. */int raspitexutil_gl_init_2_0(RASPITEX_STATE *raspitex_state){   int rc;   const EGLint* attribs = raspitex_state->egl_config_attribs;;   const EGLint default_attribs[] =   {      EGL_RED_SIZE,   8,      EGL_GREEN_SIZE, 8,      EGL_BLUE_SIZE,  8,      EGL_ALPHA_SIZE, 8,      EGL_DEPTH_SIZE, 16,      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,      EGL_NONE   };   const EGLint context_attribs[] =   {      EGL_CONTEXT_CLIENT_VERSION, 2,      EGL_NONE   };   if (! attribs)      attribs = default_attribs;   vcos_log_trace("%s", VCOS_FUNCTION);   rc = raspitexutil_gl_common(raspitex_state, attribs, context_attribs);   if (rc != 0)      goto end;   rc = raspitexutil_create_textures(raspitex_state);end:   return rc;}

VCOS_STATUS_T vcos_generic_blockpool_create_on_heap(VCOS_BLOCKPOOL_T *pool,      VCOS_UNSIGNED num_blocks, VCOS_UNSIGNED block_size, VCOS_UNSIGNED align,      VCOS_UNSIGNED flags, const char *name){   VCOS_STATUS_T status = VCOS_SUCCESS;   size_t size = VCOS_BLOCKPOOL_SIZE(num_blocks, block_size, align);   void* mem = vcos_malloc(size, name);   vcos_log_trace("%s: num_blocks %d block_size %d name %s",         VCOS_FUNCTION, num_blocks, block_size, name);   if (! mem)      return VCOS_ENOMEM;   status = vcos_generic_blockpool_init(pool, num_blocks,         block_size, mem, size, align, flags, name);   if (status != VCOS_SUCCESS)      goto fail;   pool->subpools[0].flags |= VCOS_BLOCKPOOL_SUBPOOL_FLAG_OWNS_MEM;   return status;fail:   vcos_free(mem);   return status;}

/** * Deletes textures and EGL surfaces and context. * @param   raspitex_state  Pointer to the Raspi */void raspitexutil_gl_term(RASPITEX_STATE *raspitex_state){   vcos_log_trace("%s", VCOS_FUNCTION);   /* Delete OES textures */   glDeleteTextures(1, &raspitex_state->texture);   eglDestroyImageKHR(raspitex_state->display, raspitex_state->egl_image);   raspitex_state->egl_image = EGL_NO_IMAGE_KHR;   glDeleteTextures(1, &raspitex_state->y_texture);   eglDestroyImageKHR(raspitex_state->display, raspitex_state->y_egl_image);   raspitex_state->y_egl_image = EGL_NO_IMAGE_KHR;   glDeleteTextures(1, &raspitex_state->u_texture);   eglDestroyImageKHR(raspitex_state->display, raspitex_state->u_egl_image);   raspitex_state->u_egl_image = EGL_NO_IMAGE_KHR;   glDeleteTextures(1, &raspitex_state->v_texture);   eglDestroyImageKHR(raspitex_state->display, raspitex_state->v_egl_image);   raspitex_state->u_egl_image = EGL_NO_IMAGE_KHR;   /* Terminate EGL */   eglMakeCurrent(raspitex_state->display, EGL_NO_SURFACE,         EGL_NO_SURFACE, EGL_NO_CONTEXT);   eglDestroyContext(raspitex_state->display, raspitex_state->context);   eglDestroySurface(raspitex_state->display, raspitex_state->surface);   eglTerminate(raspitex_state->display);}

/** * Uses glReadPixels to grab the current frame-buffer contents * and returns the result in a newly allocate buffer along with * the its size. * Data is returned in BGRA format for TGA output. PPM output doesn't * require the channel order swap but would require a vflip. The TGA * format also supports alpha. The byte swap is not done in this function * to avoid blocking the GL rendering thread. * @param state Pointer to the GL preview state. * @param buffer Address of pointer to set to pointer to new buffer. * @param buffer_size The size of the new buffer in bytes (out param) * @return Zero if successful. */int raspitexutil_capture_bgra(RASPITEX_STATE *state,      uint8_t **buffer, size_t *buffer_size){   const int bytes_per_pixel = 4;   vcos_log_trace("%s: %dx%d %d", VCOS_FUNCTION,         state->width, state->height, bytes_per_pixel);   *buffer_size = state->width * state->height * bytes_per_pixel;   *buffer = calloc(*buffer_size, 1);   if (! *buffer)      goto error;   glReadPixels(0, 0, state->width, state->height, GL_RGBA,         GL_UNSIGNED_BYTE, *buffer);   if (glGetError() != GL_NO_ERROR)      goto error;   return 0;error:   *buffer_size = 0;   if (*buffer)      free(*buffer);   *buffer = NULL;   return -1;}

GL_API void GL_APIENTRY glEGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image){   CLIENT_THREAD_STATE_T *thread = CLIENT_GET_THREAD_STATE();   if (IS_OPENGLES_11_OR_20(thread)) {#if EGL_BRCM_global_image      if ((uintptr_t)image & (1u << 31)) {         GLuint global_image_id[2];         if (check_global_image_egl_image(global_image_id, image, thread, false)) {            RPC_CALL3(glGlobalImageTexture2DOES_impl,                      thread,                      GLGLOBALIMAGETEXTURE2DOES_ID,                      RPC_ENUM(target),                      RPC_UINT(global_image_id[0]),                      RPC_UINT(global_image_id[1]));         } else {            set_error(GLXX_GET_CLIENT_STATE(thread), GL_INVALID_VALUE);         }      } else {#endif         vcos_log_trace("[%s] target 0x%x image %d", __FUNCTION__, target, (uint32_t)image);         RPC_CALL2(glEGLImageTargetTexture2DOES_impl,                   thread,                   GLEGLIMAGETARGETTEXTURE2DOES_ID,                   RPC_ENUM(target),                   RPC_EGLID(image));         RPC_FLUSH(thread);#if EGL_BRCM_global_image      }#endif   }}

void *platform_tls_get(PLATFORM_TLS_T tls){   void *ret;   if (!process_attached)      /* TODO: this isn't thread safe */   {      vcos_log_trace("Attaching process");      client_process_attach();      process_attached = true;      tls = client_tls;      vc_vchi_khronos_init();   }   ret = vcos_tls_get(tls);   if (!ret)   {     /* The problem here is that on VCFW, the first notification we get that a thread       * exists at all is when it calls an arbitrary EGL function. We need to detect this       * case and initiliase the per-thread state.       *       * On Windows this gets done in DllMain.       */      client_thread_attach();      vcos_thread_at_exit(client_thread_detach, NULL);      ret = vcos_tls_get(tls);   }   return ret;}

/** Preview worker thread. * Ensures camera preview is supplied with buffers and sends preview frames to GL. * @param arg  Pointer to state. * @return NULL always. */static void *preview_worker(void *arg){    RASPITEX_STATE* state = arg;    MMAL_PORT_T *preview_port = state->preview_port;    MMAL_BUFFER_HEADER_T *buf;    MMAL_STATUS_T st;    int rc;    vcos_log_trace("%s: port %p", VCOS_FUNCTION, preview_port);    rc = state->ops.create_native_window(state);    if (rc != 0)        goto end;    rc = state->ops.gl_init(state);    if (rc != 0)        goto end;    while (state->preview_stop == 0)    {        /* Send empty buffers to camera preview port */        while ((buf = mmal_queue_get(state->preview_pool->queue)) != NULL)        {            st = mmal_port_send_buffer(preview_port, buf);            if (st != MMAL_SUCCESS)            {                vcos_log_error("Failed to send buffer to %s", preview_port->name);            }        }        /* Process returned buffers */        if (preview_process_returned_bufs(state) != 0)        {            vcos_log_error("Preview error. Exiting.");            state->preview_stop = 1;        }    }end:    /* Make sure all buffers are returned on exit */    while ((buf = mmal_queue_get(state->preview_queue)) != NULL)        mmal_buffer_header_release(buf);    /* Tear down GL */    state->ops.gl_term(state);    vcos_log_trace("Exiting preview worker");    return NULL;}

static int application_error_handler(Display *display, XErrorEvent *theEvent){   vcos_log_trace(   		"Ignoring Xlib error: error code %d request code %d/n",   		theEvent->error_code,   		theEvent->request_code) ;   return 0 ;}

/** * MMAL Callback from camera preview output port. * @param port The camera preview port. * @param buf The new preview buffer. **/static void preview_output_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buf){	RASPITEX_STATE *state = (RASPITEX_STATE*) port->userdata;	if (buf->length == 0)		{		vcos_log_trace("%s: zero-length buffer => EOS", port->name);		state->preview_stop = 1;		mmal_buffer_header_release(buf);		}	else if (buf->data == NULL)		{		vcos_log_trace("%s: zero buffer handle", port->name);		mmal_buffer_header_release(buf);		}	else		{		/* Enqueue the preview frame for rendering and return to		* avoid blocking MMAL core.		*/		//mmal_queue_put(state->preview_queue, buf);				//to handle the user not reading frames, remove and return any pre-existing ones		if(mmal_queue_length( state->preview_queue ) >= 2)			{			//fprintf(stderr, "mmal_queue_length too long/n" );						MMAL_BUFFER_HEADER_T *existing_buffer = mmal_queue_get( state->preview_queue );						if(existing_buffer)				{				mmal_buffer_header_release(existing_buffer);								if (port->is_enabled)					{					fill_port_buffer_simple( port, state->preview_pool, "preview_output_cb" );					}	// if (port->is_enabled)								}	// if(existing_buffer)			}				//add the buffer to the output queue		mmal_queue_put(state->preview_queue, buf );		}}

/* Stops the rendering loop and destroys MMAL resources * @param state  Pointer to the GL preview state. */void raspitex_stop(RASPITEX_STATE *state){    if (! state->preview_stop)    {        vcos_log_trace("Stopping GL preview");        state->preview_stop = 1;        vcos_thread_join(&state->preview_thread, NULL);    }}

/** Creates a native window for the GL surface using dispmanx * @param raspitex_state A pointer to the GL preview state. * @return Zero if successful, otherwise, -1 is returned. */int raspitexutil_create_native_window(RASPITEX_STATE *raspitex_state){   VC_DISPMANX_ALPHA_T alpha = {DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0};   VC_RECT_T src_rect = {0};   VC_RECT_T dest_rect = {0};   uint32_t disp_num = 0; // Primary   uint32_t layer_num = 0;   DISPMANX_ELEMENT_HANDLE_T elem;   DISPMANX_UPDATE_HANDLE_T update;   alpha.opacity = raspitex_state->opacity;   dest_rect.x = raspitex_state->x;   dest_rect.y = raspitex_state->y;   dest_rect.width = raspitex_state->width;   dest_rect.height = raspitex_state->height;   vcos_log_trace("%s: %d,%d,%d,%d %d,%d,0x%x,0x%x", VCOS_FUNCTION,         src_rect.x, src_rect.y, src_rect.width, src_rect.height,         dest_rect.x, dest_rect.y, dest_rect.width, dest_rect.height);   src_rect.width = dest_rect.width << 16;   src_rect.height = dest_rect.height << 16;   raspitex_state->disp = vc_dispmanx_display_open(disp_num);   if (raspitex_state->disp == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to open display handle");      goto error;   }   update = vc_dispmanx_update_start(0);   if (update == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to open update handle");      goto error;   }   elem = vc_dispmanx_element_add(update, raspitex_state->disp, layer_num,         &dest_rect, 0, &src_rect, DISPMANX_PROTECTION_NONE, &alpha, NULL,         DISPMANX_NO_ROTATE);   if (elem == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to create element handle");      goto error;   }   raspitex_state->win.element = elem;   raspitex_state->win.width = raspitex_state->width;   raspitex_state->win.height = raspitex_state->height;   vc_dispmanx_update_submit_sync(update);   raspitex_state->native_window = (EGLNativeWindowType*) &raspitex_state->win;   return 0;error:   return -1;}

/** Destroys the pools of buffers used by the GL renderer. * @param raspitex_state A pointer to the GL preview state. */void raspitexutil_destroy_native_window(RASPITEX_STATE *raspitex_state){   vcos_log_trace("%s", VCOS_FUNCTION);   if (raspitex_state->disp != DISPMANX_NO_HANDLE)   {      vc_dispmanx_display_close(raspitex_state->disp);      raspitex_state->disp = DISPMANX_NO_HANDLE;   }}

/* Initialises GL preview state and creates the dispmanx native window. * @param state Pointer to the GL preview state. * @return Zero if successful. */int raspitex_init(RASPITEX_STATE *state){   VCOS_STATUS_T status;   int rc;   vcos_init();   vcos_log_register("RaspiTex", VCOS_LOG_CATEGORY);   vcos_log_set_level(VCOS_LOG_CATEGORY,         state->verbose ? VCOS_LOG_INFO : VCOS_LOG_WARN);   vcos_log_trace("%s", VCOS_FUNCTION);   status = vcos_semaphore_create(&state->capture.start_sem,         "glcap_start_sem", 1);   if (status != VCOS_SUCCESS)      goto error;   status = vcos_semaphore_create(&state->capture.completed_sem,         "glcap_completed_sem", 0);   if (status != VCOS_SUCCESS)      goto error;   switch (state->scene_id)   {      case RASPITEX_SCENE_SQUARE:         rc = square_open(state);         break;      case RASPITEX_SCENE_MIRROR:         rc = mirror_open(state);         break;      case RASPITEX_SCENE_TEAPOT:         rc = teapot_open(state);         break;      case RASPITEX_SCENE_YUV:         rc = yuv_open(state);         break;      case RASPITEX_SCENE_SOBEL:         rc = sobel_open(state);         break;     case RASPITEXT_SCENE_BGS_SIMPLE:         rc = gl_simple_open(state);         break;	        default:         rc = -1;         break;   }   if (rc != 0)      goto error;   return 0;error:   vcos_log_error("%s: failed", VCOS_FUNCTION);   return -1;}

int32_t vc_gpuserv_init( void ){   VCHIQ_SERVICE_PARAMS_T vchiq_params;   VCOS_STATUS_T status = VCOS_ENXIO;   VCHIQ_STATUS_T vchiq_status;   vcos_once(&gpuserv_client_once, init_once);   vcos_mutex_lock(&gpuserv_client.lock);   if (gpuserv_client.refcount++ > 0)   {      /* Already initialised so nothing to do */      vcos_mutex_unlock(&gpuserv_client.lock);      return VCOS_SUCCESS;   }   vcos_log_set_level(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE);   vcos_log_register("gpuserv", VCOS_LOG_CATEGORY);   vcos_log_trace("%s: starting initialisation", VCOS_FUNCTION);   /* Initialise a VCHIQ instance */   vchiq_status = vchiq_initialise(&gpuserv_client_vchiq_instance);   if (vchiq_status != VCHIQ_SUCCESS)   {      vcos_log_error("%s: failed to initialise vchiq: %d", VCOS_FUNCTION, vchiq_status);      goto error;   }   vchiq_status = vchiq_connect(gpuserv_client_vchiq_instance);   if (vchiq_status != VCHIQ_SUCCESS)   {      vcos_log_error("%s: failed to connect to vchiq: %d", VCOS_FUNCTION, vchiq_status);      goto error;   }   memset(&vchiq_params, 0, sizeof(vchiq_params));   vchiq_params.fourcc = VCHIQ_MAKE_FOURCC('G','P','U','S');   vchiq_params.callback = gpuserv_callback;   vchiq_params.userdata = NULL;   vchiq_params.version = 1;   vchiq_params.version_min = 1;   vchiq_status = vchiq_open_service(gpuserv_client_vchiq_instance, &vchiq_params, &gpuserv_client.service);   if (vchiq_status != VCHIQ_SUCCESS)   {      vcos_log_error("%s: could not open vchiq service: %d", VCOS_FUNCTION, vchiq_status);      goto error;   }   vcos_mutex_unlock(&gpuserv_client.lock);   return 0;error:   vcos_mutex_unlock(&gpuserv_client.lock);   return -1;}

static void send_bound_pixmap(int i){   KHRN_IMAGE_WRAP_T image;   vcos_log_trace("send_bound_pixmap %d %d", i, (int)pixmap_binding[i].egl_image);   vcos_assert(i >= 0 && i < NUM_PIXMAP_BINDINGS);   vcos_assert(pixmap_binding[i].used);   platform_get_pixmap_info(pixmap_binding[i].pixmap, &image);   set_egl_image_color_data(pixmap_binding[i].egl_image, &image);   khrn_platform_release_pixmap_info(pixmap_binding[i].pixmap, &image);}

/** * MMAL Callback from camera preview output port. * @param port The camera preview port. * @param buf The new preview buffer. **/static void preview_output_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buf){    RASPITEX_STATE *state = (RASPITEX_STATE*) port->userdata;    if (buf->length == 0)    {        vcos_log_trace("%s: zero-length buffer => EOS", port->name);        state->preview_stop = 1;        mmal_buffer_header_release(buf);    }    else if (buf->data == NULL)    {        vcos_log_trace("%s: zero buffer handle", port->name);        mmal_buffer_header_release(buf);    }    else    {        /* Enqueue the preview frame for rendering and return to         * avoid blocking MMAL core.         */        mmal_queue_put(state->preview_queue, buf);    }}

/** * Starts the worker / GL renderer thread. * @pre raspitex_init was successful * @pre raspitex_configure_preview_port was successful * @param state Pointer to the GL preview state. * @return Zero on success, otherwise, -1 is returned * */int raspitex_start(RASPITEX_STATE *state){    VCOS_STATUS_T status;    vcos_log_trace("%s", VCOS_FUNCTION);    status = vcos_thread_create(&state->preview_thread, "preview-worker",                                NULL, preview_worker, state);    if (status != VCOS_SUCCESS)        vcos_log_error("%s: Failed to start worker thread %d",                       VCOS_FUNCTION, status);    return (status == VCOS_SUCCESS ? 0 : -1);}

/** Destroy all EGL images */static void vidtex_destroy_images(VIDTEX_T *vt){   VIDTEX_IMAGE_SLOT_T *slot;   for (slot = vt->slots; slot < vt->slots + vcos_countof(vt->slots); slot++)   {      slot->video_frame = NULL;      if (slot->image)      {         vcos_log_trace("Destroying EGL image %p", slot->image);         eglDestroyImageKHR(vt->display, slot->image);         slot->image = NULL;      }   }}

/** * Advances the texture and EGL image to the next MMAL buffer. * * @param display The EGL display. * @param target The EGL image target e.g. EGL_IMAGE_BRCM_MULTIMEDIA * @param mm_buf The EGL client buffer (mmal opaque buffer) that is used to * create the EGL Image for the preview texture. * @param egl_image Pointer to the EGL image to update with mm_buf. * @param texture Pointer to the texture to update from EGL image. * @return Zero if successful. */int raspitexutil_do_update_texture(EGLDisplay display, EGLenum target,      EGLClientBuffer mm_buf, GLuint *texture, EGLImageKHR *egl_image){   vcos_log_trace("%s: mm_buf %u", VCOS_FUNCTION, (unsigned) mm_buf);   GLCHK(glBindTexture(GL_TEXTURE_EXTERNAL_OES, *texture));   if (*egl_image != EGL_NO_IMAGE_KHR)   {      /* Discard the EGL image for the preview frame */      eglDestroyImageKHR(display, *egl_image);      *egl_image = EGL_NO_IMAGE_KHR;   }   *egl_image = eglCreateImageKHR(display, EGL_NO_CONTEXT, target, mm_buf, NULL);   GLCHK(glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, *egl_image));   return 0;}

/** * Writes the next GL frame-buffer to a RAW .ppm formatted file * using the specified file-handle. * @param state Pointer to the GL preview state. * @param outpt_file Output file handle for the ppm image. * @return Zero on success. */int raspitex_capture(RASPITEX_STATE *state, FILE *output_file){    int rc = 0;    uint8_t *buffer = NULL;    size_t size = 0;    vcos_log_trace("%s: state %p file %p", VCOS_FUNCTION,                   state, output_file);    if (state && output_file)    {        /* Only request one capture at a time */        vcos_semaphore_wait(&state->capture.start_sem);        state->capture.request = 1;        /* Wait for capture to start */        vcos_semaphore_wait(&state->capture.completed_sem);        /* Take ownership of the captured buffer */        buffer = state->capture.buffer;        size = state->capture.size;        state->capture.request = 0;        state->capture.buffer = 0;        state->capture.size = 0;        /* Allow another capture to be requested */        vcos_semaphore_post(&state->capture.start_sem);    }    if (size == 0 || ! buffer)    {        vcos_log_error("%s: capture failed", VCOS_FUNCTION);        rc = -1;        goto end;    }    raspitexutil_brga_to_rgba(buffer, size);    rc = write_tga(output_file, state->width, state->height, buffer, size);    fflush(output_file);end:    free(buffer);    return rc;}

void khrn_platform_bind_pixmap_to_egl_image(EGLNativePixmapType pixmap, EGLImageKHR egl_image, bool send){   int i;   for (i = 0; i < NUM_PIXMAP_BINDINGS; i++)   {      if (!pixmap_binding[i].used)      {         vcos_log_trace("khrn_platform_bind_pixmap_to_egl_image %d", i);         pixmap_binding[i].used = true;         pixmap_binding[i].pixmap = pixmap;         pixmap_binding[i].egl_image = egl_image;         pixmap_binding[i].send = send;         if(send)            send_bound_pixmap(i);         return;      }   }   vcos_assert(0);  /* Not enough NUM_PIXMAP_BINDINGS? */}

/* Destroys the pools of buffers used by the GL renderer. * @param  state Pointer to the GL preview state. */void raspitex_destroy(RASPITEX_STATE *state){   vcos_log_trace("%s", VCOS_FUNCTION);   if (state->preview_pool)   {      mmal_pool_destroy(state->preview_pool);      state->preview_pool = NULL;   }   if (state->preview_queue)   {      mmal_queue_destroy(state->preview_queue);      state->preview_queue = NULL;   }   if (state->ops.destroy_native_window)      state->ops.destroy_native_window(state);   if (state->ops.close)      state->ops.close(state);   vcos_semaphore_delete(&state->capture.start_sem);   vcos_semaphore_delete(&state->capture.completed_sem);}

uint32_t vcos_generic_blockpool_elem_to_handle(void *block){   uint32_t ret = (uint32_t)-1;   uint32_t index = (uint32_t)-1;   VCOS_BLOCKPOOL_HEADER_T *hdr = NULL;   VCOS_BLOCKPOOL_T *pool = NULL;   VCOS_BLOCKPOOL_SUBPOOL_T *subpool = NULL;   uint32_t subpool_id;   vcos_assert(block);   hdr = (VCOS_BLOCKPOOL_HEADER_T*) block - 1;   subpool = hdr->owner.subpool;   ASSERT_SUBPOOL(subpool);   pool = subpool->owner;   ASSERT_POOL(pool);   vcos_mutex_lock(&pool->mutex);   /* The handle is the index into the array of blocks combined    * with the subpool id.    */   index = ((size_t) hdr - (size_t) subpool->start) / pool->block_size;   vcos_assert(index < subpool->num_blocks);   subpool_id = ((char*) subpool - (char*) &pool->subpools[0]) /      sizeof(VCOS_BLOCKPOOL_SUBPOOL_T);   vcos_assert(subpool_id < VCOS_BLOCKPOOL_MAX_SUBPOOLS);   vcos_assert(subpool_id < pool->num_subpools);   ret = VCOS_BLOCKPOOL_HANDLE_CREATE(index, subpool_id);   vcos_log_trace("%s: index %d subpool_id %d handle 0x%08x",         VCOS_FUNCTION, index, subpool_id, ret);   vcos_mutex_unlock(&pool->mutex);   return ret;}

/** * Takes a description of shader program, compiles it and gets the locations * of uniforms and attributes. * * @param p The shader program state. * @return Zero if successful. */int raspitexutil_build_shader_program(RASPITEXUTIL_SHADER_PROGRAM_T *p){    GLint status;    int i = 0;    char log[1024];    int logLen = 0;    vcos_assert(p);    vcos_assert(p->vertex_source);    vcos_assert(p->fragment_source);    if (! (p && p->vertex_source && p->fragment_source))        goto fail;    p->vs = p->fs = 0;    p->vs = glCreateShader(GL_VERTEX_SHADER);    glShaderSource(p->vs, 1, &p->vertex_source, NULL);    glCompileShader(p->vs);    glGetShaderiv(p->vs, GL_COMPILE_STATUS, &status);    if (! status) {        glGetShaderInfoLog(p->vs, sizeof(log), &logLen, log);        vcos_log_error("Program info log %s", log);        goto fail;    }    p->fs = glCreateShader(GL_FRAGMENT_SHADER);    glShaderSource(p->fs, 1, &p->fragment_source, NULL);    glCompileShader(p->fs);    glGetShaderiv(p->fs, GL_COMPILE_STATUS, &status);    if (! status) {        glGetShaderInfoLog(p->fs, sizeof(log), &logLen, log);        vcos_log_error("Program info log %s", log);        goto fail;    }    p->program = glCreateProgram();    glAttachShader(p->program, p->vs);    glAttachShader(p->program, p->fs);    glLinkProgram(p->program);    glGetProgramiv(p->program, GL_LINK_STATUS, &status);    if (! status)    {        vcos_log_error("Failed to link shader program");        glGetProgramInfoLog(p->program, sizeof(log), &logLen, log);        vcos_log_error("Program info log %s", log);        goto fail;    }    for (i = 0; i < SHADER_MAX_ATTRIBUTES; ++i)    {        if (! p->attribute_names[i])            break;        p->attribute_locations[i] = glGetAttribLocation(p->program, p->attribute_names[i]);        if (p->attribute_locations[i] == -1)        {            vcos_log_error("Failed to get location for attribute %s",                  p->attribute_names[i]);            goto fail;        }        else {            vcos_log_trace("Attribute for %s is %d",                  p->attribute_names[i], p->attribute_locations[i]);        }    }    for (i = 0; i < SHADER_MAX_UNIFORMS; ++i)    {        if (! p->uniform_names[i])            break;        p->uniform_locations[i] = glGetUniformLocation(p->program, p->uniform_names[i]);        if (p->uniform_locations[i] == -1)        {            vcos_log_error("Failed to get location for uniform %s",                  p->uniform_names[i]);            goto fail;        }        else {            vcos_log_trace("Uniform for %s is %d",                  p->uniform_names[i], p->uniform_locations[i]);        }    }    return 0;fail:    vcos_log_error("%s: Failed to build shader program", VCOS_FUNCTION);    if (p)    {        glDeleteProgram(p->program);        glDeleteShader(p->fs);        glDeleteShader(p->vs);    }//.........这里部分代码省略.........