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

static BoolephyrXVPrivSaveImageToPortPriv(EphyrPortPriv * a_port_priv,                               const unsigned char *a_image_buf,                               int a_image_len){    Bool is_ok = FALSE;    EPHYR_LOG("enter/n");    if (a_port_priv->image_buf_size < a_image_len) {        unsigned char *buf = NULL;        buf = realloc(a_port_priv->image_buf, a_image_len);        if (!buf) {            EPHYR_LOG_ERROR("failed to realloc image buffer/n");            goto out;        }        a_port_priv->image_buf = buf;        a_port_priv->image_buf_size = a_image_len;    }    memmove(a_port_priv->image_buf, a_image_buf, a_image_len);    is_ok = TRUE; out:    return is_ok;    EPHYR_LOG("leave/n");}

static intephyrGetPortAttribute(KdScreenInfo * a_screen_info,                      Atom a_attr_name, int *a_attr_value, pointer a_port_priv){    int res = Success, host_atom = 0;    EphyrPortPriv *port_priv = a_port_priv;    EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);    EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);    EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s/n",              port_priv->port_number,              (int) a_attr_name, NameForAtom(a_attr_name));    if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {        EPHYR_LOG_ERROR("failed to convert local atom to host atom/n");        res = BadMatch;        goto out;    }    if (!ephyrHostXVGetPortAttribute(port_priv->port_number,                                     host_atom, a_attr_value)) {        EPHYR_LOG_ERROR("failed to get port attribute/n");        res = BadMatch;        goto out;    }    res = Success; out:    EPHYR_LOG("leave/n");    return res;}

static EphyrXVPriv *ephyrXVPrivNew(void){    EphyrXVPriv *xv_priv = NULL;    EPHYR_LOG("enter/n");    xv_priv = calloc(1, sizeof(EphyrXVPriv));    if (!xv_priv) {        EPHYR_LOG_ERROR("failed to create EphyrXVPriv/n");        goto error;    }    ephyrHostXVInit();    if (!ephyrXVPrivQueryHostAdaptors(xv_priv)) {        EPHYR_LOG_ERROR("failed to query the host x for xv properties/n");        goto error;    }    if (!ephyrXVPrivSetAdaptorsHooks(xv_priv)) {        EPHYR_LOG_ERROR("failed to set xv_priv hooks/n");        goto error;    }    EPHYR_LOG("leave/n");    return xv_priv; error:    if (xv_priv) {        ephyrXVPrivDelete(xv_priv);        xv_priv = NULL;    }    return NULL;}

static voidephyrQueryBestSize(KdScreenInfo * a_info,                   Bool a_motion,                   short a_src_w,                   short a_src_h,                   short a_drw_w,                   short a_drw_h,                   unsigned int *a_prefered_w,                   unsigned int *a_prefered_h, pointer a_port_priv){    int res = 0;    EphyrPortPriv *port_priv = a_port_priv;    EPHYR_RETURN_IF_FAIL(port_priv);    EPHYR_LOG("enter/n");    res = ephyrHostXVQueryBestSize(port_priv->port_number,                                   a_motion,                                   a_src_w, a_src_h,                                   a_drw_w, a_drw_h,                                   a_prefered_w, a_prefered_h);    if (!res) {        EPHYR_LOG_ERROR("Failed to query best size/n");    }    EPHYR_LOG("leave/n");}

static intephyrQueryImageAttributes(KdScreenInfo * a_info,                          int a_id,                          unsigned short *a_w,                          unsigned short *a_h, int *a_pitches, int *a_offsets){    int image_size = 0;    EPHYR_RETURN_VAL_IF_FAIL(a_w && a_h, FALSE);    EPHYR_LOG("enter: dim (%dx%d), pitches: %p, offsets: %p/n",              *a_w, *a_h, a_pitches, a_offsets);    if (!ephyrHostXVQueryImageAttributes(s_base_port_id,                                         a_id,                                         a_w, a_h,                                         &image_size, a_pitches, a_offsets)) {        EPHYR_LOG_ERROR("EphyrHostXVQueryImageAttributes() failed/n");        goto out;    }    EPHYR_LOG("image size: %d, dim (%dx%d)/n", image_size, *a_w, *a_h); out:    EPHYR_LOG("leave/n");    return image_size;}

BoolephyrDRIGetClientDriverName(int a_screen,                            int *a_ddx_driver_major_version,                            int *a_ddx_driver_minor_version,                            int *a_ddx_driver_patch_version,                            char **a_client_driver_name){    Display *dpy = hostx_get_display();    Bool is_ok = FALSE;    EPHYR_RETURN_VAL_IF_FAIL(a_ddx_driver_major_version                             && a_ddx_driver_minor_version                             && a_ddx_driver_patch_version                             && a_client_driver_name, FALSE);    EPHYR_LOG("enter/n");    is_ok = XF86DRIGetClientDriverName(dpy, DefaultScreen(dpy),                                       a_ddx_driver_major_version,                                       a_ddx_driver_minor_version,                                       a_ddx_driver_patch_version,                                       a_client_driver_name);    EPHYR_LOG("major:%d, minor:%d, patch:%d, name:%s/n",              *a_ddx_driver_major_version,              *a_ddx_driver_minor_version,              *a_ddx_driver_patch_version, *a_client_driver_name);    EPHYR_LOG("leave:%d/n", is_ok);    return is_ok;}

BoolephyrDRIGetDrawableInfo(int a_screen,                        int a_drawable,                        unsigned int *a_index,                        unsigned int *a_stamp,                        int *a_x,                        int *a_y,                        int *a_w,                        int *a_h,                        int *a_num_clip_rects,                        drm_clip_rect_t ** a_clip_rects,                        int *a_back_x,                        int *a_back_y,                        int *a_num_back_clip_rects,                        drm_clip_rect_t ** a_back_clip_rects){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    EphyrHostWindowAttributes attrs;    EPHYR_RETURN_VAL_IF_FAIL(a_x && a_y && a_w && a_h                             && a_num_clip_rects, FALSE);    EPHYR_LOG("enter/n");    memset(&attrs, 0, sizeof(attrs));    if (!hostx_get_window_attributes(a_drawable, &attrs)) {        EPHYR_LOG_ERROR("failed to query host window attributes/n");        goto out;    }    if (!XF86DRIGetDrawableInfo(dpy, DefaultScreen(dpy), a_drawable,                                a_index, a_stamp,                                a_x, a_y,                                a_w, a_h,                                a_num_clip_rects, a_clip_rects,                                a_back_x, a_back_y,                                a_num_back_clip_rects, a_back_clip_rects)) {        EPHYR_LOG_ERROR("XF86DRIGetDrawableInfo ()/n");        goto out;    }    EPHYR_LOG("host x,y,w,h: (%d,%d,%d,%d)/n", *a_x, *a_y, *a_w, *a_h);    if (*a_num_clip_rects) {        free(*a_back_clip_rects);        *a_back_clip_rects = calloc(*a_num_clip_rects, sizeof(drm_clip_rect_t));        memmove(*a_back_clip_rects,                *a_clip_rects, *a_num_clip_rects * sizeof(drm_clip_rect_t));        *a_num_back_clip_rects = *a_num_clip_rects;    }    EPHYR_LOG("num back clip rects:%d, num clip rects:%d/n",              *a_num_clip_rects, *a_num_back_clip_rects);    *a_back_x = *a_x;    *a_back_y = *a_y;    *a_w = attrs.width;    *a_h = attrs.height;    is_ok = TRUE; out:    EPHYR_LOG("leave. index:%d, stamp:%d, x,y:(%d,%d), w,y:(%d,%d)/n",              *a_index, *a_stamp, *a_x, *a_y, *a_w, *a_h);    return is_ok;}

static intephyrGLXGetIntegervReal(__GLXclientState * a_cl, GLbyte * a_pc, Bool a_do_swap){    int res = BadImplementation;    xGLXSingleReq *const req = (xGLXSingleReq *) a_pc;    GLenum int_name;    int value = 0;    GLint answer_buf_room[200];    GLint *buf = NULL;    EPHYR_LOG("enter/n");    a_pc += __GLX_SINGLE_HDR_SIZE;    int_name = *(GLenum *) (a_pc + 0);    if (!ephyrHostGetIntegerValue(req->contextTag, int_name, &value)) {        EPHYR_LOG_ERROR("ephyrHostGetIntegerValue() failed/n");        goto out;    }    buf = __glXGetAnswerBuffer(a_cl, sizeof(value),                               answer_buf_room, sizeof(answer_buf_room), 4);    if (!buf) {        EPHYR_LOG_ERROR("failed to allocate reply buffer/n");        res = BadAlloc;        goto out;    }    __glXSendReply(a_cl->client, buf, 1, sizeof(value), GL_FALSE, 0);    res = Success; out:    EPHYR_LOG("leave/n");    return res;}

static intephyrGLXIsDirectReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap){    int res=BadImplementation;    ClientPtr client = a_cl->client;    xGLXIsDirectReq *req = (xGLXIsDirectReq *) a_pc;    xGLXIsDirectReply reply;    int is_direct=0 ;    EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, FALSE) ;    EPHYR_LOG ("enter/n") ;    memset (&reply, 0, sizeof (reply)) ;    if (!ephyrHostIsContextDirect (req->context, (int*)&is_direct)) {        EPHYR_LOG_ERROR ("ephyrHostIsContextDirect() failed/n") ;        goto out ;    }    reply.isDirect = is_direct ;    reply.length = 0;    reply.type = X_Reply;    reply.sequenceNumber = client->sequence;    WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);    res = Success ;out:    EPHYR_LOG ("leave/n") ;    return res ;}

BoolephyrHostDestroyContext(int a_ctxt_id){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    int major_opcode = 0, remote_ctxt_id = 0;    xGLXDestroyContextReq *req = NULL;    EPHYR_LOG("enter:%d/n", a_ctxt_id);    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {        EPHYR_LOG_ERROR("failed to get major opcode/n");        goto out;    }    if (!hostx_get_resource_id_peer(a_ctxt_id, &remote_ctxt_id)) {        EPHYR_LOG_ERROR("failed to get remote glx ctxt id/n");        goto out;    }    EPHYR_LOG("host context id:%d/n", remote_ctxt_id);    LockDisplay(dpy);    GetReq(GLXDestroyContext, req);    req->reqType = major_opcode;    req->glxCode = X_GLXDestroyContext;    req->context = remote_ctxt_id;    UnlockDisplay(dpy);    SyncHandle();    is_ok = TRUE; out:    EPHYR_LOG("leave/n");    return is_ok;}

BoolephyrInitScreen(ScreenPtr pScreen){    KdScreenPriv(pScreen);    KdScreenInfo *screen = pScreenPriv->screen;    EPHYR_LOG("pScreen->myNum:%d/n", pScreen->myNum);    hostx_set_screen_number(screen, pScreen->myNum);    hostx_set_win_title(screen, "(ctrl+shift grabs mouse and keyboard)");    pScreen->CreateColormap = ephyrCreateColormap;#ifdef XV    if (!ephyrNoXV) {        if (!ephyrInitVideo(pScreen)) {            EPHYR_LOG_ERROR("failed to initialize xvideo/n");        }        else {            EPHYR_LOG("initialized xvideo okay/n");        }    }#endif /*XV*/#ifdef XF86DRI    if (!ephyrNoDRI && !host_has_extension(&xcb_xf86dri_id)) {        EPHYR_LOG("host x does not support DRI. Disabling DRI forwarding/n");        ephyrNoDRI = TRUE;    }    if (!ephyrNoDRI) {        ephyrDRIExtensionInit(pScreen);        ephyrHijackGLXExtension();    }#endif    return TRUE;}

BoolephyrInitScreen(ScreenPtr pScreen){    KdScreenPriv(pScreen);    KdScreenInfo *screen = pScreenPriv->screen;    EPHYR_LOG("pScreen->myNum:%d/n", pScreen->myNum);    hostx_set_screen_number(screen, pScreen->myNum);    if (EphyrWantNoHostGrab) {        hostx_set_win_title(screen, "xephyr");    } else {        hostx_set_win_title(screen, "(ctrl+shift grabs mouse and keyboard)");    }    pScreen->CreateColormap = ephyrCreateColormap;#ifdef XV    if (!ephyrNoXV) {        if (ephyr_glamor)            ephyr_glamor_xv_init(pScreen);        else if (!ephyrInitVideo(pScreen)) {            EPHYR_LOG_ERROR("failed to initialize xvideo/n");        }        else {            EPHYR_LOG("initialized xvideo okay/n");        }    }#endif /*XV*/    return TRUE;}

static intephyrGLXMakeCurrentReal(__GLXclientState * a_cl, GLXDrawable write,                        GLXDrawable read, GLXContextTag ctx,                        GLXContextTag old_ctx, Bool a_do_swap){    int res = BadImplementation;    xGLXMakeCurrentReply reply;    DrawablePtr drawableR = NULL, drawableW = NULL;    GLXContextTag new_ctx = 0;    EPHYR_LOG("enter/n");    res = dixLookupDrawable(&drawableW, write, a_cl->client, 0, DixReadAccess);    EPHYR_RETURN_VAL_IF_FAIL(drawableW, BadValue);    EPHYR_RETURN_VAL_IF_FAIL(drawableW->pScreen, BadValue);    EPHYR_LOG("screen nummber requested:%d/n", drawableW->pScreen->myNum);    if (read != write) {        res = dixLookupDrawable(&drawableR, read, a_cl->client, 0,                                DixReadAccess);        EPHYR_RETURN_VAL_IF_FAIL(drawableR, BadValue);        EPHYR_RETURN_VAL_IF_FAIL(drawableR->pScreen, BadValue);    }    else {        drawableR = drawableW;    }    if (!ephyrHostGLXMakeCurrent(hostx_get_window(drawableW->pScreen->myNum),                                 hostx_get_window(drawableR->pScreen->myNum),                                 ctx, old_ctx, (int *) &new_ctx)) {        EPHYR_LOG_ERROR("ephyrHostGLXMakeCurrent() failed/n");        goto out;    }    reply = (xGLXMakeCurrentReply) {        .type = X_Reply,        .sequenceNumber = a_cl->client->sequence,        .length = 0,        .contextTag = new_ctx    };    if (a_do_swap) {        __GLX_DECLARE_SWAP_VARIABLES;        __GLX_SWAP_SHORT(&reply.sequenceNumber);        __GLX_SWAP_INT(&reply.length);        __GLX_SWAP_INT(&reply.contextTag);    }    WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, &reply);    res = Success; out:    EPHYR_LOG("leave/n");    return res;}intephyrGLXMakeCurrent(__GLXclientState * a_cl, GLbyte * a_pc){    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) a_pc;    return ephyrGLXMakeCurrentReal(a_cl, req->drawable, req->drawable,                                   req->context, req->oldContextTag, FALSE);}

BoolephyrDRIDestroyDrawable(int a_screen, int a_drawable){    EPHYR_LOG("enter/n");    EPHYR_LOG_ERROR("not implemented yet/n");    EPHYR_LOG("leave/n");    return FALSE;}

static intephyrGLXGetFBConfigsSGIXReal (__GLXclientState *a_cl,                              GLbyte *a_pc,                              Bool a_do_swap){    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)a_pc;    ClientPtr client = a_cl->client;    xGLXGetVisualConfigsReply reply;    int32_t *props_buf=NULL, num_visuals=0,            num_props=0, res=BadImplementation, i=0,            props_per_visual_size=0,            props_buf_size=0;    __GLX_DECLARE_SWAP_VARIABLES;    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;    EPHYR_LOG ("enter/n") ;    if (!ephyrHostGLXVendorPrivGetFBConfigsSGIX (req->screen,                                                 &num_visuals,                                                 &num_props,                                                 &props_buf_size,                                                 &props_buf)) {        EPHYR_LOG_ERROR ("ephyrHostGLXGetVisualConfigs() failed/n") ;        goto out ;    }    EPHYR_LOG ("num_visuals:%d, num_props:%d/n", num_visuals, num_props) ;    reply.numVisuals = num_visuals;    reply.numProps = num_props;    reply.length = props_buf_size >> 2;    reply.type = X_Reply;    reply.sequenceNumber = client->sequence;    if (a_do_swap) {        __GLX_SWAP_SHORT(&reply.sequenceNumber);        __GLX_SWAP_INT(&reply.length);        __GLX_SWAP_INT(&reply.numVisuals);        __GLX_SWAP_INT(&reply.numProps);        __GLX_SWAP_INT_ARRAY (props_buf, num_props) ;    }    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char*)&reply);    props_per_visual_size = props_buf_size/num_visuals ;    for (i=0; i < num_visuals; i++) {        WriteToClient (client,                       props_per_visual_size,                       &((char*)props_buf)[i*props_per_visual_size]);    }    res = Success ;out:    EPHYR_LOG ("leave/n") ;    free(props_buf) ;    props_buf = NULL ;    return res ;}

static intephyrSetPortAttribute(KdScreenInfo * a_info,                      Atom a_attr_name, int a_attr_value, pointer a_port_priv){    int res = Success, host_atom = 0;    EphyrPortPriv *port_priv = a_port_priv;    Bool is_attr_valid = FALSE;    EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor, BadMatch);    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->pAttributes, BadMatch);    EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->nAttributes, BadMatch);    EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);    EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s, attr_val:%d/n",              port_priv->port_number,              (int) a_attr_name, NameForAtom(a_attr_name), a_attr_value);    if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {        EPHYR_LOG_ERROR("failed to convert local atom to host atom/n");        res = BadMatch;        goto out;    }    if (!ephyrXVPrivIsAttrValueValid(port_priv->current_adaptor->pAttributes,                                     port_priv->current_adaptor->nAttributes,                                     NameForAtom(a_attr_name),                                     a_attr_value, &is_attr_valid)) {        EPHYR_LOG_ERROR("failed to validate attribute %s/n",                        NameForAtom(a_attr_name));        /*           res = BadMatch ;           goto out ;         */    }    if (!is_attr_valid) {        EPHYR_LOG_ERROR("attribute %s is not valid/n",                        NameForAtom(a_attr_name));        /*           res = BadMatch ;           goto out ;         */    }    if (!ephyrHostXVSetPortAttribute(port_priv->port_number,                                     host_atom, a_attr_value)) {        EPHYR_LOG_ERROR("failed to set port attribute/n");        res = BadMatch;        goto out;    }    res = Success; out:    EPHYR_LOG("leave/n");    return res;}

BoolephyrDRIAuthConnection(int a_screen, drm_magic_t a_magic){    Display *dpy = hostx_get_display();    Bool is_ok = FALSE;    EPHYR_LOG("enter/n");    is_ok = XF86DRIAuthConnection(dpy, DefaultScreen(dpy), a_magic);    EPHYR_LOG("leave. is_ok:%d/n", is_ok);    return is_ok;}

BoolephyrDRICloseConnection(int a_screen){    Display *dpy = hostx_get_display();    Bool is_ok = FALSE;    EPHYR_LOG("enter/n");    is_ok = XF86DRICloseConnection(dpy, DefaultScreen(dpy));    EPHYR_LOG("leave/n");    return is_ok;}

BoolephyrDRIDestroyContext(int a_screen, int a_context_id){    Display *dpy = hostx_get_display();    Bool is_ok = FALSE;    EPHYR_LOG("enter/n");    is_ok = XF86DRIDestroyContext(dpy, DefaultScreen(dpy), a_context_id);    EPHYR_LOG("leave:%d/n", is_ok);    return is_ok;}

intephyrGLXQueryVersion(__GLXclientState * a_cl, GLbyte * a_pc){    ClientPtr client = a_cl->client;    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;    xGLXQueryVersionReply reply;    int major, minor;    int res = BadImplementation;    EPHYR_LOG("enter/n");    major = req->majorVersion;    minor = req->minorVersion;    if (!ephyrHostGLXQueryVersion(&major, &minor)) {        EPHYR_LOG_ERROR("ephyrHostGLXQueryVersion() failed/n");        goto out;    }    EPHYR_LOG("major:%d, minor:%d/n", major, minor);    reply = (xGLXQueryVersionReply) {        .type = X_Reply,        .sequenceNumber = client->sequence,        .length = 0,        .majorVersion = major,        .minorVersion = minor    };    if (client->swapped) {        __glXSwapQueryVersionReply(client, &reply);    }    else {        WriteToClient(client, sz_xGLXQueryVersionReply, &reply);    }    res = Success; out:    EPHYR_LOG("leave/n");    return res;}intephyrGLXQueryVersionSwap(__GLXclientState * a_cl, GLbyte * a_pc){    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;    __GLX_DECLARE_SWAP_VARIABLES;    __GLX_SWAP_SHORT(&req->length);    __GLX_SWAP_INT(&req->majorVersion);    __GLX_SWAP_INT(&req->minorVersion);    return ephyrGLXQueryVersion(a_cl, a_pc);}

BoolephyrDRICreateDrawable(int a_screen,                       int a_drawable, drm_drawable_t * a_hw_drawable){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    EPHYR_LOG("enter/n");    is_ok = XF86DRICreateDrawable(dpy, DefaultScreen(dpy),                                  a_drawable, a_hw_drawable);    EPHYR_LOG("leave. is_ok:%d/n", is_ok);    return is_ok;}

/* * Xephyr - A kdrive X server thats runs in a host X window. *          Authored by Matthew Allum <[email
C++ EPHYR_LOG_ERROR函数代码示例
C++ EPETRA_CHK_ERR函数代码示例