intel_xvmc.c

显驱动 Intel英特尔G45G43G41G35G33G31G965Q963Q965GM965系列显卡最新X.Org驱动2.4.0版For Linux

        return BadValue;
    }

    strncpy(xvmc_driver->busID, curBusID, 20);
    xvmc_driver->busID[20] = '\0';
    XFree(curBusID);

    /* Get magic number */
    drmGetMagic(xvmc_driver->fd, &magic);
    // context->flags = (unsigned long)magic;

    if (!uniDRIAuthConnection(display, screen, magic)) {
	XVMC_ERR("[XvMC]: X server did not allow DRI. Check permissions.");
	xvmc_driver = NULL;
	XFree(priv_data);
        return BadAlloc;
    }

    /*
     * Map DRI Sarea. we always want it right?
     */
    if (drmMap(xvmc_driver->fd, xvmc_driver->hsarea,
               xvmc_driver->sarea_size, &xvmc_driver->sarea_address) < 0) {
        XVMC_ERR("Unable to map DRI SAREA.\n");
	xvmc_driver = NULL;
	XFree(priv_data);
        return BadAlloc;
    }
    pSAREA = (drm_sarea_t *)xvmc_driver->sarea_address;
    xvmc_driver->driHwLock = (drmLock *)&pSAREA->lock;
    pthread_mutex_init(&xvmc_driver->ctxmutex, NULL);

    /* context_id is alloc in _xvmc_create_context */
    if (!uniDRICreateContext(display, screen, DefaultVisual(display, screen),
			     context->context_id,
                             &intel_ctx->hw_context)) {
        XVMC_ERR("Could not create DRI context for xvmc ctx %d.",
		 (int)context->context_id);
	XFree(priv_data);
        context->privData = NULL;
        drmUnmap(xvmc_driver->sarea_address, xvmc_driver->sarea_size);
        return BadAlloc;
    }

    /* call driver hook.
     * driver hook should free priv_data after return if success.*/
    ret = (xvmc_driver->create_context)(display, context, priv_count, priv_data);
    if (ret) {
	XVMC_ERR("driver create context failed\n");
	XFree(priv_data);
	drmUnmap(xvmc_driver->sarea_address, xvmc_driver->sarea_size);
	return ret;
    }

    intelInitBatchBuffer();

    intel_xvmc_dump_open();

    return Success;
}

/*
 * Function: XvMCDestroyContext
 * Description: Destorys the specified context.
 *
 * Arguments:
 *   display - Specifies the connection to the server.
 *   context - The context to be destroyed.
 *
 */
Status XvMCDestroyContext(Display *display, XvMCContext *context)
{
    Status ret;
    int screen = DefaultScreen(display);

    if (!display || !context)
        return XvMCBadContext;

    ret = (xvmc_driver->destroy_context)(display, context);
    if (ret) {
	XVMC_ERR("destroy context fail\n");
	return ret;
    }

    uniDRIDestroyContext(display, screen, context->context_id);
    intel_xvmc_free_context(context->context_id);

    ret = _xvmc_destroy_context(display, context);
    if (ret != Success) {
	XVMC_ERR("_xvmc_destroy_context fail\n");
	return ret;
    }

    if (xvmc_driver->num_ctx == 0) {
	uniDRICloseConnection(display, screen);

	pthread_mutex_destroy(&xvmc_driver->ctxmutex);

	drmUnmap(xvmc_driver->sarea_address, xvmc_driver->sarea_size);

	if (xvmc_driver->fd >= 0)
	    drmClose(xvmc_driver->fd);
	xvmc_driver->fd = -1;

	intelFiniBatchBuffer();

	intel_xvmc_dump_close();
    }
    return Success;
}

/*
 * Function: XvMCCreateSurface
 */
Status XvMCCreateSurface(Display *display, XvMCContext *context, XvMCSurface *surface)
{
    Status ret;
    int priv_count;
    CARD32 *priv_data;
    intel_xvmc_surface_ptr intel_surf = NULL;

    if (!display || !context)
        return XvMCBadContext;

    if (!surface)
	return XvMCBadSurface;

    intel_surf = intel_xvmc_new_surface(display);
    if (!intel_surf)
	return BadAlloc;
    intel_surf->surface = surface;

    if ((ret = _xvmc_create_surface(display, context, surface,
                                    &priv_count, &priv_data))) {
        XVMC_ERR("Unable to create XvMCSurface.");
        return ret;
    }

    intel_surf->image = XvCreateImage(display, context->port,
	    FOURCC_XVMC, (char *)&intel_surf->data, surface->width,
	    surface->height);
    if (!intel_surf->image) {
	XVMC_ERR("Can't create XvImage for surface\n");
	_xvmc_destroy_surface(display, surface);
	intel_xvmc_free_surface(surface->surface_id);
	return BadAlloc;
    }
    intel_surf->image->data = (char *)&intel_surf->data;

    ret = (xvmc_driver->create_surface)(display, context, surface, priv_count,
	    priv_data);
    if (ret) {
	XVMC_ERR("create surface failed\n");
	return ret;
    }

    return Success;
}


/*
 * Function: XvMCDestroySurface
 */
Status XvMCDestroySurface(Display *display, XvMCSurface *surface)
{
    intel_xvmc_surface_ptr intel_surf;

    if (!display || !surface)
        return XvMCBadSurface;

    intel_surf = intel_xvmc_find_surface(surface->surface_id);
    if (!intel_surf)
	return XvMCBadSurface;

    XFree(intel_surf->image);
    if (intel_surf->gc_init)
	XFreeGC(display, intel_surf->gc);
    intel_xvmc_free_surface(surface->surface_id);

    (xvmc_driver->destroy_surface)(display, surface);

    _xvmc_destroy_surface(display, surface);

    return Success;
}

/*
 * Function: XvMCCreateBlocks
 */
Status XvMCCreateBlocks(Display *display, XvMCContext *context,
                        unsigned int num_blocks,
                        XvMCBlockArray *block)
{
    if (!display || !context || !num_blocks || !block)
        return BadValue;

    memset(block, 0, sizeof(XvMCBlockArray));

    if (!(block->blocks = (short *)malloc(num_blocks << 6 * sizeof(short))))
        return BadAlloc;

    block->num_blocks = num_blocks;
    block->context_id = context->context_id;
    block->privData = NULL;

    return Success;
}

/*
 * Function: XvMCDestroyBlocks
 */
Status XvMCDestroyBlocks(Display *display, XvMCBlockArray *block)
{
    if (!display || !block)
        return BadValue;

    if (block->blocks)
        free(block->blocks);

    block->context_id = 0;
    block->num_blocks = 0;
    block->blocks = NULL;
    block->privData = NULL;

    return Success;
}

/*
 * Function: XvMCCreateMacroBlocks
 */
Status XvMCCreateMacroBlocks(Display *display, XvMCContext *context,
                             unsigned int num_blocks,
                             XvMCMacroBlockArray *blocks)
{
    if (!display || !context || !blocks || !num_blocks)
        return BadValue;

    memset(blocks, 0, sizeof(XvMCMacroBlockArray));
    blocks->macro_blocks = (XvMCMacroBlock *)malloc(num_blocks * sizeof(XvMCMacroBlock));

    if (!blocks->macro_blocks)
        return BadAlloc;

    blocks->num_blocks = num_blocks;
    blocks->context_id = context->context_id;
    blocks->privData = NULL;

    return Success;
}

/*
 * Function: XvMCDestroyMacroBlocks
 */
Status XvMCDestroyMacroBlocks(Display *display, XvMCMacroBlockArray *block)
{
    if (!display || !block)
        return BadValue;
    if (block->macro_blocks)
        free(block->macro_blocks);

    block->context_id = 0;
    block->num_blocks = 0;
    block->macro_blocks = NULL;
    block->privData = NULL;

    return Success;
}

/*
 * Function: XvMCRenderSurface
 *
 * Description: This function does the actual HWMC. Given a list of
 *  macroblock structures it dispatched the hardware commands to execute
 *  them.
 */
Status XvMCRenderSurface(Display *display, XvMCContext *context,
                         unsigned int picture_structure,
                         XvMCSurface *target_surface,
                         XvMCSurface *past_surface,
                         XvMCSurface *future_surface,
                         unsigned int flags,
                         unsigned int num_macroblocks,
                         unsigned int first_macroblock,
                         XvMCMacroBlockArray *macroblock_array,
                         XvMCBlockArray *blocks)
{
    Status ret;

    if (!display || !context) {
        XVMC_ERR("Invalid Display, Context or Target!");
        return XvMCBadContext;
    }
    if (!target_surface)
	return XvMCBadSurface;

    intel_xvmc_dump_render(context, picture_structure, target_surface,
	    past_surface, future_surface, flags, num_macroblocks,
	    first_macroblock, macroblock_array, blocks);

    ret = (xvmc_driver->render_surface)(display, context, picture_structure,
	    target_surface, past_surface, future_surface, flags,
	    num_macroblocks, first_macroblock, macroblock_array,
	    blocks);

    if (ret) {
	XVMC_ERR("render surface fail\n");
	return ret;
    }
    return Success;
}

/*
 * Function: XvMCPutSurface
 *
 * Description:
 * Arguments:
 *  display: Connection to X server
 *  surface: Surface to be displayed
 *  draw: X Drawable on which to display the surface
 *  srcx: X coordinate of the top left corner of the region to be
 *          displayed within the surface.
 *  srcy: Y coordinate of the top left corner of the region to be
 *          displayed within the surface.
 *  srcw: Width of the region to be displayed.
 *  srch: Height of the region to be displayed.
 *  destx: X cordinate of the top left corner of the destination region
 *         in the drawable coordinates.
 *  desty: Y cordinate of the top left corner of the destination region
 *         in the drawable coordinates.
 *  destw: Width of the destination region.
 *  desth: Height of the destination region.
 *  flags: One or more of the following.
 *	XVMC_TOP_FIELD - Display only the Top field of the surface.
 *	XVMC_BOTTOM_FIELD - Display only the Bottom Field of the surface.
 *	XVMC_FRAME_PICTURE - Display both fields or frame.
 */
Status XvMCPutSurface(Display *display,XvMCSurface *surface,
                      Drawable draw, short srcx, short srcy,
                      unsigned short srcw, unsigned short srch,
                      short destx, short desty,
                      unsigned short destw, unsigned short desth,
                      int flags)
{
    Status ret = Success;
    XvMCContext *context;
    intel_xvmc_context_ptr intel_ctx;
    intel_xvmc_surface_ptr intel_surf;

    if (!display || !surface)
        return XvMCBadSurface;

    intel_ctx = intel_xvmc_find_context(surface->context_id);
    intel_surf = intel_xvmc_find_surface(surface->surface_id);
    if (!intel_ctx || !intel_surf)
	return XvMCBadSurface;
    context = intel_ctx->context;

    if (intel_surf->gc_init == FALSE) {
	intel_surf->gc = XCreateGC(display, draw, 0, NULL);
	intel_surf->gc_init = TRUE;
    } else if (draw != intel_surf->last_draw) {
	XFreeGC(display, intel_surf->gc);
	intel_surf->gc = XCreateGC(display, draw, 0, NULL);
    }
    intel_surf->last_draw = draw;

    /* fill intel_surf->data */
    ret = (xvmc_driver->put_surface)(display, surface, draw, srcx, srcy,
	    srcw, srch, destx, desty, destw, desth, flags, &intel_surf->data);
    if (ret) {
	XVMC_ERR("put surface fail\n");
	return ret;
    }

    ret = XvPutImage(display, context->port, draw, intel_surf->gc,
	    intel_surf->image, srcx, srcy, srcw, srch, destx, desty,
	    destw, desth);

    return ret;
}

/*
 * Function: XvMCSyncSurface
 * Arguments:
 *   display - Connection to the X server
 *   surface - The surface to synchronize
 */