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

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;}

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 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;}

BoolephyrInitVideo(ScreenPtr pScreen){    Bool is_ok = FALSE;    KdScreenPriv(pScreen);    KdScreenInfo *screen = pScreenPriv->screen;    static EphyrXVPriv *xv_priv;    EPHYR_LOG("enter/n");    if (screen->fb.bitsPerPixel == 8) {        EPHYR_LOG_ERROR("8 bits depth not supported/n");        return FALSE;    }    if (!xv_priv) {        xv_priv = ephyrXVPrivNew();    }    if (!xv_priv) {        EPHYR_LOG_ERROR("failed to create xv_priv/n");        goto out;    }    if (!ephyrXVPrivRegisterAdaptors(xv_priv, pScreen)) {        EPHYR_LOG_ERROR("failed to register adaptors/n");        goto out;    }    is_ok = TRUE; out:    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 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;}

static intephyrPutVideo(KdScreenInfo * a_info,              DrawablePtr a_drawable,              short a_vid_x, short a_vid_y,              short a_drw_x, short a_drw_y,              short a_vid_w, short a_vid_h,              short a_drw_w, short a_drw_h,              RegionPtr a_clipping_region, pointer a_port_priv){    EphyrPortPriv *port_priv = a_port_priv;    BoxRec clipped_area, dst_box;    int result = BadImplementation;    int drw_x = 0, drw_y = 0, drw_w = 0, drw_h = 0;    EPHYR_RETURN_VAL_IF_FAIL(a_info->pScreen, BadValue);    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);    EPHYR_LOG("enter/n");    dst_box.x1 = a_drw_x;    dst_box.x2 = a_drw_x + a_drw_w;    dst_box.y1 = a_drw_y;    dst_box.y2 = a_drw_y + a_drw_h;    if (!DoSimpleClip(&dst_box,                      RegionExtents(a_clipping_region), &clipped_area)) {        EPHYR_LOG_ERROR("failed to simple clip/n");        goto out;    }    drw_x = clipped_area.x1;    drw_y = clipped_area.y1;    drw_w = clipped_area.x2 - clipped_area.x1;    drw_h = clipped_area.y2 - clipped_area.y1;    if (!ephyrHostXVPutVideo(a_info->pScreen->myNum,                             port_priv->port_number,                             a_vid_x, a_vid_y, a_vid_w, a_vid_h,                             a_drw_x, a_drw_y, a_drw_w, a_drw_h)) {        EPHYR_LOG_ERROR("ephyrHostXVPutVideo() failed/n");        goto out;    }    result = Success; out:    EPHYR_LOG("leave/n");    return result;}

static voidephyrProcessExpose(xcb_generic_event_t *xev){    xcb_expose_event_t *expose = (xcb_expose_event_t *)xev;    KdScreenInfo *screen = screen_from_window(expose->window);    EphyrScrPriv *scrpriv = screen->driver;    /* Wait for the last expose event in a series of cliprects     * to actually paint our screen.     */    if (expose->count != 0)        return;    if (scrpriv) {        hostx_paint_rect(scrpriv->screen, 0, 0, 0, 0,                         scrpriv->win_width,                         scrpriv->win_height);    } else {        EPHYR_LOG_ERROR("failed to get host screen/n");#ifdef XF86DRI        /*         * We only receive expose events when the expose event         * have be generated for a drawable that is a host X         * window managed by Xephyr. Host X windows managed by         * Xephyr exists for instance when Xephyr is asked to         * create a GL drawable in a DRI environment.         */        ephyrExposePairedWindow(expose->window);#endif                          /* XF86DRI */    }}

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 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 ;}

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;}

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 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 BoolephyrXVPrivIsAttrValueValid(KdAttributePtr a_attrs,                            int a_attrs_len,                            const char *a_attr_name,                            int a_attr_value, Bool *a_is_valid){    int i = 0;    EPHYR_RETURN_VAL_IF_FAIL(a_attrs && a_attr_name && a_is_valid, FALSE);    for (i = 0; i < a_attrs_len; i++) {        if (a_attrs[i].name && strcmp(a_attrs[i].name, a_attr_name))            continue;        if (a_attrs[i].min_value > a_attr_value ||            a_attrs[i].max_value < a_attr_value) {            *a_is_valid = FALSE;            EPHYR_LOG_ERROR("attribute was not valid/n"                            "value:%d. min:%d. max:%d/n",                            a_attr_value,                            a_attrs[i].min_value, a_attrs[i].max_value);        }        else {            *a_is_valid = TRUE;        }        return TRUE;    }    return FALSE;}

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;}

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);}

intephyrGLXQueryServerString(__GLXclientState *a_cl, GLbyte *a_pc){    int res = BadImplementation ;    ClientPtr client = a_cl->client;    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) a_pc;    xGLXQueryServerStringReply reply;    char *server_string=NULL, *buf=NULL;    int length=0 ;    EPHYR_LOG ("enter/n") ;    if (!ephyrHostGLXGetStringFromServer (req->screen,                                          req->name,                                          EPHYR_HOST_GLX_QueryServerString,                                          &server_string)) {        EPHYR_LOG_ERROR ("failed to query string from host/n") ;        goto out ;    }    EPHYR_LOG ("string: %s/n", server_string) ;    length= strlen (server_string) + 1;    reply.type = X_Reply ;    reply.sequenceNumber = client->sequence ;    reply.length = __GLX_PAD (length) >> 2 ;    reply.n = length ;    buf = calloc(reply.length << 2, 1);    if (!buf) {        EPHYR_LOG_ERROR ("failed to allocate string/n;");        return BadAlloc;    }    memcpy (buf, server_string, length);    WriteToClient(client, sz_xGLXQueryServerStringReply, (char*)&reply);    WriteToClient(client, (int)(reply.length << 2), server_string);    res = Success ;out:    EPHYR_LOG ("leave/n") ;    free(server_string) ;    server_string = NULL;    free(buf);    buf = NULL;    return res ;}

intephyrGLXQueryServerString(__GLXclientState * a_cl, GLbyte * a_pc){    int res = BadImplementation;    ClientPtr client = a_cl->client;    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) a_pc;    xGLXQueryServerStringReply reply;    char *server_string = NULL;    int length = 0;    EPHYR_LOG("enter/n");    if (!ephyrHostGLXGetStringFromServer(req->screen,                                         req->name,                                         EPHYR_HOST_GLX_QueryServerString,                                         &server_string)) {        EPHYR_LOG_ERROR("failed to query string from host/n");        goto out;    }    EPHYR_LOG("string: %s/n", server_string);    length = strlen(server_string) + 1;    reply = (xGLXQueryServerStringReply) {        .type = X_Reply,        .sequenceNumber = client->sequence,        .length = __GLX_PAD(length) >> 2,        .n = length    };    WriteToClient(client, sz_xGLXQueryServerStringReply, &reply);    WriteToClient(client, (int) (reply.length << 2), server_string);    res = Success; out:    EPHYR_LOG("leave/n");    free(server_string);    server_string = NULL;    return res;}intephyrGLXQueryServerStringSwap(__GLXclientState * a_cl, GLbyte * a_pc){    EPHYR_LOG_ERROR("not yet implemented/n");    return BadImplementation;}

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 intephyrGLXCreateContextReal(xGLXCreateContextReq * a_req, Bool a_do_swap){    int res = BadImplementation;    EphyrHostWindowAttributes host_w_attrs;    __GLX_DECLARE_SWAP_VARIABLES;    EPHYR_RETURN_VAL_IF_FAIL(a_req, BadValue);    EPHYR_LOG("enter/n");    if (a_do_swap) {        __GLX_SWAP_SHORT(&a_req->length);        __GLX_SWAP_INT(&a_req->context);        __GLX_SWAP_INT(&a_req->visual);        __GLX_SWAP_INT(&a_req->screen);        __GLX_SWAP_INT(&a_req->shareList);    }    EPHYR_LOG("context creation requested. localid:%d, "              "screen:%d, visual:%d, direct:%d/n",              (int) a_req->context, (int) a_req->screen,              (int) a_req->visual, (int) a_req->isDirect);    memset(&host_w_attrs, 0, sizeof(host_w_attrs));    if (!hostx_get_window_attributes(hostx_get_window(a_req->screen),                                     &host_w_attrs)) {        EPHYR_LOG_ERROR("failed to get host window attrs/n");        goto out;    }    EPHYR_LOG("host window visual id: %d/n", host_w_attrs.visualid);    if (!ephyrHostGLXCreateContext(a_req->screen,                                   host_w_attrs.visualid,                                   a_req->context,                                   a_req->shareList, 0,                                   a_req->isDirect, X_GLXCreateContext)) {        EPHYR_LOG_ERROR("ephyrHostGLXCreateContext() failed/n");        goto out;    }    res = Success; out:    EPHYR_LOG("leave/n");    return res;}

static BoolephyrXVPrivRegisterAdaptors(EphyrXVPriv * a_this, ScreenPtr a_screen){    KdScreenPriv(a_screen);    KdScreenInfo *screen = pScreenPriv->screen;    Bool is_ok = FALSE;    KdVideoAdaptorPtr *adaptors = NULL, *registered_adaptors = NULL;    int num_registered_adaptors = 0, i = 0, num_adaptors = 0;    EPHYR_RETURN_VAL_IF_FAIL(a_this && a_screen, FALSE);    EPHYR_LOG("enter/n");    if (!a_this->num_adaptors)        goto out;    num_registered_adaptors =        KdXVListGenericAdaptors(screen, &registered_adaptors);    num_adaptors = num_registered_adaptors + a_this->num_adaptors;    adaptors = calloc(num_adaptors, sizeof(KdVideoAdaptorPtr));    if (!adaptors) {        EPHYR_LOG_ERROR("failed to allocate adaptors tab/n");        goto out;    }    memmove(adaptors, registered_adaptors, num_registered_adaptors);    for (i = 0; i < a_this->num_adaptors; i++) {        *(adaptors + num_registered_adaptors + i) = &a_this->adaptors[i];    }    if (!KdXVScreenInit(a_screen, adaptors, num_adaptors)) {        EPHYR_LOG_ERROR("failed to register adaptors/n");        goto out;    }    EPHYR_LOG("there are  %d registered adaptors/n", num_adaptors);    is_ok = TRUE; out:    free(registered_adaptors);    registered_adaptors = NULL;    free(adaptors);    adaptors = NULL;    EPHYR_LOG("leave/n");    return is_ok;}

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 ;}

BoolephyrHostIsContextDirect(int a_ctxt_id, int *a_is_direct){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    xGLXIsDirectReq *req = NULL;    xGLXIsDirectReply reply;    int major_opcode = 0, remote_glx_ctxt_id = 0;    EPHYR_LOG("enter/n");    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_glx_ctxt_id)) {        EPHYR_LOG_ERROR("failed to get remote glx ctxt id/n");        goto out;    }    memset(&reply, 0, sizeof(reply));    /* Send the glXIsDirect request */    LockDisplay(dpy);    GetReq(GLXIsDirect, req);    req->reqType = major_opcode;    req->glxCode = X_GLXIsDirect;    req->context = remote_glx_ctxt_id;    if (!_XReply(dpy, (xReply *) &reply, 0, False)) {        EPHYR_LOG_ERROR("fail in reading reply from host/n");        UnlockDisplay(dpy);        SyncHandle();        goto out;    }    UnlockDisplay(dpy);    SyncHandle();    *a_is_direct = reply.isDirect;    is_ok = TRUE; out:    EPHYR_LOG("leave/n");    return is_ok;}

BoolephyrHostGetIntegerValue(int a_current_context_tag, int a_int, int *a_val){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    int major_opcode = 0, size = 0;    xGLXSingleReq *req = NULL;    xGLXSingleReply reply;    unsigned char *pc = NULL;    EPHYR_RETURN_VAL_IF_FAIL(a_val, FALSE);    EPHYR_LOG("enter/n");    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {        EPHYR_LOG_ERROR("failed to get major opcode/n");        goto out;    }    LockDisplay(dpy);    GetReqExtra(GLXSingle, 4, req);    req->reqType = major_opcode;    req->glxCode = X_GLsop_GetIntegerv;    req->contextTag = a_current_context_tag;    pc = ((unsigned char *) (req) + sz_xGLXSingleReq);    EPHYR_GLX_SINGLE_PUT_LONG(0, a_int);    EPHYR_GLX_SINGLE_READ_XREPLY();    EPHYR_GLX_SINGLE_GET_SIZE(size);    if (!size) {        UnlockDisplay(dpy);        SyncHandle();        EPHYR_LOG_ERROR("X_GLsop_GetIngerv failed/n");        goto out;    }    EPHYR_GLX_SINGLE_GET_LONG(a_val);    UnlockDisplay(dpy);    SyncHandle();    is_ok = TRUE; out:    EPHYR_LOG("leave/n");    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);}

static intephyrReputImage(KdScreenInfo * a_info,                DrawablePtr a_drawable,                short a_drw_x,                short a_drw_y, RegionPtr a_clipping_region, pointer a_port_priv){    EphyrPortPriv *port_priv = a_port_priv;    int result = BadImplementation;    EPHYR_RETURN_VAL_IF_FAIL(a_info->pScreen, FALSE);    EPHYR_RETURN_VAL_IF_FAIL(a_drawable && port_priv, BadValue);    EPHYR_LOG("enter/n");    if (!port_priv->image_buf_size || !port_priv->image_buf) {        EPHYR_LOG_ERROR("has null image buf in cache/n");        goto out;    }    if (!ephyrHostXVPutImage(a_info->pScreen->myNum,                             port_priv->port_number,                             port_priv->image_id,                             a_drw_x, a_drw_y,                             port_priv->drw_w, port_priv->drw_h,                             port_priv->src_x, port_priv->src_y,                             port_priv->src_w, port_priv->src_h,                             port_priv->image_width, port_priv->image_height,                             port_priv->image_buf,                             (EphyrHostBox *) RegionRects(a_clipping_region),                             RegionNumRects(a_clipping_region))) {        EPHYR_LOG_ERROR("ephyrHostXVPutImage() failed/n");        goto out;    }    result = Success; out:    EPHYR_LOG("leave/n");    return result;}

static voidephyrStopVideo(KdScreenInfo * a_info, pointer a_port_priv, Bool a_exit){    EphyrPortPriv *port_priv = a_port_priv;    EPHYR_RETURN_IF_FAIL(a_info && a_info->pScreen);    EPHYR_RETURN_IF_FAIL(port_priv);    EPHYR_LOG("enter/n");    if (!ephyrHostXVStopVideo(a_info->pScreen->myNum, port_priv->port_number)) {        EPHYR_LOG_ERROR("XvStopVideo() failed/n");    }    EPHYR_LOG("leave/n");}

static intephyrGLXGetStringReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap){    ClientPtr client=NULL ;    int context_tag=0, name=0, res=BadImplementation, length=0 ;    char *string=NULL;    __GLX_DECLARE_SWAP_VARIABLES;    EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, BadValue) ;    EPHYR_LOG ("enter/n") ;    client = a_cl->client ;    if (a_do_swap) {        __GLX_SWAP_INT (a_pc + 4);        __GLX_SWAP_INT (a_pc + __GLX_SINGLE_HDR_SIZE);    }    context_tag = __GLX_GET_SINGLE_CONTEXT_TAG (a_pc) ;    a_pc += __GLX_SINGLE_HDR_SIZE;    name = *(GLenum*)(a_pc + 0);    EPHYR_LOG ("context_tag:%d, name:%d/n", context_tag, name) ;    if (!ephyrHostGLXGetStringFromServer (context_tag,                                          name,                                          EPHYR_HOST_GLX_GetString,                                          &string)) {        EPHYR_LOG_ERROR ("failed to get string from server/n") ;        goto out ;    }    if (string) {        length = strlen (string) + 1;        EPHYR_LOG ("got string:'%s', size:%d/n", string, length) ;    } else {        EPHYR_LOG ("got string: string (null)/n") ;    }    __GLX_BEGIN_REPLY (length);    __GLX_PUT_SIZE (length);    __GLX_SEND_HEADER ();    if (a_do_swap) {        __GLX_SWAP_REPLY_SIZE ();        __GLX_SWAP_REPLY_HEADER ();    }    WriteToClient (client, length, (char *)string);    res = Success ;out:    EPHYR_LOG ("leave/n") ;    return res ;}

BoolephyrHostGLXQueryVersion(int *a_major, int *a_minor){    Bool is_ok = FALSE;    Display *dpy = hostx_get_display();    int major_opcode = 0;    xGLXQueryVersionReq *req = NULL;    xGLXQueryVersionReply reply;    EPHYR_RETURN_VAL_IF_FAIL(a_major && a_minor, FALSE);    EPHYR_LOG("enter/n");    if (glx_major) {        *a_major = glx_major;        *a_minor = glx_minor;        return TRUE;    }    if (!ephyrHostGLXGetMajorOpcode(&major_opcode)) {        EPHYR_LOG_ERROR("failed to get major opcode/n");        goto out;    }    EPHYR_LOG("major opcode: %d/n", major_opcode);    /* Send the glXQueryVersion request */    memset(&reply, 0, sizeof(reply));    LockDisplay(dpy);    GetReq(GLXQueryVersion, req);    req->reqType = major_opcode;    req->glxCode = X_GLXQueryVersion;    req->majorVersion = 2;    req->minorVersion = 1;    _XReply(dpy, (xReply *) &reply, 0, False);    UnlockDisplay(dpy);    SyncHandle();    *a_major = glx_major = reply.majorVersion;    *a_minor = glx_minor = reply.minorVersion;    EPHYR_LOG("major:%d, minor:%d/n", *a_major, *a_minor);    is_ok = TRUE; out:    EPHYR_LOG("leave/n");    return is_ok;}