xenocara/lib/libXvMC/wrapper/XvMCWrapper.c
2015-04-06 13:33:24 +00:00

782 lines
23 KiB
C

/*****************************************************************************
* XvMC Wrapper including the Nonstandard VLD extension.
*
* Copyright (c) 2004 The Unichrome project. All rights reserved.
*
*
* 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 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
* AUTHOR(S) OR COPYRIGHT HOLDER(S) 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: Thomas Hellström (2004)
*/
/*
* BUGS: The wrapper really should maintain one symbol table per port. This
* could possibly be impemented, To do that, the port-independent symbols need to be lifted out,
* and one would have to create a number of mapping tables:
*
* port -> symbol table
* context -> port
* surface -> port
* subpicture -> port
*
* and reference the right table when needed.
* This needs to be done only if there is a player that wants to access two displays with different
* hardware simultaneously. Not likely as of today.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <X11/Xlib.h>
#include <X11/extensions/XvMC.h>
#include <X11/extensions/XvMClib.h>
#include <X11/extensions/vldXvMC.h>
#include <dlfcn.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
typedef Bool (*XvMCQueryExtensionP) (Display *, int *, int *);
typedef Status (*XvMCQueryVersionP) (Display *, int *,int *);
typedef XvMCSurfaceInfo * (*XvMCListSurfaceTypesP)(Display *, XvPortID, int *);
typedef Status (* XvMCCreateContextP) (Display *,XvPortID,int ,int ,int ,int ,XvMCContext * );
typedef Status (*XvMCDestroyContextP) (Display *, XvMCContext * );
typedef Status (*XvMCCreateSurfaceP)(Display *,XvMCContext *,XvMCSurface *);
typedef Status (*XvMCDestroySurfaceP)(Display *, XvMCSurface *);
typedef XvImageFormatValues * (*XvMCListSubpictureTypesP) (Display *,XvPortID ,int ,int *);
typedef Status (*XvMCPutSurfaceP)(Display *,XvMCSurface *,Drawable ,short , short , unsigned short ,
unsigned short ,short ,short ,unsigned short ,unsigned short ,int );
typedef Status (*XvMCHideSurfaceP)(Display *, XvMCSurface *);
typedef Status (*XvMCCreateSubpictureP) (Display *, XvMCContext *, XvMCSubpicture *,
unsigned short, unsigned short,int);
typedef Status (*XvMCClearSubpictureP) (Display *,XvMCSubpicture *,short,short,unsigned short,unsigned short,
unsigned int);
typedef Status (*XvMCCompositeSubpictureP) (Display *, XvMCSubpicture *,XvImage *,short,short,
unsigned short, unsigned short,short,short);
typedef Status (*XvMCDestroySubpictureP) (Display *, XvMCSubpicture *);
typedef Status (*XvMCSetSubpicturePaletteP) (Display *, XvMCSubpicture *, unsigned char *);
typedef Status (*XvMCBlendSubpictureP) (Display *d,XvMCSurface *,XvMCSubpicture *,short,
short,unsigned short,unsigned short,short,short,
unsigned short,unsigned short);
typedef Status (*XvMCBlendSubpicture2P) (Display *,XvMCSurface *,XvMCSurface *,
XvMCSubpicture *,short,short,unsigned short,
unsigned short,short,short,unsigned short,
unsigned short);
typedef Status (*XvMCSyncSurfaceP) (Display *, XvMCSurface *);
typedef Status (*XvMCFlushSurfaceP) (Display *, XvMCSurface *);
typedef Status (*XvMCGetSurfaceStatusP) (Display *, XvMCSurface *, int *);
typedef Status (*XvMCRenderSurfaceP) (Display *,XvMCContext *,unsigned int,XvMCSurface *,
XvMCSurface *,XvMCSurface *,unsigned int,unsigned int,
unsigned int,XvMCMacroBlockArray *,XvMCBlockArray *);
typedef Status (*XvMCSyncSubpictureP) (Display *, XvMCSubpicture *);
typedef Status (*XvMCFlushSubpictureP) (Display *, XvMCSubpicture *);
typedef Status (*XvMCGetSubpictureStatusP) (Display *, XvMCSubpicture *, int *);
typedef Status (*XvMCCreateBlocksP) (Display *, XvMCContext *,unsigned int,XvMCBlockArray *);
typedef Status (*XvMCDestroyBlocksP) (Display *,XvMCBlockArray *);
typedef Status (*XvMCCreateMacroBlocksP) (Display *,XvMCContext *,unsigned int,
XvMCMacroBlockArray *);
typedef Status (*XvMCDestroyMacroBlocksP) (Display *,XvMCMacroBlockArray *);
typedef XvAttribute *(*XvMCQueryAttributesP) (Display *,XvMCContext *,int *);
typedef Status (*XvMCSetAttributeP) (Display *,XvMCContext *, Atom, int);
typedef Status (*XvMCGetAttributeP) (Display *,XvMCContext *, Atom, int *);
/*
* Nonstandard VLD acceleration level:
*/
typedef Status (*XvMCBeginSurfaceP) (Display *,XvMCContext *,XvMCSurface *,
XvMCSurface *,XvMCSurface *f,const XvMCMpegControl *);
typedef Status (*XvMCLoadQMatrixP) (Display *, XvMCContext *,const XvMCQMatrix *);
typedef Status (*XvMCPutSliceP)(Display *,XvMCContext *, char *,int);
typedef Status (*XvMCPutSlice2P)(Display *,XvMCContext *, char *,int, unsigned);
typedef Status (*XvMCGetDRInfoP)(Display *, XvPortID, char **, char **, int *, int *,
int *, int *);
typedef struct {
XvMCQueryExtensionP XvMCQueryExtension;
XvMCQueryVersionP XvMCQueryVersion;
XvMCListSurfaceTypesP XvMCListSurfaceTypes;
XvMCCreateContextP XvMCCreateContext;
XvMCDestroyContextP XvMCDestroyContext;
XvMCCreateSurfaceP XvMCCreateSurface;
XvMCDestroySurfaceP XvMCDestroySurface;
XvMCListSubpictureTypesP XvMCListSubpictureTypes;
XvMCPutSurfaceP XvMCPutSurface;
XvMCHideSurfaceP XvMCHideSurface;
XvMCCreateSubpictureP XvMCCreateSubpicture;
XvMCClearSubpictureP XvMCClearSubpicture;
XvMCCompositeSubpictureP XvMCCompositeSubpicture;
XvMCDestroySubpictureP XvMCDestroySubpicture;
XvMCSetSubpicturePaletteP XvMCSetSubpicturePalette;
XvMCBlendSubpictureP XvMCBlendSubpicture;
XvMCBlendSubpicture2P XvMCBlendSubpicture2;
XvMCSyncSurfaceP XvMCSyncSurface;
XvMCFlushSurfaceP XvMCFlushSurface;
XvMCGetSurfaceStatusP XvMCGetSurfaceStatus;
XvMCRenderSurfaceP XvMCRenderSurface;
XvMCSyncSubpictureP XvMCSyncSubpicture;
XvMCFlushSubpictureP XvMCFlushSubpicture;
XvMCGetSubpictureStatusP XvMCGetSubpictureStatus;
XvMCCreateBlocksP XvMCCreateBlocks;
XvMCDestroyBlocksP XvMCDestroyBlocks;
XvMCCreateMacroBlocksP XvMCCreateMacroBlocks;
XvMCDestroyMacroBlocksP XvMCDestroyMacroBlocks;
XvMCQueryAttributesP XvMCQueryAttributes;
XvMCSetAttributeP XvMCSetAttribute;
XvMCGetAttributeP XvMCGetAttribute;
/*
* Nonstandard VLD acceleration level:
*/
XvMCBeginSurfaceP XvMCBeginSurface;
XvMCLoadQMatrixP XvMCLoadQMatrix;
XvMCPutSliceP XvMCPutSlice;
XvMCPutSlice2P XvMCPutSlice2;
/*
* Driver name function.
*/
XvMCGetDRInfoP XvMCGetDRInfo;
int preInitialised;
int initialised;
int vldextension;
} XvMCWrapper;
static XvMCWrapper xW;
static int wrapperInit = 0;
static int wrapperPreInit = 0;
static void *xvhandle;
static void *handle2;
#define BUFLEN 200
#define STRS(ARG) STR(ARG)
#define STR(ARG) #ARG
#define XW_RSYM(base,handle,handle2,pointer, retval) \
do { \
register char *symerr; \
base.pointer = (pointer##P) dlsym((handle),#pointer); \
if ((symerr = dlerror()) != NULL) { \
if (!handle2) { \
fprintf(stderr,"%s\n",symerr); return retval; \
} \
base.pointer = (pointer##P) dlsym((handle2),#pointer); \
if ((symerr = dlerror()) != NULL) { \
fprintf(stderr,"%s\n",symerr); return retval; \
} \
} \
} while (0);
#define XW_RSYM2(base,handle,handle2,pointer) \
base.pointer = (pointer##P) dlsym((handle),#pointer); \
if (dlerror() != NULL) { \
base.pointer = (pointer##P) dlsym((handle2),#pointer); \
if (dlerror() != NULL) return; \
}
/*
* Try to dlopen a shared library, versionless first.
*/
static void *dlopenversion(const char *lib, const char *version, int flag)
{
void *ret;
int curLen,verLen;
char *curName;
const char *tail;
curLen = strlen(lib) + (verLen = strlen(version)) + 1;
curName = (char *) malloc(curLen * sizeof(char));
strncpy( curName, lib, curLen);
if (verLen > 1) {
if (NULL != (tail = strstr(version+1,"."))) {
strncat( curName, version, tail - version);
} else {
strncat( curName, version, verLen);
}
}
ret = dlopen(curName, flag);
free(curName);
return ret;
}
static int preInitW(Display *dpy)
{
/*
* Resolve functions that are not hw driver specific.
*/
void *handleZ = NULL;
wrapperPreInit = 1;
xW.preInitialised = 0;
xW.initialised = 0;
xvhandle = dlopenversion("libXv.so", XV_SOVERSION, RTLD_LAZY | RTLD_GLOBAL);
if (!xvhandle) {
fprintf(stderr,"XvMCWrapper: Warning! Could not open shared "
"library \"libXv.so" XV_SOVERSION "\"\nThis may cause relocation "
"errors later.\nError was: \"%s\".\n",dlerror());
}
handle2 = dlopenversion("libXvMC.so", XVMC_SOVERSION, RTLD_LAZY | RTLD_GLOBAL);
if (!handle2) {
fprintf(stderr,"XvMCWrapper: Could not load XvMC "
"library \"libXvMC.so" XVMC_SOVERSION "\". Failing\n");
fprintf(stderr,"%s\n",dlerror());
return 1;
}
XW_RSYM(xW, handle2, handleZ, XvMCQueryExtension, 1);
XW_RSYM(xW, handle2, handleZ, XvMCQueryVersion, 1);
xW.preInitialised = 1;
return 0;
}
static void initW(Display *dpy, XvPortID port)
{
char nameBuffer[BUFLEN];
void *handle;
int tmp;
char *clientName = NULL;
char *err;
FILE *configFile;
int nameLen = 0;
int major,minor,patchLevel,isLocal;
char *busID = NULL;
wrapperInit = 1;
xW.initialised = 0;
if (!wrapperPreInit)
if (preInitW( dpy )) return;
/*
* Will the DDX tell us the client driver name?
*/
xW.XvMCGetDRInfo = (XvMCGetDRInfoP)
dlsym(handle2,"XvMCGetDRInfo");
if ((err = dlerror()) == NULL) {
if (0 == xW.XvMCGetDRInfo( dpy, port, &clientName, &busID, &major,
&minor,&patchLevel, &isLocal)) {
nameLen = strlen(clientName);
XFree(busID);
if (!isLocal) {
fprintf(stderr,"XvMCWrapper: X server is not local. Cannot run XvMC.\n");
XFree(clientName);
return;
}
} else {
clientName = NULL;
}
}
if (clientName && (nameLen < BUFLEN-7) && (nameLen > 0)) {
nameLen += 3;
strncpy(nameBuffer,"lib",BUFLEN-1);
strncpy(nameBuffer+3, clientName, BUFLEN-4);
strncpy(nameBuffer + nameLen, ".so", BUFLEN-nameLen-1);
nameBuffer[BUFLEN-1] = 0;
XFree(clientName);
handle = dlopenversion(nameBuffer, XVMC_SOVERSION,RTLD_LAZY);
} else {
/*
* No. Try to obtain it from the config file.
*/
if (clientName) XFree(clientName);
configFile = fopen(STRS(XVMC_CONFIGDIR) "/XvMCConfig","r");
xW.initialised = 0;
xW.vldextension = 0;
if (NULL == configFile) {
fprintf(stderr,"XvMCWrapper: Could not open config file \"%s\".\n",
STRS(XVMC_CONFIGDIR) "/XvMCConfig");
perror("XvMCWrapper");
return;
}
if (NULL == fgets(nameBuffer, BUFLEN, configFile)) {
fclose(configFile);
fprintf(stderr,"XvMCWrapper: Could not read XvMC library name.\n");
perror("XvMCWrapper");
return;
}
fclose(configFile);
if ((tmp = strlen(nameBuffer)) == 0) {
fprintf(stderr,"XvMCWrapper: Zero length XvMC library name.\n");
fprintf(stderr,"%s\n",dlerror());
return;
}
/*
* Skip trailing newlines and garbage.
*/
while (iscntrl(nameBuffer[tmp-1])) {
nameBuffer[tmp-1] = 0;
if (--tmp == 0) {
fprintf(stderr,"XvMCWrapper: Zero length XvMC library name.\n");
return;
}
}
handle = dlopen(nameBuffer,RTLD_LAZY);
}
if (!handle) {
fprintf(stderr,"XvMCWrapper: Could not load hardware specific XvMC "
"library \"%s\".\n",nameBuffer);
fprintf(stderr,"%s\n",dlerror());
return;
}
XW_RSYM(xW, handle, handle2, XvMCListSurfaceTypes,);
XW_RSYM(xW, handle, handle2, XvMCCreateContext,);
XW_RSYM(xW, handle, handle2, XvMCDestroyContext,);
XW_RSYM(xW, handle, handle2, XvMCCreateSurface,);
XW_RSYM(xW, handle, handle2, XvMCDestroySurface,);
XW_RSYM(xW, handle, handle2, XvMCListSubpictureTypes,);
XW_RSYM(xW, handle, handle2, XvMCHideSurface,);
XW_RSYM(xW, handle, handle2, XvMCCreateSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCClearSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCCompositeSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCDestroySubpicture,);
XW_RSYM(xW, handle, handle2, XvMCSetSubpicturePalette,);
XW_RSYM(xW, handle, handle2, XvMCBlendSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCBlendSubpicture2,);
XW_RSYM(xW, handle, handle2, XvMCPutSurface,);
XW_RSYM(xW, handle, handle2, XvMCSyncSurface,);
XW_RSYM(xW, handle, handle2, XvMCFlushSurface,);
XW_RSYM(xW, handle, handle2, XvMCGetSurfaceStatus,);
XW_RSYM(xW, handle, handle2, XvMCRenderSurface,);
XW_RSYM(xW, handle, handle2, XvMCSyncSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCFlushSubpicture,);
XW_RSYM(xW, handle, handle2, XvMCGetSubpictureStatus,);
XW_RSYM(xW, handle, handle2, XvMCCreateBlocks,);
XW_RSYM(xW, handle, handle2, XvMCDestroyBlocks,);
XW_RSYM(xW, handle, handle2, XvMCCreateMacroBlocks,);
XW_RSYM(xW, handle, handle2, XvMCDestroyMacroBlocks,);
XW_RSYM(xW, handle, handle2, XvMCQueryAttributes,);
XW_RSYM(xW, handle, handle2, XvMCSetAttribute,);
XW_RSYM(xW, handle, handle2, XvMCGetAttribute,);
xW.initialised = 1;
XW_RSYM2(xW, handle, handle2, XvMCBeginSurface);
XW_RSYM(xW, handle, handle2, XvMCLoadQMatrix,);
XW_RSYM(xW, handle, handle2, XvMCPutSlice,);
XW_RSYM(xW, handle, handle2, XvMCPutSlice2,);
xW.vldextension = 1;
}
Bool XvMCQueryExtension (Display *display, int *eventBase, int *errBase)
{
if (!wrapperPreInit) preInitW( display );
if (!xW.preInitialised) return 0;
return (*xW.XvMCQueryExtension)(display, eventBase, errBase);
}
Status XvMCQueryVersion (Display *display, int *major_versionp,
int *minor_versionp)
{
if (!wrapperPreInit) preInitW( display );
if (!xW.preInitialised) return 0;
return (*xW.XvMCQueryVersion)(display, major_versionp, minor_versionp);
}
XvMCSurfaceInfo * XvMCListSurfaceTypes(Display *dpy, XvPortID port, int *num)
{
if (!wrapperInit) initW( dpy, port);
if (!xW.initialised) return NULL;
return (*xW.XvMCListSurfaceTypes)(dpy, port, num);
}
Status XvMCCreateContext (
Display *display,
XvPortID port,
int surface_type_id,
int width,
int height,
int flags,
XvMCContext * context
)
{
if (!wrapperInit) initW(display, port);
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateContext)(display, port, surface_type_id,
width, height, flags, context);
}
Status XvMCDestroyContext (Display *display, XvMCContext * context)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCDestroyContext)(display, context);
}
Status
XvMCCreateSurface(
Display *display,
XvMCContext * context,
XvMCSurface * surface
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateSurface)(display, context, surface);
}
Status XvMCDestroySurface(Display *display, XvMCSurface *surface)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCDestroySurface)(display, surface);
}
XvImageFormatValues * XvMCListSubpictureTypes (
Display * display,
XvPortID port,
int surface_type_id,
int *count_return
)
{
if (!xW.initialised) return NULL;
return (*xW.XvMCListSubpictureTypes)(display, port, surface_type_id,
count_return);
}
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
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCPutSurface)(display, surface, draw, srcx, srcy, srcw, srch,
destx, desty, destw, desth, flags);
}
Status XvMCHideSurface(Display *display, XvMCSurface *surface)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCHideSurface)(display, surface);
}
Status
XvMCCreateSubpicture (
Display *display,
XvMCContext *context,
XvMCSubpicture *subpicture,
unsigned short width,
unsigned short height,
int xvimage_id
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateSubpicture)(display, context, subpicture, width, height,
xvimage_id);
}
Status
XvMCClearSubpicture (
Display *display,
XvMCSubpicture *subpicture,
short x,
short y,
unsigned short width,
unsigned short height,
unsigned int color
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCClearSubpicture)(display, subpicture, x, y, width, height, color);
}
Status
XvMCCompositeSubpicture (
Display *display,
XvMCSubpicture *subpicture,
XvImage *image,
short srcx,
short srcy,
unsigned short width,
unsigned short height,
short dstx,
short dsty
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCCompositeSubpicture)(display, subpicture, image, srcx, srcy,
width, height, dstx, dsty);
}
Status
XvMCDestroySubpicture (Display *display, XvMCSubpicture *subpicture)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCDestroySubpicture)(display, subpicture);
}
Status
XvMCSetSubpicturePalette (
Display *display,
XvMCSubpicture *subpicture,
unsigned char *palette
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCSetSubpicturePalette)(display, subpicture, palette);
}
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
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCBlendSubpicture)(display, target_surface, subpicture,
subx, suby, subw, subh, surfx, surfy,
surfw, surfh);
}
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
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCBlendSubpicture2)(display, source_surface, target_surface, subpicture,
subx, suby, subw, subh, surfx, surfy, surfw, surfh);
}
Status XvMCSyncSurface (Display *display, XvMCSurface *surface)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCSyncSurface)(display, surface);
}
Status XvMCFlushSurface (Display *display, XvMCSurface *surface)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCFlushSurface)(display, surface);
}
Status XvMCGetSurfaceStatus (Display *display, XvMCSurface *surface, int *stat)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCGetSurfaceStatus)(display, surface, stat);
}
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
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCRenderSurface)(display, context, picture_structure, target_surface,
past_surface, future_surface, flags, num_macroblocks,
first_macroblock, macroblock_array, blocks);
}
Status XvMCSyncSubpicture (Display *display, XvMCSubpicture *subpicture)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCSyncSubpicture)(display, subpicture);
}
Status XvMCFlushSubpicture (Display *display, XvMCSubpicture *subpicture)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCFlushSubpicture)(display, subpicture);
}
Status
XvMCGetSubpictureStatus (Display *display, XvMCSubpicture *subpic, int *stat)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCGetSubpictureStatus)(display, subpic, stat);
}
Status XvMCCreateBlocks (
Display *display,
XvMCContext *context,
unsigned int num_blocks,
XvMCBlockArray *block
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateBlocks)(display, context, num_blocks, block);
}
Status XvMCDestroyBlocks (Display *display,XvMCBlockArray *block)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCDestroyBlocks)(display, block);
}
Status XvMCCreateMacroBlocks (
Display *display,
XvMCContext *context,
unsigned int num_blocks,
XvMCMacroBlockArray *blocks
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCCreateMacroBlocks)(display, context, num_blocks, blocks);
}
Status XvMCDestroyMacroBlocks (
Display *display,
XvMCMacroBlockArray *block
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCDestroyMacroBlocks)(display, block);
}
XvAttribute *
XvMCQueryAttributes (
Display *display,
XvMCContext *context,
int *number
)
{
if (!xW.initialised) return NULL;
return (*xW.XvMCQueryAttributes)(display, context, number);
}
Status
XvMCSetAttribute (
Display *display,
XvMCContext *context,
Atom attribute,
int value
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCSetAttribute)(display, context, attribute, value);
}
Status
XvMCGetAttribute (
Display *display,
XvMCContext *context,
Atom attribute,
int *value
)
{
if (!xW.initialised) return BadValue;
return (*xW.XvMCGetAttribute)(display, context, attribute, value);
}
Status XvMCBeginSurface(Display *display,
XvMCContext *context,
XvMCSurface *target_surface,
XvMCSurface *past_surface,
XvMCSurface *future_surface,
const XvMCMpegControl *control)
{
if (!xW.vldextension) return BadValue;
return (*xW.XvMCBeginSurface)(display, context, target_surface, past_surface, future_surface,
control);
}
Status XvMCLoadQMatrix(Display *display, XvMCContext *context,
const XvMCQMatrix *qmx)
{
if (!xW.vldextension) return BadValue;
return (*xW.XvMCLoadQMatrix)(display, context, qmx);
}
Status XvMCPutSlice(Display *display,XvMCContext *context,
char *slice, int nBytes)
{
if (!xW.vldextension) return BadValue;
return (*xW.XvMCPutSlice)(display, context, slice, nBytes);
}
Status XvMCPutSlice2(Display *display,XvMCContext *context,
char *slice, int nBytes, int sliceCode)
{
if (!xW.vldextension) return BadValue;
return (*xW.XvMCPutSlice2)(display, context, slice, nBytes, sliceCode);
}