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

/* * After this call, all library internal resources will be cleaned up */VAStatus vaTerminate (    VADisplay dpy){  VAStatus vaStatus = VA_STATUS_SUCCESS;  VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;  VADriverContextP old_ctx;  CHECK_DISPLAY(dpy);  old_ctx = CTX(dpy);  if (old_ctx->handle) {      vaStatus = old_ctx->vtable->vaTerminate(old_ctx);//      dlclose(old_ctx->handle);      old_ctx->handle = NULL;  }  free(old_ctx->vtable);  old_ctx->vtable = NULL;  free(old_ctx->vtable_vpp);  old_ctx->vtable_vpp = NULL;  VA_TRACE_LOG(va_TraceTerminate, dpy);  va_TraceEnd(dpy);  va_FoolEnd(dpy);  if (VA_STATUS_SUCCESS == vaStatus)      pDisplayContext->vaDestroy(pDisplayContext);  return vaStatus;}

VAStatus vaPutSurfaceBuf (    VADisplay dpy,    VASurfaceID surface,    unsigned char* data,    int* data_len,    short srcx,    short srcy,    unsigned short srcw,    unsigned short srch,    short destx,    short desty,    unsigned short destw,    unsigned short desth,    VARectangle *cliprects, /* client supplied clip list */    unsigned int number_cliprects, /* number of clip rects in the clip list */    unsigned int flags /* de-interlacing flags */){  VADriverContextP ctx;  struct VADriverVTableTPI *tpi;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);    tpi = ( struct VADriverVTableTPI *)ctx->vtable_tpi;  if (tpi && tpi->vaPutSurfaceBuf) {      return tpi->vaPutSurfaceBuf( ctx, surface, data, data_len, srcx, srcy, srcw, srch,                                  destx, desty, destw, desth, cliprects, number_cliprects, flags );  } else      return VA_STATUS_ERROR_UNIMPLEMENTED;}

VAStatus vaCreateContext (    VADisplay dpy,    VAConfigID config_id,    int picture_width,    int picture_height,    int flag,    VASurfaceID *render_targets,    int num_render_targets,    VAContextID *context		/* out */){  VADriverContextP ctx;  VAStatus vaStatus;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  vaStatus = ctx->vtable->vaCreateContext( ctx, config_id, picture_width, picture_height,                                      flag, render_targets, num_render_targets, context );  /* keep current encode/decode resoluton */  VA_TRACE_ALL(va_TraceCreateContext, dpy, config_id, picture_width, picture_height, flag, render_targets, num_render_targets, context);  return vaStatus;}

VAStatus vaCreateBuffer (    VADisplay dpy,    VAContextID context,	/* in */    VABufferType type,		/* in */    unsigned int size,		/* in */    unsigned int num_elements,	/* in */    void *data,			/* in */    VABufferID *buf_id		/* out */){  VADriverContextP ctx;  VAStatus vaStatus;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  VA_FOOL_FUNC(va_FoolCreateBuffer, dpy, context, type, size, num_elements, data, buf_id);  vaStatus = ctx->vtable->vaCreateBuffer( ctx, context, type, size, num_elements, data, buf_id);  VA_TRACE_LOG(va_TraceCreateBuffer,               dpy, context, type, size, num_elements, data, buf_id);  return vaStatus;}

VAStatusvaCreateSurfaces(    VADisplay           dpy,    unsigned int        format,    unsigned int        width,    unsigned int        height,    VASurfaceID        *surfaces,    unsigned int        num_surfaces,    VASurfaceAttrib    *attrib_list,    unsigned int        num_attribs){    VADriverContextP ctx;    VAStatus vaStatus;    CHECK_DISPLAY(dpy);    ctx = CTX(dpy);    if (!ctx)        return VA_STATUS_ERROR_INVALID_DISPLAY;    if (ctx->vtable->vaCreateSurfaces2)        vaStatus = ctx->vtable->vaCreateSurfaces2(ctx, format, width, height,                                              surfaces, num_surfaces,                                              attrib_list, num_attribs);    else if (attrib_list && num_attribs > 0)        vaStatus = VA_STATUS_ERROR_ATTR_NOT_SUPPORTED;    else        vaStatus = ctx->vtable->vaCreateSurfaces(ctx, width, height, format,                                                 num_surfaces, surfaces);    VA_TRACE_LOG(va_TraceCreateSurfaces,                 dpy, width, height, format, num_surfaces, surfaces,                 attrib_list, num_attribs);    return vaStatus;}

/*  vaAssociateSubpicture associates the subpicture with the target_surface.  It defines the region mapping between the subpicture and the target  surface through source and destination rectangles (with the same width and height).  Both will be displayed at the next call to vaPutSurface.  Additional  associations before the call to vaPutSurface simply overrides the association.*/VAStatus vaAssociateSubpicture (    VADisplay dpy,    VASubpictureID subpicture,    VASurfaceID *target_surfaces,    int num_surfaces,    short src_x, /* upper left offset in subpicture */    short src_y,    unsigned short src_width,    unsigned short src_height,    short dest_x, /* upper left offset in surface */    short dest_y,    unsigned short dest_width,    unsigned short dest_height,    /*     * whether to enable chroma-keying or global-alpha     * see VA_SUBPICTURE_XXX values     */    unsigned int flags){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaAssociateSubpicture ( ctx, subpicture, target_surfaces, num_surfaces, src_x, src_y, src_width, src_height, dest_x, dest_y, dest_width, dest_height, flags );}

VAStatusvaQuerySurfaceAttributes(    VADisplay           dpy,    VAConfigID          config,    VASurfaceAttrib    *attrib_list,    unsigned int       *num_attribs){    VADriverContextP ctx;    VAStatus vaStatus;    CHECK_DISPLAY(dpy);    ctx = CTX(dpy);    if (!ctx)        return VA_STATUS_ERROR_INVALID_DISPLAY;    if (!ctx->vtable->vaQuerySurfaceAttributes)        vaStatus = va_impl_query_surface_attributes(ctx, config,                                                    attrib_list, num_attribs);    else        vaStatus = ctx->vtable->vaQuerySurfaceAttributes(ctx, config,                                                         attrib_list, num_attribs);    VA_TRACE_LOG(va_TraceQuerySurfaceAttributes, dpy, config, attrib_list, num_attribs);    return vaStatus;}

VAStatus vaUnlockSurface(VADisplay dpy,    VASurfaceID surface){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaUnlockSurface( ctx, surface );}

VAStatus vaDestroyContext (    VADisplay dpy,    VAContextID context){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaDestroyContext( ctx, context );}

/* * Destroy the subpicture before destroying the image it is assocated to */VAStatus vaDestroySubpicture (    VADisplay dpy,    VASubpictureID subpicture){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaDestroySubpicture ( ctx, subpicture);}

/* * Should call DestroyImage before destroying the surface it is bound to */VAStatus vaDestroyImage (    VADisplay dpy,    VAImageID image){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaDestroyImage ( ctx, image);}

/* Unlocks buffer after usage from external API */VAStatusvaReleaseBufferHandle(VADisplay dpy, VABufferID buf_id){    VADriverContextP ctx;    CHECK_DISPLAY(dpy);    ctx = CTX(dpy);    if (!ctx->vtable->vaReleaseBufferHandle)        return VA_STATUS_ERROR_UNIMPLEMENTED;    return ctx->vtable->vaReleaseBufferHandle(ctx, buf_id);}

VAStatus vaSetSubpictureImage (    VADisplay dpy,    VASubpictureID subpicture,    VAImageID image){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaSetSubpictureImage ( ctx, subpicture, image);}

/* * Subpictures are created with an image associated. */VAStatus vaCreateSubpicture (    VADisplay dpy,    VAImageID image,    VASubpictureID *subpicture	/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaCreateSubpicture ( ctx, image, subpicture );}

/* * Derive an VAImage from an existing surface. * This interface will derive a VAImage and corresponding image buffer from * an existing VA Surface. The image buffer can then be mapped/unmapped for * direct CPU access. This operation is only possible on implementations with * direct rendering capabilities and internal surface formats that can be * represented with a VAImage. When the operation is not possible this interface * will return VA_STATUS_ERROR_OPERATION_FAILED. Clients should then fall back * to using vaCreateImage + vaPutImage to accomplish the same task in an * indirect manner. * * Implementations should only return success when the resulting image buffer * would be useable with vaMap/Unmap. * * When directly accessing a surface special care must be taken to insure * proper synchronization with the graphics hardware. Clients should call * vaQuerySurfaceStatus to insure that a surface is not the target of concurrent * rendering or currently being displayed by an overlay. * * Additionally nothing about the contents of a surface should be assumed * following a vaPutSurface. Implementations are free to modify the surface for * scaling or subpicture blending within a call to vaPutImage. * * Calls to vaPutImage or vaGetImage using the same surface from which the image * has been derived will return VA_STATUS_ERROR_SURFACE_BUSY. vaPutImage or * vaGetImage with other surfaces is supported. * * An image created with vaDeriveImage should be freed with vaDestroyImage. The * image and image buffer structures will be destroyed; however, the underlying * surface will remain unchanged until freed with vaDestroySurfaces. */VAStatus vaDeriveImage (    VADisplay dpy,    VASurfaceID surface,    VAImage *image	/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaDeriveImage ( ctx, surface, image );}

VAStatus vaSetImagePalette (    VADisplay dpy,    VAImageID image,    unsigned char *palette){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaSetImagePalette ( ctx, image, palette);}

VAStatus vaQueryConfigProfiles (    VADisplay dpy,    VAProfile *profile_list,	/* out */    int *num_profiles		/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaQueryConfigProfiles ( ctx, profile_list, num_profiles );}

/* * Global alpha value is between 0 and 1. A value of 1 means fully opaque and * a value of 0 means fully transparent. If per-pixel alpha is also specified then * the overall alpha is per-pixel alpha multiplied by the global alpha */VAStatus vaSetSubpictureGlobalAlpha (    VADisplay dpy,    VASubpictureID subpicture,    float global_alpha){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaSetSubpictureGlobalAlpha ( ctx, subpicture, global_alpha );}

VAStatus vaQueryImageFormats (    VADisplay dpy,    VAImageFormat *format_list,	/* out */    int *num_formats		/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaQueryImageFormats ( ctx, format_list, num_formats);}

/* * vaDeassociateSubpicture removes the association of the subpicture with target_surfaces. */VAStatus vaDeassociateSubpicture (    VADisplay dpy,    VASubpictureID subpicture,    VASurfaceID *target_surfaces,    int num_surfaces){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaDeassociateSubpicture ( ctx, subpicture, target_surfaces, num_surfaces );}

VAStatus vaQueryConfigEntrypoints (    VADisplay dpy,    VAProfile profile,    VAEntrypoint *entrypoints,	/* out */    int *num_entrypoints	/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaQueryConfigEntrypoints ( ctx, profile, entrypoints, num_entrypoints);}

VAStatus vaUnmapBuffer (    VADisplay dpy,    VABufferID buf_id	/* in */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  VA_FOOL_FUNC(va_FoolCheckContinuity, dpy);  return ctx->vtable->vaUnmapBuffer( ctx, buf_id );}

VAStatus vaInitialize (    VADisplay dpy,    int *major_version,	 /* out */    int *minor_version 	 /* out */){    const char *driver_name_env = NULL;    char *driver_name = NULL;    VAStatus vaStatus;    CHECK_DISPLAY(dpy);    va_TraceInit(dpy);    va_FoolInit(dpy);    va_infoMessage("VA-API version %s/n", VA_VERSION_S);    vaStatus = va_getDriverName(dpy, &driver_name);    va_infoMessage("va_getDriverName() returns %d/n", vaStatus);    driver_name_env = getenv("LIBVA_DRIVER_NAME");    if ((VA_STATUS_SUCCESS == vaStatus) &&        driver_name_env && (geteuid() == getuid())) {        /* Don't allow setuid apps to use LIBVA_DRIVER_NAME */        if (driver_name) /* memory is allocated in va_getDriverName */            free(driver_name);        driver_name = strdup(driver_name_env);        vaStatus = VA_STATUS_SUCCESS;        va_infoMessage("User requested driver '%s'/n", driver_name);    }    if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {        vaStatus = va_openDriver(dpy, driver_name);        va_infoMessage("va_openDriver() returns %d/n", vaStatus);        *major_version = VA_MAJOR_VERSION;        *minor_version = VA_MINOR_VERSION;    } else        va_errorMessage("va_getDriverName() failed with %s,driver_name=%s/n",                        vaErrorStr(vaStatus), driver_name);    if (driver_name)        free(driver_name);    VA_TRACE_LOG(va_TraceInitialize, dpy, major_version, minor_version);    return vaStatus;}

/* * If chromakey is enabled, then the area where the source value falls within * the chromakey [min, max] range is transparent */VAStatus vaSetSubpictureChromakey (    VADisplay dpy,    VASubpictureID subpicture,    unsigned int chromakey_min,    unsigned int chromakey_max,    unsigned int chromakey_mask){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaSetSubpictureChromakey ( ctx, subpicture, chromakey_min, chromakey_max, chromakey_mask );}

VAStatus vaBufferSetNumElements (    VADisplay dpy,    VABufferID buf_id,	/* in */    unsigned int num_elements /* in */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  VA_FOOL_FUNC(va_FoolCheckContinuity, dpy);  return ctx->vtable->vaBufferSetNumElements( ctx, buf_id, num_elements );}

/* * The width and height fields returned in the VAImage structure may get * enlarged for some YUV formats. The size of the data buffer that needs * to be allocated will be given in the "data_size" field in VAImage. * Image data is not allocated by this function.  The client should * allocate the memory and fill in the VAImage structure's data field * after looking at "data_size" returned from the library. */VAStatus vaCreateImage (    VADisplay dpy,    VAImageFormat *format,    int width,    int height,    VAImage *image	/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaCreateImage ( ctx, format, width, height, image);}

VAStatus vaGetConfigAttributes (    VADisplay dpy,    VAProfile profile,    VAEntrypoint entrypoint,    VAConfigAttrib *attrib_list, /* in/out */    int num_attribs){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaGetConfigAttributes ( ctx, profile, entrypoint, attrib_list, num_attribs );}

VAStatus vaQueryConfigAttributes (    VADisplay dpy,    VAConfigID config_id,    VAProfile *profile, 	/* out */    VAEntrypoint *entrypoint, 	/* out */    VAConfigAttrib *attrib_list,/* out */    int *num_attribs		/* out */){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  return ctx->vtable->vaQueryConfigAttributes( ctx, config_id, profile, entrypoint, attrib_list, num_attribs);}

VAStatus vaDestroyBuffer (    VADisplay dpy,    VABufferID buffer_id){  VADriverContextP ctx;  CHECK_DISPLAY(dpy);  ctx = CTX(dpy);  VA_FOOL_FUNC(va_FoolCheckContinuity, dpy);  VA_TRACE_LOG(va_TraceDestroyBuffer,               dpy, buffer_id);  return ctx->vtable->vaDestroyBuffer( ctx, buffer_id );}