path: root/src/xvmc/radeon_xvmc.c

/*
 * Copyright 2008 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Author: Cooper Yuan  <cooper.yuan@amd.com>
 *
 */

#include "radeon_xvmc.h"

struct radeon_xvmc_driver *xvmc_driver_ptr = NULL;

static radeon_xvmc_context_ptr radeon_xvmc_new_context(Display *dpy)
{
    radeon_xvmc_context_ptr ret;

    ret = (radeon_xvmc_context_ptr)calloc(1, sizeof(radeon_xvmc_context_t));
    if (!ret)
        return NULL;

    ret->next = xvmc_driver_ptr->ctx_list;
    xvmc_driver_ptr->ctx_list = ret;
    xvmc_driver_ptr->num_ctx++;

    return ret;

}

static void radeon_xvmc_free_context(XID id)
{
    radeon_xvmc_context_ptr p = xvmc_driver_ptr->ctx_list;
    radeon_xvmc_context_ptr pre = p;

    while(p) 
    {
        if (p->context && p->context->context_id == id) 
        {
            if (p == xvmc_driver_ptr->ctx_list)
                xvmc_driver_ptr->ctx_list = p->next;
            else
                pre->next = p->next;
            break;
        }
        pre = p;
        p = p->next;
    }

    if (p) 
    {
        free(p);
        xvmc_driver_ptr->num_ctx--;
    }
}

radeon_xvmc_context_ptr radeon_xvmc_find_context(XID id)
{
    radeon_xvmc_context_ptr p = xvmc_driver_ptr->ctx_list;

    while(p)
    {
        if (p->context && p->context->context_id == id)
            return p;
        p = p->next;
    }
    return NULL;
}

static radeon_xvmc_surface_ptr radeon_xvmc_new_surface(Display *dpy)
{
    radeon_xvmc_surface_ptr ret;

    ret = (radeon_xvmc_surface_ptr)calloc(1, sizeof(radeon_xvmc_surface_t));
    if (!ret)
        return NULL;

    ret->next = xvmc_driver_ptr->surf_list;
    xvmc_driver_ptr->surf_list = ret;
    xvmc_driver_ptr->num_surf++;

    ret->image = NULL;
    ret->gc_init = FALSE;

    return ret;
}

static void radeon_xvmc_free_surface(XID id)
{
    radeon_xvmc_surface_ptr p = xvmc_driver_ptr->surf_list;
    radeon_xvmc_surface_ptr pre = p;

    while(p) 
    {
        if (p->surface && p->surface->surface_id == id) 
        {
            if (p == xvmc_driver_ptr->surf_list)
                xvmc_driver_ptr->surf_list = p->next;
            else
                pre->next = p->next;
            break;
        }
        pre = p;
        p = p->next;
    }

    if (p) 
    {
        free(p);
        xvmc_driver_ptr->num_surf--;
    }
}

radeon_xvmc_surface_ptr radeon_xvmc_find_surface(XID id)
{
    radeon_xvmc_surface_ptr p = xvmc_driver_ptr->surf_list;

    while(p) 
    {
        if (p->surface && p->surface->surface_id == id)
            return p;
        p = p->next;
    }
    return NULL;
}

/*
* Function: XvMCCreateContext
* Description: Create a XvMC context for the given surface parameters.
* Arguments:
*   display - Connection to the X server.
*   port - XvPortID to use as avertised by the X connection.
*   surface_type_id - Unique identifier for the Surface type.
*   width - Width of the surfaces.
*   height - Height of the surfaces.
*   flags - one or more of the following
*      XVMC_DIRECT - A direct rendered context is requested.
*
* Notes: surface_type_id and width/height parameters must match those
*        returned by XvMCListSurfaceTypes.
* Returns: Status
*/
_X_EXPORT Status XvMCCreateContext(Display *display, XvPortID port,
                         int surface_type_id, int width, int height,
                         int flags, XvMCContext *context)
{
    Status ret;
    drm_sarea_t *pSAREA;
    char *curBusID;
    CARD32 *priv_data = NULL;
    struct radeon_xvmc_common *comm;
    drm_magic_t magic;
    int major, minor;
    int priv_count;
    int isCapable;
    int event_base, error_base;
    int screen = DefaultScreen(display);
    radeon_xvmc_context_ptr radeon_ctx;
    int fd;

    /* Verify Obvious things first */
    if (!display || !context)
        return BadValue;

    if (!(flags & XVMC_DIRECT)) 
    {
        ErrorF("[XvMC]: Radeon: Indirect Rendering not supported! Using Direct.");
        return BadValue;
    }

    context->surface_type_id = surface_type_id;
    context->width           = (unsigned short)((width + 15) & ~15);
    context->height          = (unsigned short)((height + 15) & ~15);
    context->flags           = flags;
    context->port            = port;

    if (!XvMCQueryExtension(display, &event_base, &error_base)) 
    {
        ErrorF("[XvMC]: Radeon: XvMCExtension is not available!");
        return BadValue;
    }
    
    ret = XvMCQueryVersion(display, &major, &minor);
    if (ret) 
    {
        ErrorF("[XvMC]: Radeon: XvMCQueryVersion Failed, unable to determine protocol version.");
        return ret;
    }

    /*
     * Pass control to the X server to create a drm_context_t for us and
     * validate the with/height and flags.
     */
    if ((ret = _xvmc_create_context(display, context, &priv_count, &priv_data))) 
    {
        ErrorF("[XvMC]: Radeon: Unable to create XvMC Context.");
        return ret;
    }

    comm = (struct radeon_xvmc_common *)priv_data;

    if (xvmc_driver_ptr == NULL || xvmc_driver_ptr->type != comm->type) 
    {
        switch (comm->type) 
        {
          case XVMC_R500_MPEG2_MC:
            xvmc_driver_ptr = &r500_xvmc_driver;
            break;
          default:
            ErrorF("[XvMC]: Radeon: unimplemented xvmc type %d", comm->type);
            XFree(priv_data);
            priv_data = NULL;
            return BadValue;
        }
    }

    if (xvmc_driver_ptr == NULL || xvmc_driver_ptr->type != comm->type) 
    {
        ErrorF("[XvMC]: Radeon: fail to load xvmc driver for type %d\n", comm->type);
        return BadValue;
    }

    xvmc_driver_ptr->sarea_size         = comm->sarea_size;
    xvmc_driver_ptr->batchbuffer.handle = comm->batchbuffer.handle;
    xvmc_driver_ptr->batchbuffer.offset = comm->batchbuffer.offset;
    xvmc_driver_ptr->batchbuffer.size   = comm->batchbuffer.size;

    /* assign local ctx info */
    radeon_ctx = radeon_xvmc_new_context(display);
    if (!radeon_ctx) 
    {
        ErrorF("[XvMC]: Radeon XvMC context create failed\n");
        return BadAlloc;
    }
    radeon_ctx->context = context;

    ret = uniDRIQueryDirectRenderingCapable(display, screen, &isCapable);
    if (!ret || !isCapable) 
    {
        ErrorF("[XvMC]: Direct Rendering is not available on this system!");
        XFree(priv_data);
        return BadValue;
    }

    if (!uniDRIOpenConnection(display, screen, &xvmc_driver_ptr->hsarea, &curBusID)) 
    {
        ErrorF("[XvMC]: Could not open DRI connection to X server!");
        XFree(priv_data);
        return BadValue;
    }

    /* Open DRI Device */
    if((fd = drmOpen("radeon", curBusID)) < 0) 
    {
        ErrorF("[XvMC]: DRM Device could not be opened.");
        XFree(priv_data);
        XFree(curBusID);
        return BadValue;
    }

    xvmc_driver_ptr->fd = fd;

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

    /* Get magic number */
    drmGetMagic(xvmc_driver_ptr->fd, &magic);

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

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

    /* context_id is alloc in _xvmc_create_context */
    if (!uniDRICreateContext(display, screen, DefaultVisual(display, screen),
                             context->context_id,
                             &radeon_ctx->hw_context)) 
    {
        XVMC_ERR("[XvMC]: Could not create DRI context for xvmc ctx %d.",
                 (int)context->context_id);
        XFree(priv_data);
        context->privData = NULL;
        drmUnmap(xvmc_driver_ptr->sarea_address, xvmc_driver_ptr->sarea_size);
        return BadAlloc;
    }
    
    /* 
     * call driver hook.
     * driver hook should free priv_data after return if success.
     */
    ret = (xvmc_driver_ptr->create_context)(display, context, priv_count, priv_data);
    if (ret) 
    {
        ErrorF("[XvMC]: driver create context failed\n");
        XFree(priv_data);
        drmUnmap(xvmc_driver_ptr->sarea_address, xvmc_driver_ptr->sarea_size);
        return ret;
    }

    return Success;
}

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

    if (!display || !context)
        return XvMCBadContext;
    screen = DefaultScreen(display);
    ret = (xvmc_driver_ptr->destroy_context)(display, context);
    if (ret) 
    {
        ErrorF("[XvMC]: destroy context fail\n");
        return ret;
    }

    uniDRIDestroyContext(display, screen, context->context_id);
    radeon_xvmc_free_context(context->context_id);
    
    ret = _xvmc_destroy_context(display, context);
    if (ret != Success) 
    {
        ErrorF("[XvMC]: _xvmc_destroy_context fail\n");
        return ret;
    }

    if (xvmc_driver_ptr->num_ctx == 0) 
    {
        uniDRICloseConnection(display, screen);
        pthread_mutex_destroy(&xvmc_driver_ptr->ctxmutex);

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

        if (xvmc_driver_ptr->fd >= 0)
            drmClose(xvmc_driver_ptr->fd);
        xvmc_driver_ptr->fd = -1;
    }
    return Success;    
}

/*
 * Function: XvMCCreateSurface
 */
_X_EXPORT Status XvMCCreateSurface(Display *display, XvMCContext *context, XvMCSurface *surface)
{
}

/*
 * Function: XvMCDestroySurface
 */
_X_EXPORT Status XvMCDestroySurface(Display *display, XvMCSurface *surface)
{
}

/*
 * Function: XvMCCreateBlocks
 */
_X_EXPORT Status XvMCCreateBlocks(Display *display, XvMCContext *context,
                        unsigned int num_blocks,
                        XvMCBlockArray *block)
{
}

/*
 * Function: XvMCDestroyBlocks
 */
_X_EXPORT Status XvMCDestroyBlocks(Display *display, XvMCBlockArray *block)
{
}

/*
 * Function: XvMCCreateMacroBlocks
 */
_X_EXPORT Status XvMCCreateMacroBlocks(Display *display, XvMCContext *context,
                             unsigned int num_blocks,
                             XvMCMacroBlockArray *blocks)
{
}

/*
 * Function: XvMCDestroyMacroBlocks
 */
_X_EXPORT Status XvMCDestroyMacroBlocks(Display *display, XvMCMacroBlockArray *block)
{
}

/*
 * Function: XvMCRenderSurface
 *
 * Description: This function does the actual HWMC. Given a list of
 *  macroblock structures it dispatched the hardware commands to execute
 *  them.
 */
_X_EXPORT 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)
{
}

/*
 * 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.
 */
_X_EXPORT 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)
{
}

/*
 * Function: XvMCSyncSurface
 * Arguments:
 *   display - Connection to the X server
 *   surface - The surface to synchronize
 */
_X_EXPORT Status XvMCSyncSurface(Display *display, XvMCSurface *surface)
{
}

/*
 * Function: XvMCFlushSurface
 * Description:
 *   This function commits pending rendering requests to ensure that they
 *   wll be completed in a finite amount of time.
 * Arguments:
 *   display - Connection to X server
 *   surface - Surface to flush
 * Returns: Status
 */
_X_EXPORT Status XvMCFlushSurface(Display * display, XvMCSurface *surface)
{
}

/*
 * Function: XvMCGetSurfaceStatus
 * Description:
 * Arguments:
 *  display: connection to X server
 *  surface: The surface to query
 *  stat: One of the Following
 *    XVMC_RENDERING - The last XvMCRenderSurface command has not
 *                     completed.
 *    XVMC_DISPLAYING - The surface is currently being displayed or a
 *                     display is pending.
 */
_X_EXPORT Status XvMCGetSurfaceStatus(Display *display, XvMCSurface *surface, int *stat)
{
}

/*
 * Function: XvMCHideSurface
 * Description: Stops the display of a surface.
 * Arguments:
 *   display - Connection to the X server.
 *   surface - surface to be hidden.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCHideSurface(Display *display, XvMCSurface *surface)
{
}

/*
 * Function: XvMCCreateSubpicture
 * Description: This creates a subpicture by filling out the XvMCSubpicture
 *              structure passed to it and returning Success.
 * Arguments:
 *   display - Connection to the X server.
 *   context - The context to create the subpicture for.
 *   subpicture - Pre-allocated XvMCSubpicture structure to be filled in.
 *   width - of subpicture
 *   height - of subpicture
 *   xvimage_id - The id describing the XvImage format.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCCreateSubpicture(Display *display, XvMCContext *context,
                            XvMCSubpicture *subpicture,
                            unsigned short width, unsigned short height,
                            int xvimage_id)
{
}

/*
 * Function: XvMCClearSubpicture
 * Description: Clear the area of the given subpicture to "color".
 *              structure passed to it and returning Success.
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - Subpicture to clear.
 *   x, y, width, height - rectangle in the subpicture to clear.
 *   color - The data to file the rectangle with.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCClearSubpicture(Display *display, XvMCSubpicture *subpicture,
                           short x, short y,
                           unsigned short width, unsigned short height,
                           unsigned int color)
{
}

/*
 * Function: XvMCCompositeSubpicture
 * Description: Composite the XvImae on the subpicture. This composit uses
 *              non-premultiplied alpha. Destination alpha is utilized
 *              except for with indexed subpictures. Indexed subpictures
 *              use a simple "replace".
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - Subpicture to clear.
 *   image - the XvImage to be used as the source of the composite.
 *   srcx, srcy, width, height - The rectangle from the image to be used.
 *   dstx, dsty - location in the subpicture to composite the source.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCCompositeSubpicture(Display *display, XvMCSubpicture *subpicture,
                               XvImage *image,
                               short srcx, short srcy,
                               unsigned short width, unsigned short height,
                               short dstx, short dsty)
{
}

/*
 * Function: XvMCDestroySubpicture
 * Description: Destroys the specified subpicture.
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - Subpicture to be destroyed.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCDestroySubpicture(Display *display, XvMCSubpicture *subpicture)
{
    return BadValue;
}

/*
 * Function: XvMCSetSubpicturePalette
 * Description: Set the subpictures palette
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - Subpiture to set palette for.
 *   palette - A pointer to an array holding the palette data. The array
 *     is num_palette_entries * entry_bytes in size.
 * Returns: Status
 */
_X_EXPORT Status XvMCSetSubpicturePalette(Display *display, XvMCSubpicture *subpicture,
                                unsigned char *palette)
{
    return BadValue;
}

/*
 * Function: XvMCBlendSubpicture
 * Description:
 *    The behavior of this function is different depending on whether
 *    or not the XVMC_BACKEND_SUBPICTURE flag is set in the XvMCSurfaceInfo.
 *    i915 only support frontend behavior.
 *
 *    XVMC_BACKEND_SUBPICTURE not set ("frontend" behavior):
 *
 *    XvMCBlendSubpicture is a no-op in this case.
 *
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - The subpicture to be blended into the video.
 *   target_surface - The surface to be displayed with the blended subpic.
 *   source_surface - Source surface prior to blending.
 *   subx, suby, subw, subh - The rectangle from the subpicture to use.
 *   surfx, surfy, surfw, surfh - The rectangle in the surface to blend
 *      blend the subpicture rectangle into. Scaling can ocure if
 *      XVMC_SUBPICTURE_INDEPENDENT_SCALING is set.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCBlendSubpicture(Display *display, XvMCSurface *target_surface,
                           XvMCSubpicture *subpicture,
                           short subx, short suby,
                           unsigned short subw, unsigned short subh,
                           short surfx, short surfy,
                           unsigned short surfw, unsigned short surfh)
{
    return BadValue;
}

/*
 * Function: XvMCBlendSubpicture2
 * Description:
 *    The behavior of this function is different depending on whether
 *    or not the XVMC_BACKEND_SUBPICTURE flag is set in the XvMCSurfaceInfo.
 *    i915 only supports frontend blending.
 *
 *    XVMC_BACKEND_SUBPICTURE not set ("frontend" behavior):
 *
 *    XvMCBlendSubpicture2 blends the source_surface and subpicture and
 *    puts it in the target_surface.  This does not effect the status of
 *    the source surface but will cause the target_surface to query
 *    XVMC_RENDERING until the blend is completed.
 *
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - The subpicture to be blended into the video.
 *   target_surface - The surface to be displayed with the blended subpic.
 *   source_surface - Source surface prior to blending.
 *   subx, suby, subw, subh - The rectangle from the subpicture to use.
 *   surfx, surfy, surfw, surfh - The rectangle in the surface to blend
 *      blend the subpicture rectangle into. Scaling can ocure if
 *      XVMC_SUBPICTURE_INDEPENDENT_SCALING is set.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCBlendSubpicture2(Display *display,
                            XvMCSurface *source_surface,
                            XvMCSurface *target_surface,
                            XvMCSubpicture *subpicture,
                            short subx, short suby,
                            unsigned short subw, unsigned short subh,
                            short surfx, short surfy,
                            unsigned short surfw, unsigned short surfh)
{
    return BadValue;
}

/*
 * Function: XvMCSyncSubpicture
 * Description: This function blocks until all composite/clear requests on
 *              the subpicture have been complete.
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - The subpicture to synchronize
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCSyncSubpicture(Display *display, XvMCSubpicture *subpicture)
{
    return BadValue;
}

/*
 * Function: XvMCFlushSubpicture
 * Description: This function commits pending composite/clear requests to
 *              ensure that they will be completed in a finite amount of
 *              time.
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - The subpicture whos compsiting should be flushed
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCFlushSubpicture(Display *display, XvMCSubpicture *subpicture)
{
    return BadValue;
}

/*
 * Function: XvMCGetSubpictureStatus
 * Description: This function gets the current status of a subpicture
 *
 * Arguments:
 *   display - Connection to the X server.
 *   subpicture - The subpicture whos status is being queried
 *   stat - The status of the subpicture. It can be any of the following
 *          OR'd together:
 *          XVMC_RENDERING  - Last composite or clear request not completed
 *          XVMC_DISPLAYING - Suppicture currently being displayed.
 *
 * Returns: Status
 */
_X_EXPORT Status XvMCGetSubpictureStatus(Display *display, XvMCSubpicture *subpicture,
                               int *stat)
{
    return BadValue;
}

/*
 * Function: XvMCQueryAttributes
 * Description: An array of XvAttributes of size "number" is returned by
 *   this function. If there are no attributes, NULL is returned and number
 *   is set to 0. The array may be freed with xfree().
 *
 * Arguments:
 *   display - Connection to the X server.
 *   context - The context whos attributes we are querying.
 *   number - The returned number of recognized atoms
 *
 * Returns:
 *  An array of XvAttributes.
 */
_X_EXPORT XvAttribute *XvMCQueryAttributes(Display *display, XvMCContext *context,
                                 int *number)
{
    /* now XvMC has no extra attribs than Xv */
    *number = 0;
    return NULL;
}

/*
 * Function: XvMCSetAttribute
 * Description: This function sets a context-specific attribute.
 *
 * Arguments:
 *   display - Connection to the X server.
 *   context - The context whos attributes we are querying.
 *   attribute - The X atom of the attribute to be changed.
 *   value - The new value for the attribute.
 *
 * Returns:
 *  Status
 */
_X_EXPORT Status XvMCSetAttribute(Display *display, XvMCContext *context,
                        Atom attribute, int value)
{
    return Success;
}

/*
 * Function: XvMCGetAttribute
 * Description: This function queries a context-specific attribute and
 *   returns the value.
 *
 * Arguments:
 *   display - Connection to the X server.
 *   context - The context whos attributes we are querying.
 *   attribute - The X atom of the attribute to be queried
 *   value - The returned attribute value
 *
 * Returns:
 *  Status
 */
_X_EXPORT Status XvMCGetAttribute(Display *display, XvMCContext *context,
                        Atom attribute, int *value)
{
    return Success;
}